Summary

This PR introduces a new single-row-required selection mode for st.dataframe. This mode ensures that exactly one row is always selected, mimicking the behavior of a radio button. It auto-selects the first row if no default is provided, prevents clearing the selection, hides the "Clear selection" toolbar button, and uses a circle checkbox style for visual differentiation.

Code Quality

The code changes are well-structured, clear, and follow the existing patterns in the codebase.

• In lib/streamlit/elements/arrow.py, the validation logic correctly groups row selection modes and ensures only one is specified. The auto-selection logic is properly integrated into _validate_selection_state and DataframeSelectionSerde.deserialize.
• In the frontend, useSelectionHandler.ts and useWidgetState.ts appropriately handle the new mode by preventing selection clearing and setting the initial default selection. The changes to DataFrame.tsx correctly update the UI (hiding the clear button and changing the checkbox style).

Test Coverage

The changes are comprehensively tested:

• Python Unit Tests: arrow_dataframe_test.py covers the new selection mode parsing, validation, and auto-selection logic.
• TypeScript Unit Tests: useSelectionHandler.test.ts and useWidgetState.test.ts cover the frontend state management, ensuring that the selection cannot be cleared and that the initial state is correctly loaded.
• E2E Tests: st_dataframe_selections_test.py verifies the end-to-end behavior, including auto-selection, the absence of the clear button, the inability to clear via Escape or clicking the selected row, and visual snapshots for the circle checkbox style.

Backwards Compatibility

This is a non-breaking, additive change. Existing selection modes (single-row, multi-row, etc.) are unaffected. The new mode is mutually exclusive with other row selection modes, which is enforced by validation.

Security & Risk

No security concerns or regression risks were identified. The changes are confined to the dataframe selection logic and do not interact with security-sensitive areas such as routing, authentication, or external assets.

External test recommendation

• Recommend external_test: No
• Triggered categories: None
• Evidence:
  • lib/streamlit/elements/arrow.py: Only modifies dataframe selection state validation and serialization.
  • frontend/lib/src/components/widgets/DataFrame/*: Only modifies frontend selection state management and UI rendering for the dataframe component.
• Suggested external_test focus areas: N/A
• Confidence: High
• Assumptions and gaps: The changes are purely related to the internal state management and UI of the dataframe component and do not touch any external integration points.

Accessibility

The frontend changes rely on glide-data-grid for rendering. The visual change to a circle checkbox (checkboxStyle: "circle") provides a clear visual cue for the radio-like behavior without negatively impacting the existing accessibility of the grid.

Recommendations

The implementation is solid and ready to be merged. No further changes are required.

Verdict

APPROVED: The implementation is complete, well-tested, and follows the project's best practices.

This is an automated AI review by gemini-3.1-pro. Please verify the feedback and use your judgment.

Summary

This PR introduces a new st.dataframe selection mode, "single-row-required", with end-to-end support across protobuf, Python backend validation/serde, frontend selection handling, and e2e snapshots/tests. The intended behavior is radio-like row selection: a row is always selected (defaulting to the first row), selection cannot be cleared, and row markers are rendered with circle style.

Code Quality

I found one blocking behavior issue:

• Sorting path violates required-selection correctness and can desync UI vs backend state in frontend/lib/src/components/widgets/DataFrame/DataFrame.tsx (lines ~932-939 and ~1129-1133) together with frontend/lib/src/components/widgets/DataFrame/hooks/useSelectionHandler.ts (lines ~233-253).
  • Sorting currently calls clearSelection() / clearSelection(false, true) before sort, but clearSelection now forcibly preserves rows when single-row-required is active (effectiveKeepRows = keepRows || isRequiredRowSelectionActivated).
  • Result: the sort flow no longer truly clears row selection for required mode, while the surrounding sort comments explicitly rely on clearing due unsupported row remapping.
  • This creates a high risk of stale display-index selection through sort transitions and inconsistent selected-row semantics (potential mismatch between visible selected row and backend-reported original row index).

Test Coverage

Coverage is generally solid across backend + frontend hook tests + e2e scenarios for default selection, preventing clear, and visual behavior.
However, there is a key missing regression test for the blocking issue:

• No test covers "single-row-required" behavior when sorting via header click and column menu sort.
• Existing single-row sorting behavior is tested, but required-mode sort semantics are not.

Backwards Compatibility

The API change is additive ("single-row-required" and new enum value), so baseline compatibility is good.
That said, current sort behavior in required mode risks functional regressions for users who rely on stable selection semantics during sorting.

Security & Risk

No direct security-sensitive surfaces are modified (no auth/session/websocket handshake/routes/CORS/cookie/header changes).
Primary risk is functional correctness/regression in selection state synchronization when sorting in required mode.

External test recommendation

• Recommend external_test: No
• Triggered categories: None
• Evidence:
  • frontend/lib/src/components/widgets/DataFrame/DataFrame.tsx: widget selection UX/state logic only; no external-origin, routing, auth, websocket transport, or embedding boundary changes.
  • frontend/lib/src/components/widgets/DataFrame/hooks/useSelectionHandler.ts: local selection-state transitions only.
  • lib/streamlit/elements/arrow.py: selection-mode parsing/validation and selection-state serde only.
  • proto/streamlit/proto/Dataframe.proto: additive enum value only.
  • e2e_playwright/st_dataframe_selections_test.py: local widget behavior and snapshot coverage only.
• Suggested external_test focus areas:
  • None required for this diff; prioritize local e2e + unit coverage for sorting/selection-state correctness.
  • If desired defensively, validate required-row selection behavior under embedded iframe host only after local sort semantics are fixed.
• Confidence: High
• Assumptions and gaps: Assessment assumes no hidden changes outside this PR that alter hosting, embedding, auth, routing, websocket transport, or storage behavior.

Accessibility

No accessibility regressions are obvious in this diff.
Hiding the clear button in required mode is consistent with behavior constraints, and row marker circle styling is a visual affordance change without introducing new non-semantic interactive elements.

Recommendations

1. Fix required-mode sorting behavior so selection semantics remain correct after sort (e.g., remap selection by original row identity and sync, or intentionally reselect a deterministic row and sync). Avoid preserving stale display-index selections through sort.
2. Add targeted tests for "single-row-required" sorting paths (both header-click sort and column-menu sort) asserting backend-reported selected row consistency after sort.
3. Update st.dataframe selection_mode docs in lib/streamlit/elements/arrow.py (lines ~659-669) to include "single-row-required" in the public parameter documentation list.

Verdict

CHANGES REQUESTED: The feature is close, but sorting with single-row-required currently has a correctness gap that can produce inconsistent selection behavior and should be fixed before merge.

This is an automated AI review by gpt-5.3-codex-high. Please verify the feedback and use your judgment.

Summary

This PR adds a new "single-row-required" selection mode to st.dataframe that enforces exactly one row to always be selected (radio-like behavior). Key changes:

• Protobuf: Adds SINGLE_ROW_REQUIRED = 6 enum value to Dataframe.proto.
• Backend (Python): Adds "single-row-required" to SelectionMode, introduces _ROW_SELECTION_MODES set for unified row-mode checks, auto-selects first row when no default/selection exists, prevents clearing to empty in serde and validation.
• Frontend (TypeScript): Adds isRequiredRowSelectionActivated derived state in useSelectionHandler, prevents row clearing in processSelectionChange and clearSelection, hides "Clear selection" toolbar button, uses circle checkbox style for visual radio-like appearance, auto-selects first row in loadInitialSelectionState.
• Tests: Python unit tests, TypeScript unit tests, E2E tests (with visual snapshots across browsers).
• Spec: Product spec documenting design decisions and alternatives.

Code Quality

The implementation is well-structured and follows existing patterns throughout the codebase. The layered approach (proto -> backend -> frontend) is clean, and the _ROW_SELECTION_MODES set is a good refactor to centralize row-mode checks.

Specific notes:

1. Minor inefficiency in processSelectionChange (useSelectionHandler.ts, lines 164-185): The syncSelection flag is computed before the single-row-required prevention logic fires. When a user attempts to clear the selection (e.g., clicking the selected row), rowSelectionChanged is true and syncSelection is true, but the prevention logic restores the old rows. This causes syncSelectionState to be called with unchanged data. While likely harmless (the widget manager should deduplicate), it's a wasteful no-op sync that could in edge cases trigger an unnecessary rerun. Consider recomputing syncSelection after the prevention block, or short-circuiting early.

2. DataframeSelectionSerde fields (arrow.py, lines 198-199): The is_required_row_mode and num_rows fields on the dataclass are clean. However, num_rows is somewhat generic and could cause confusion since the serde is only concerned with it for the required-row fallback. A comment or more specific name (e.g., _num_rows_for_required_fallback) might help, though the current naming is acceptable.

3. Spec file: The specs/2026-03-10-single-row-required-selection/product-spec.md file is a nice addition for documenting design decisions. It's well-written and thorough.

Test Coverage

Python unit tests (arrow_dataframe_test.py): Good coverage of the new mode, including:

• Selection mode parsing (single and combined)
• Invalid mode combinations (single-row-required + single-row, single-row-required + multi-row)
• Auto-selection of first row when empty
• Preservation of valid existing selection
• Empty dataframe edge case
• Limiting to single row

TypeScript unit tests (useSelectionHandler.test.ts): Good coverage including:

• Detection of single-row-required mode
• Preventing clearing row selection
• Allowing changing row selection
• clearSelection preserving rows

Gaps identified:

1. Missing useWidgetState test for auto-selection: The useWidgetState.test.ts changes only add isRequiredRowSelectionActivated: false to existing test calls. There is no new test case for isRequiredRowSelectionActivated: true to verify that loadInitialSelectionState auto-selects the first row when no stored selection or default exists. This is a meaningful coverage gap for the frontend auto-selection path.

2. Missing typing test: lib/tests/streamlit/typing/dataframe_types.py does not include an assert_type test for selection_mode="single-row-required". Since this is a new literal value in the SelectionMode type alias, it should be verified.

E2E tests (st_dataframe_selections_test.py): Two well-structured tests covering:

• Behavior (auto-selection, no clearing, selection change, negative assertions)
• Visual snapshot (circle checkbox style)

The E2E test uses wait_for_timeout in three places (200ms, 200ms, 250ms). The comments justify this as necessary because glide-data-grid renders to canvas and selection state isn't observable via DOM for negative assertions. This is acceptable per the E2E guidelines but could be a flakiness risk in slow CI. Consider increasing the timeouts slightly or using wait_until with a polling approach where possible.

Backwards Compatibility

This change is fully backwards compatible:

• The protobuf change is additive (new enum value SINGLE_ROW_REQUIRED = 6). Existing values are unchanged.
• The new "single-row-required" selection mode is opt-in; existing "single-row" and "multi-row" modes are unaffected.
• The _ROW_SELECTION_MODES refactor doesn't change existing behavior — it centralizes the set of row modes that were previously checked inline.
• The SelectionMode type alias now includes "single-row-required", which is additive and won't break existing code.

Security & Risk

No security concerns identified:

• No changes to routing, auth, cookies, CSRF, or session handling.
• No changes to WebSocket communication (only a new protobuf enum value).
• No new dependencies added.
• No file upload/download, asset serving, or path traversal changes.
• No HTML/Markdown rendering or sanitization changes.
• No eval, exec, subprocess, or similar injection vectors introduced.
• The changes are purely within the dataframe selection handling logic.

External test recommendation

• Recommend external_test: No
• Triggered categories: None
• Evidence:
  • proto/streamlit/proto/Dataframe.proto: Additive enum value only, no wire protocol changes
  • lib/streamlit/elements/arrow.py: Pure selection logic within dataframe widget, no routing/auth/network changes
  • frontend/lib/src/components/widgets/DataFrame/: UI selection handling only, no embedding/iframe/postMessage changes
• Suggested external_test focus areas: N/A
• Confidence: High
• Assumptions and gaps: None. This is a self-contained feature addition to the dataframe widget with no external system integration, no cross-origin behavior, no security header changes, and no embedding/iframe implications.

Accessibility

• The change uses checkboxStyle: "circle" for row markers in single-row-required mode, which provides visual differentiation from square checkboxes (radio-like appearance). This is a valid visual cue for the different selection semantics.
• The "Clear selection" toolbar button (which has label="Clear selection" for accessibility) is correctly hidden when it would be non-functional.
• No new interactive elements are introduced that would need additional ARIA labels.
• The existing keyboard handling (Escape key) is properly intercepted via the processSelectionChange prevention logic rather than by adding new keyboard event handlers, maintaining existing accessibility patterns.

Recommendations

1. Add a useWidgetState unit test for auto-selection: Add a test case in useWidgetState.test.ts where isRequiredRowSelectionActivated: true, no stored widget value exists, and no selectionDefault is set, verifying that loadInitialSelectionState returns a selection with row 0 and syncs it to the widget manager.

2. Update the selection_mode docstring: The parameter docstring at lib/streamlit/elements/arrow.py line 659 lists all modes except "single-row-required". Add it to both the parameter type annotation line and the bullet list description:

   selection_mode : "single-row", "single-row-required", "multi-row", ...
   

   And add a bullet:

   - "single-row-required": Exactly one row must always be selected (radio-like). Auto-selects the first row if no default is given.
   

3. Add a typing test: Add an assert_type call in lib/tests/streamlit/typing/dataframe_types.py for selection_mode="single-row-required" to verify the new literal value is accepted by the type system.

4. Consider fixing the unnecessary sync: In processSelectionChange (useSelectionHandler.ts), after the single-row-required prevention block restores old rows, the syncSelection flag is still true. Consider adding a check after prevention to skip the sync if the final selection equals the current selection, e.g.:

   const actualRowChanged = !isEqual(
     updatedSelection.rows.toArray(),
     gridSelection.rows.toArray()
   )

   This prevents unnecessary backend syncs when the user attempts to clear in single-row-required mode.

Verdict

CHANGES REQUESTED: Solid, well-structured feature implementation with good test coverage across all layers. The main gaps are a missing docstring update for the new selection mode (item 2 — users won't discover the feature without it), a missing useWidgetState unit test for the auto-selection path (item 1), and a missing typing test (item 3). Items 1-3 should be addressed before merging; item 4 is a nice-to-have improvement.

This is an automated AI review by opus-4.6-thinking.

Summary

This PR introduces a new single-row-required selection mode for st.dataframe. This mode ensures that exactly one row is always selected, providing a radio-like behavior. It automatically selects the first row if no default is provided, prevents clearing the selection, and uses a circular checkbox style to visually differentiate it from standard multi-select checkboxes.

Code Quality

The code changes are clean, well-structured, and follow the existing patterns in the codebase.

• The frontend logic in useSelectionHandler.ts correctly intercepts selection changes to prevent clearing the row selection.
• The default state handling in useWidgetState.ts and the backend _validate_selection_state function are robust and handle edge cases (like empty dataframes) appropriately.
• The use of pendingRowSelectionRemapRef in DataFrame.tsx is a pragmatic and effective way to preserve the selected row's data mapping when the user sorts a column.

Test Coverage

Test coverage is excellent.

• Python Unit Tests: arrow_dataframe_test.py covers the new selection mode parsing, validation, and auto-selection logic, including edge cases like empty dataframes.
• TypeScript Unit Tests: useSelectionHandler.test.ts and useWidgetState.test.ts thoroughly test the new mode's behavior, including preventing selection clearing and auto-selecting the first row.
• E2E Tests: st_dataframe_selections_test.py includes comprehensive Playwright tests that verify the visual style (via snapshots), auto-selection, interaction behavior (preventing deselection), and the preservation of selection during column sorting.

Backwards Compatibility

The changes are fully backwards compatible. The new single-row-required mode is an opt-in feature. The validation logic for existing selection modes (single-row and multi-row) remains functionally identical, with only a minor improvement to the exception message when multiple row selection modes are provided.

Security & Risk

No security concerns or regression risks identified. The changes are confined to the dataframe element's frontend and backend state management and do not interact with security-sensitive areas such as routing, authentication, or cross-origin behavior.

External test recommendation

• Recommend external_test: No
• Triggered categories: None
• Evidence:
  • The changes are strictly limited to the st.dataframe element's selection state logic and visual rendering (lib/streamlit/elements/arrow.py, DataFrame.tsx, and associated hooks).
• Confidence: High
• Assumptions and gaps: None

Accessibility

The frontend changes include a thoughtful accessibility improvement: using checkboxStyle: "circle" for the single-row-required mode. This provides users with the standard visual paradigm for single-choice selection (radio button appearance), distinguishing it from the multi-choice square checkboxes.

Recommendations

None. The implementation is solid and ready for merge.

Verdict

APPROVED: The implementation of the single-row-required selection mode is robust, well-tested, and follows best practices.

This is an automated AI review by gemini-3.1-pro. Please verify the feedback and use your judgment.

Summary

This PR adds a new st.dataframe selection mode, single-row-required, across protobuf, Python API validation/serde, frontend selection handling, and end-to-end/unit/type tests. The implementation enforces exactly one selected row (auto-select row 0 when needed), prevents clearing that row, preserves selection across sort in the required mode, and updates row-marker visuals to a radio-like circle style.

Code Quality

The implementation is cohesive and follows existing patterns across backend validation (_validate_selection_state), frontend hooks (useSelectionHandler, useWidgetState), and DataFrame UI orchestration (DataFrame.tsx). I found no blocking correctness issues in the changed logic paths.

One non-blocking docs consistency nit:

• lib/streamlit/elements/arrow.py (around lines 112-115) still states that row selections reset after sorting; this is no longer universally true with single-row-required (sorting now preserves the selected data row in that mode).

Test Coverage

Coverage is strong and multi-layered for this change:

• Python unit tests extend selection mode parsing/validation and required-row behavior in lib/tests/streamlit/elements/arrow_dataframe_test.py.
• Frontend hook tests add required-row behavior checks in frontend/lib/src/components/widgets/DataFrame/hooks/useSelectionHandler.test.ts and initial-state auto-selection coverage in frontend/lib/src/components/widgets/DataFrame/hooks/useWidgetState.test.ts.
• E2E coverage in e2e_playwright/st_dataframe_selections_test.py validates:
  • initial auto-selection,
  • inability to clear required row,
  • sort preservation behavior,
  • combined single-row-required + multi-column scenarios,
  • visual snapshot behavior (including new snapshots for all browsers).
• Typing coverage is updated in lib/tests/streamlit/typing/dataframe_types.py.

Given the scope, this is sufficient for merge confidence.

Backwards Compatibility

No breaking API changes were identified:

• Existing selection modes remain unchanged.
• New protobuf enum value is appended (SINGLE_ROW_REQUIRED = 6), preserving previous enum numeric values.
• Validation changes only tighten invalid row-mode combinations involving the new mode.

Behavioral change is additive and opt-in via selection_mode="single-row-required".

Security & Risk

No security-sensitive surfaces were modified (no auth/session routing, cookies/CSRF, asset handlers, external fetches, dynamic code execution, or sensitive data handling changes). Risk is primarily functional UI/state synchronization, and current tests cover those paths well.

External test recommendation

• Recommend external_test: No
• Triggered categories: None
• Evidence:
  • frontend/lib/src/components/widgets/DataFrame/DataFrame.tsx: selection/sorting UI state handling only; no routing/auth/embed/cross-origin logic.
  • frontend/lib/src/components/widgets/DataFrame/hooks/useSelectionHandler.ts: in-memory selection invariants only.
  • lib/streamlit/elements/arrow.py: selection-mode parsing and state validation only; no server endpoint/auth/header changes.
  • proto/streamlit/proto/Dataframe.proto: additive enum for widget selection mode only.
• Suggested external_test focus areas:
  • None required for this PR specifically.
• Confidence: High
• Assumptions and gaps: Assessment is based on the PR diff only; no runtime validation against externally hosted/embedded deployments was executed in this review.

Accessibility

No clear accessibility regressions were found in this diff. The change mainly affects canvas-rendered row marker styling (square -> circle) and selection state logic, not semantic DOM controls. Toolbar behavior remains label-based (Clear selection action), and hiding that action in required-row mode does not remove an alternate required user path.

Recommendations

1. Update the stale warning text in lib/streamlit/elements/arrow.py (around lines 112-115) to clarify that sort-clearing behavior does not apply to single-row-required.

Verdict

APPROVED: The feature implementation is coherent, well-tested across backend/frontend/e2e layers, and appears ready to merge with only a minor documentation consistency follow-up.

This is an automated AI review by gpt-5.3-codex-high. Please verify the feedback and use your judgment.

Summary

This PR adds a new single-row-required selection mode to st.dataframe, providing radio-like row selection behavior where exactly one row must always be selected. Key changes:

• Protobuf: New SINGLE_ROW_REQUIRED = 6 enum value in Dataframe.proto.
• Backend (Python): New "single-row-required" literal in SelectionMode, a _ROW_SELECTION_MODES set for centralized row-mode checks, auto-selection of row 0 when no default is provided, and validation that at most one row mode is active.
• Frontend (TypeScript): useSelectionHandler prevents clearing the row selection and exposes isRequiredRowSelectionActivated; useWidgetState auto-selects row 0 on initial load; DataFrame.tsx hides the "Clear selection" toolbar button, uses circle checkbox style, and preserves row selection across column sorts via a ref-guarded useEffect.
• Tests: Python unit tests, TypeScript unit tests, typing tests, and E2E (Playwright) tests covering auto-selection, no-clear invariant, sort preservation, combined mode, and visual snapshots.

Code Quality

The code is well-structured and follows existing patterns in the codebase.

Strengths:

• The _ROW_SELECTION_MODES set (lib/streamlit/elements/arrow.py:95-99) is a good refactoring that centralizes row-mode checks and avoids repeating mode string comparisons.
• The clearSelection override via effectiveKeepRows (useSelectionHandler.ts:244) is clean and minimal.
• The processSelectionChange guard for preventing row clearing (useSelectionHandler.ts:176-187) is correctly placed and handles combined modes (row required + column selection) properly, including the actualSyncNeeded logic to still sync column/cell changes.
• Validation error messages are now dynamic (arrow.py:287-289), which is more helpful.

Minor observations:

1. useEffect dependency array breadth (DataFrame.tsx:416-421): The row-remapping effect depends on gridSelection and processSelectionChange. Since processSelectionChange is rebuilt on every gridSelection change, this effect fires on every selection change—not just sorts. The ref guard (pendingRowSelectionRemapRef.current === null) correctly prevents unnecessary work, but per the frontend AGENTS.md guidance to "keep dependency arrays minimal," consider whether getOriginalIndex alone (plus the ref guard) would suffice, since the ref is only set in the sort handler and getOriginalIndex is the signal that the sort has been applied.

2. E2E test wait_for_timeout usage (st_dataframe_selections_test.py:143,156,165): The test uses wait_for_timeout(200) and wait_for_timeout(250) which is discouraged by the E2E AGENTS.md. The justification (canvas-based rendering makes selection state not DOM-observable) is valid, but this may introduce flakiness in slower CI environments. The comments explaining the rationale are appreciated.

Test Coverage

Test coverage is thorough and well-organized across all layers:

• Python unit tests (arrow_dataframe_test.py): Cover auto-selection of row 0, preservation of existing selection, empty dataframe handling, row limiting to 1, mode parsing, and invalid mode combinations (single-row-required + single-row or multi-row).
• TypeScript unit tests (useSelectionHandler.test.ts, useWidgetState.test.ts): Cover mode detection, preventing row clearing, allowing row changes, clearSelection preservation, combined mode with column selection, and auto-selection on initial load.
• Type tests (dataframe_types.py): Verify the new mode string is accepted by the type checker.
• E2E tests (st_dataframe_selections_test.py): Cover auto-selection on load, Escape key not clearing, re-clicking same row not deselecting, changing to a different row, sort preservation, combined row+column mode with programmatic changes, visual snapshot.
• Negative assertions: Tests properly assert that clearing does NOT happen (e.g., not_to_contain_text("'rows': []"), expect(syncSelectionStateMock).toBeCalledTimes(1) not incrementing).

The E2E sort test (test_single_row_required_select_and_sort) asserts that some row remains selected after sorting but doesn't verify it's the correct row (the one that was selected before sort). This is pragmatic given the data-dependent nature of sorting, though a more precise assertion would strengthen confidence.

Backwards Compatibility

No backwards compatibility concerns:

• The protobuf enum SINGLE_ROW_REQUIRED = 6 is purely additive; existing values (0-5) are unchanged.
• The SelectionMode type alias adds a new literal without modifying existing ones.
• All existing selection modes continue to work identically.
• The validation now uses a centralized _ROW_SELECTION_MODES set, but the behavior for existing modes is preserved.
• The row-mode conflict check was generalized from checking {"single-row", "multi-row"} to checking len(row_modes) > 1, which correctly covers all combinations.

Security & Risk

No security concerns identified:

• Changes are confined to UI selection logic—no new endpoints, auth changes, or external requests.
• No HTML/Markdown rendering or sanitization changes.
• No new dependencies added.
• The auto-select behavior only affects the first row (index 0) and is constrained by existing validation.

External test recommendation

• Recommend external_test: No
• Triggered categories: None
• Evidence:
  • proto/streamlit/proto/Dataframe.proto: Additive enum value only, no routing/transport changes.
  • lib/streamlit/elements/arrow.py: Selection mode logic, no server/auth/embedding changes.
  • frontend/lib/src/components/widgets/DataFrame/: UI component changes within existing widget framework, no cross-origin, iframe, or asset-serving changes.
• Suggested external_test focus areas: None required.
• Confidence: High
• Assumptions and gaps: Assumes the dataframe widget's WebSocket message handling is not affected by the new enum value in external/embedded contexts (confirmed by reviewing the protobuf and widget state serialization code).

Accessibility

• The circle checkbox style (checkboxStyle: "circle" at DataFrame.tsx:1075) provides visual differentiation for the radio-like behavior, which is appropriate UX semantics.
• Since glide-data-grid renders to a <canvas> element, standard ARIA attributes don't apply to individual rows. The grid's built-in accessibility handling is unchanged.
• The "Clear selection" toolbar button is correctly hidden (not just disabled) for this mode, preventing user confusion.
• No new interactive elements introduced outside the canvas, so no additional a11y requirements.

Recommendations

1. Consider narrowing the useEffect dependency array for the row-remapping effect in DataFrame.tsx (lines 416-421). The current dependencies (getOriginalIndex, originalNumRows, gridSelection, processSelectionChange) cause the effect to fire on every selection change. Since the ref guard prevents all non-sort executions, this is functionally correct but adds unnecessary overhead. If getOriginalIndex reliably changes only when sorting occurs, it may be sufficient as the sole trigger alongside the ref check.

2. Strengthen the E2E sort preservation test (test_single_row_required_select_and_sort): Consider asserting the exact row index after sort, not just that a row is selected. This would validate that the remap logic correctly tracks the original data row through the sort.

3. Minor: The useWidgetState.test.ts test at line 809 ("auto-selects first row in single-row-required mode when no stored selection or default") is missing a blank line before it that other test cases have—just a formatting nit.

Verdict

APPROVED: Well-implemented feature with thorough test coverage across all layers, no backwards compatibility or security concerns, and clean integration with existing selection infrastructure. The minor suggestions above are non-blocking refinements.

This is an automated AI review by opus-4.6-thinking.

frontend/lib/src/components/widgets/DataFrame/DataFrame.tsx (line 1169)
issue: The column-menu sort handler does not remap the row selection in single-row-required mode. The header-click handler (line 965) captures original row indices into pendingRowSelectionRemapRef before sorting, so the useEffect at line 385 can find the new display index for the same data row. This handler skips that step — clearSelection(false, true) preserves the display index (thanks to effectiveKeepRows), but after sorting, that display index now points to a different underlying data row. Please apply the same remap logic here, e.g.:

if (isRequiredRowSelectionActivated && isRowSelected) {
  const originalRowIndices = gridSelection.rows.toArray().map(getOriginalIndex)
  pendingRowSelectionRemapRef.current = originalRowIndices
  clearSelection(true, true)
} else if (isRowSelectionActivated && isRowSelected) {
  clearSelection(false, true)
} else {
  clearSelection(true, true)
}

e2e_playwright/st_dataframe_selections_test.py (line 209)
suggestion: This test asserts that some row remains selected after sort (not_to_contain_text("'rows': []")) but doesn't verify which specific row. Consider asserting the expected row index based on the known sort order to provide stronger regression coverage — e.g., original row 0 should map to a known position after ascending sort on col_0.

frontend/lib/src/components/widgets/DataFrame/DataFrame.tsx (line 417)
thought: This useEffect dependency array includes gridSelection and processSelectionChange, which means it re-runs on every selection change — not just sorts. The pendingRowSelectionRemapRef null-check guard makes this safe, but it fires more often than strictly necessary. An alternative would be to track the sort operation itself as the trigger (e.g., a sort counter ref), but the current approach is pragmatic and correct.

e2e_playwright/st_dataframe_selections_test.py (line 144)
nitpick: wait_for_timeout(200) is discouraged by the E2E guidelines. The comment explains why it's needed (canvas rendering), but consider using wait_until with a callback that checks the expected state instead, which would be more robust against timing variations.