diff --git a/.claude/rules/data-grid.md b/.claude/rules/data-grid.md
index 3a88677def..0686c9cf17 100644
--- a/.claude/rules/data-grid.md
+++ b/.claude/rules/data-grid.md
@@ -1,21 +1,68 @@
 ---
 paths:
-  - "apple/TablePro/Views/Results/**/*"
+  - "apple/TablePro/Views/DataGrid/**/*"
   - "apple/TablePro/Core/DataGrid/**/*"
+  - "apple/TablePro/Views/Results/**/*"
+  - "apple/TableProTests/Views/DataGrid/**/*"
+  - "apple/TableProTests/Core/DataGrid/**/*"
   - "apple/TableProTests/Views/Results/**/*"
 ---
 
 # Data grid
 
-- **Selection indices are display positions**, not `TableRows.rows` indices. Resolve them through `DisplayRowMapping` (or `TableViewCoordinator.displayRow(at:)` and `tableRowsIndex(forDisplayRow:)`) before reading or changing a row; they match only while no sort or value filter applies.
-- **Cells are drawn, not mounted.** `tableView(_:viewFor:row:)` returns nil for data columns and `DataGridRowView` draws the visible cells, and every column stays attached. Never hide off-screen columns with `NSTableColumn.isHidden`: each write costs O(attached columns).
-- **Find data columns through `DataGridColumnPool.presentsColumn` and `firstPresentedColumnIndex`**, never a fixed index into `tableColumns` (the row-number column and pool slots sit there too).
-- **The header draws all of its own chrome** through `SortableHeaderChrome`: the cell never calls `super.draw`, and `highlightedTableColumn` stays unset, because AppKit paints a fixed-height band that does not fit the taller header. Sort state goes through `SortableHeaderView.applySortState(_:schema:)`, which also sets each header cell's accessibility sort direction.
-- **A themed header draws its own cells.** `NSTableHeaderView.draw` paints AppKit's band over the header fill before the cells, so while `dataGrid.headerBackground` is themed `SortableHeaderView` draws each column's header cell itself, the dragged one included; an unthemed header keeps `super.draw`.
-- **Row selection is `NSTableRowView`'s own** unless the theme overrides `gridSelection` or `gridInactiveSelection`, so the default theme follows Accent and focus. The gutter and a selected column heading read `DataGridBodyChrome.selectionColor(emphasized:scope:)` so they match the row. A theme change repaints visible rows; it never reloads data.
-- **A translucent theme selection is flattened once.** The row, the gutter and a heading sit on three different bases, so `DataGridBodyChrome.themedSelectionColor(emphasized:scope:)` lays the selection over the grid background and all three paint that opaque color with any alpha.
-- **A range outline stays apart from its fill.** Natively a multi-cell range is outlined in the selection color at 70%. Under a themed `dataGrid.selection` that outline would vanish into the opaque fill, so `GridSelectionOverlay.rangeBorderColor(_:)` takes the active cell's border color instead (`dataGrid.focusBorder`, else Accent) at 70%.
-- **The grid reads its colors through its `ThemeScope`.** `DataGridView(themeScope:)` hands it to `TableViewCoordinator`, and every grid color read goes through `coordinator.themeScope`, `KeyHandlingTableView.themeScope` and `SortableHeaderView.themeScope` included. `ThemeEngine.shared` supplies only the fonts and the cache counters that follow a system color change. A new scope repaints in place with no reload. Read `scope.resolved` once per draw, not once per cell. Scopes: `.claude/rules/theme.md`.
-- **`gridStyleMask` stays empty; `DataGridBodyChrome` draws column separators and the stripes.** AppKit's vertical grid lines add one subview per column and make every layout pass quadratic. Take separator positions from `presentsColumn` and `rect(ofColumn:)`.
-- **Scroll the grid with `NSView.scroll(_:)`**, never `clipView.scroll(to:)` plus `reflectScrolledClipView`, which leaves the header behind.
-- **Accessibility goes through `DataGridCellAccessibilityView`**, mounted for on-screen rows once `DataGridAccessibility.isActive`; `NSTableView` builds its cell tree from views only. Keep that path working whenever row drawing changes.
+Three layers, knowledge pointing one way: an owner's adapter, then `DataGridModel` (`Core/DataGrid`), then the AppKit view (`Views/DataGrid`). The value editors and viewers stay in `Views/Results`.
+
+## Model
+
+- **`DataGridModel` holds the grid's state** and outlives every mount: column set, row order, selection, sort, value filter, column layout, display formats, find and the edit session. Its owner holds it strongly; the data tab keeps one per tab on `MainContentCoordinator`.
+- **An owner talks to the model, never to the view.** It implements `DataGridDataSource` and `DataGridActions` in an adapter class and calls `reloadRows()` when its rows were replaced or `apply(_ delta:)` when they changed. The model keeps the selection by identity and sends the mounted view one `DataGridChange`.
+- **Rows are `RowID`, columns are `DataGridColumnID`.** `DataGridRowOrder` maps display rows, and `DataGridColumnSet` is the only converter between data index, display position and pane. A bare `Int` is a display position, valid only inside one call: capture the IDs before a popover, a sheet or an `await`.
+- **Every edit is one `model.commit(_:actionName:)`** of `DataGridCellEdit`s, taken by IDs when the gesture began. A command over many cells is one call, so one undo step.
+- **The selection is `model.selection`, changed through `GridSelectionReducer`**, a pure engine in `Core/DataGrid/Engine` with its own tests. The tables' `selectedRowIndexes` mirror the rows it spans; a change AppKit makes itself (Up, Down, type-select) goes through `rowsSelectedNatively` first.
+- **A selection says what it is in `GridSelection.Mode`**: a click selects the row with the cell cursor on the clicked cell (`.cursor`), a drag, Shift or Command gesture makes a cell range (`.cells`), and row numbers or Select All pick rows (`.rows`). Copy, Delete and the row commands read the mode, never the rectangle's shape.
+- **What a grid offers is `configuration.commands`.** Menus and validation read it, because a defaulted protocol method cannot be detected at runtime.
+- **State persists through `model.store`.** Only the data tab of a real, non-temporary table has `layoutScope` `.table`; every other grid is `.ephemeral` and never writes a table's saved layout or display formats.
+
+## Panes
+
+- **Two tables, one grid.** The main pane's `DataGridTableView` holds every column, the row numbers first. The frozen pane is a second table laid over the main pane's leading edge, showing the row numbers and the frozen columns. Keys, find, copy and VoiceOver work on the main table.
+- **The main table is the only first responder.** The frozen table refuses it and hands its presses to the controller. `DataGridContainerView.gridHasFocus` is the one focus flag: both panes' row views take `isEmphasized` from it, and so does the active-cell border.
+- **Row height, row count, reloads, inserts and removes reach both panes in one call**, so their document heights never differ.
+- **Vertical scroll stays in step through bounds-change notifications**: each pane's clip moves the other with `clipView.scroll(to:)` and `reflectScrolledClipView`, only when its y differs. Anywhere else scroll with `NSView.scroll(_:)`: moving a clip's x that way leaves the header behind.
+- **The frozen pane forwards every wheel event to the main scroll view**, so one momentum engine moves both.
+- **Frozen columns take at most two thirds of the grid** (`DataGridMetrics.maximumFrozenShare`). Columns past that scroll, and Freeze Up to This Column is refused in the menu.
+- **`DataGridTableView.scrollToVisible(_:)` widens the rect leftward by the frozen width**, so a revealed column never parks under the frozen pane.
+- **A column moves only within its side of the freeze line.** A freeze or unfreeze rebuilds both panes' column lists from the set, writing width and position explicitly: remove-then-add alone strands a column at the end and resets its width.
+
+## Cells
+
+- **Cells are drawn, not mounted.** `DataGridRowView` draws its pane's cells through `DataGridCellRenderer`. `tableView(_:viewFor:row:)` returns nil except for the cell being edited and the accessibility stand-ins: a view per cell costs 45 ms a frame at 1,000 rows by 200 columns against 1.5 ms drawn.
+- **A change repaints, it never reloads.** It reaches pixels as `needsDisplay` on the row views it names. `reloadData(forRowIndexes:columnIndexes:)` only mounts or unmounts a cell view, since reloading an edited row ends the edit. A full `reloadData()` drops the table selection without telling anyone, so the controller writes it back.
+- **Every column stays attached.** Never hide an off-screen column with `NSTableColumn.isHidden`: each write costs O(attached columns). Columns come from each pane's pool, keyed by `DataGridColumnID`, so a re-run of the same result does not flicker (#951).
+- **Resolve a table column through `DataGridPane.slot(atTableIndex:columns:)` and `tableIndex(forDisplayPosition:columns:)`**, never a fixed index into `tableColumns`: the row-number column sits first and the frozen pane holds a subset.
+- **`gridStyleMask` stays empty.** AppKit's vertical grid lines keep a subview per column (518 ms a layout at 500 columns). `DataGridBodyChrome` draws the separators in each row, and the stripes and separators past the last row.
+- **Selection is the system's.** `drawSelection(in:)` fills the whole row in a row selection and the selected columns' span in a cell range: `selectedContentBackgroundColor` when emphasized, else `unemphasizedSelectedContentBackgroundColor`. The active cell is an inner stroke in `keyboardFocusIndicatorColor`, 2 pt with focus and 1 pt without, in the selected text color over an emphasized fill. No outline goes round a range.
+- **Never draw the active cell with the focus ring API.** From a row view the ring loses its top and bottom; on an `NSTableView` it draws nothing.
+- **Colors come from `model.themeScope`**, read once per draw. A theme, Accent or Increase Contrast change repaints the visible rows and never reloads data. `ThemeEngine.shared` supplies only the fonts. No theme slot colors the header, the selection, selected text or the active-cell border (`.claude/rules/theme.md`).
+- **The row view draws the column a header drag is moving**, at the header's `draggedDistance`: drawn cells have no views for AppKit to float.
+
+## Header
+
+- **Stock `NSTableHeaderView` and `NSTableHeaderCell`.** `DataGridHeaderView` overrides only `menu(for:)` and `viewWillDraw`, which repaints the body on each step of a column drag. AppKit draws the primary sort arrow; the controller sets each header cell's `accessibilitySortDirection`, which AppKit leaves unknown.
+- **The model's sort is the source.** `tableView.sortDescriptors` is written from `store.sortState` under `isApplyingSortDescriptors`, because an assignment inside the callback fires it again. A plain click keeps only the clicked key and flips it on a repeat; an Option-click keeps the key AppKit appended (`HeaderSortCycle`). Shift-click reaches no sort callback, and Command-click selects the column.
+- **Header text is the column name.** The type, the comment and, while several keys sort, the sort order go in `headerToolTip`; an active value filter adds a funnel symbol attachment to the title, in the header text color.
+
+## Keyboard, mouse and menus
+
+- **Behavior comes from responder actions, never key codes.** `keyDown` sends Return, Enter, Tab, Backtab, Delete, Forward Delete, Left, Right, and Shift-Up or Shift-Down over a cell range through `interpretKeyEvents`. Everything else goes to `super`, which keeps AppKit's row movement and type-select.
+- **A modifier test masks `.capsLock` and `.function`**: compare within `[.command, .shift, .option, .control]` only. Forward Delete carries `.function`.
+- **Copy, Paste, Delete, Select All, Find, Copy Special, Set Value and zoom are actions the grid answers itself**, with `NSMenuItemValidation`, so they work in every window. The context menu's Paste takes the keyboard's path. A window's own handler runs only while the grid is not focused.
+- **The context menu is built from `clickedRow` and `clickedColumn`** in `menuNeedsUpdate(_:)`. It acts on the selection when the clicked cell is inside it, else on the clicked cell or row; the selection never moves.
+- **A press in either pane resolves to one `GridCoord`** through the container and the column set. A drag autoscrolls the main pane and crosses panes.
+
+## Accessibility
+
+- **AppKit builds the AXCell tree from cell views only**, so while `DataGridAccessibility.isActive` the main table mounts a `DataGridAccessibilityCellView` (identifier `data-grid-cell`) for each on-screen cell. It draws nothing and takes no clicks. Keep that path working whenever row drawing changes.
+- **A label reads "Row N, column M: value"**: N is the row number on screen, page offset included, and M the display position. UI tests find cells by it (`.claude/rules/ui-tests.md`, The grid).
+- **The frozen pane is hidden from accessibility.** A frozen column's stand-in in the main table reports the frame the frozen pane shows it at.
+- **Only the viewport mounts.** Mounting for every row starved the main thread behind a 1,000-row page (#2392); rows scrolled into view remount.
diff --git a/.claude/rules/theme.md b/.claude/rules/theme.md
index a09169dd46..d552dbcc44 100644
--- a/.claude/rules/theme.md
+++ b/.claude/rules/theme.md
@@ -19,8 +19,9 @@ paths:
 
 - `TableProTheme` is Foundation only, so the iOS app can adopt it; AppKit and SwiftUI code stays in `apple/TablePro/Theme`.
 - **`ThemeSlot` is the one registry.** A slot exists only while a view reads it: removing its last reader removes the slot.
-- `isOverridden(_:)` means the slot draws a theme color, set or derived: ask it before swapping a native drawing path (row selection, caret, header). Only the theme editor asks `hasExplicitColor(_:)`.
-- **Adding a slot bumps `ThemeSchema.current`.** The decoder reads every schema from 3 up and refuses a newer one or an unknown key, rather than load a file without colors its author wrote. The bump renames the sync content kind (Sync).
+- `isOverridden(_:)` means the slot draws a theme color, set or derived: ask it before swapping a native drawing path (a code table's selection, the caret). Only the theme editor asks `hasExplicitColor(_:)`.
+- **Adding a slot bumps `ThemeSchema.current`.** `ThemeFileFormat` reads only the current schema: an older or newer one, or an unknown key, is refused rather than loaded without colors its author wrote, so a bump stops every older file from loading. The bump renames the sync content kind (Sync).
+- **Removing a slot never bumps the schema.** Its key joins `ThemeFileFormat.retiredKeys`, which the decoder drops, so a file that still carries it loads without it.
 - **An imported file is untrusted.** `ThemeFileImporter` checks the size before it reads, mints a fresh id every time, and never follows a VS Code `include` out of the file's folder.
 
 ## Reading colors
@@ -28,7 +29,7 @@ paths:
 - **A scoped carrier reads through its `ThemeScope`, never `ThemeEngine.shared`.** Only the theme editor preview uses `.fixed(_:)`, and a new definition is a new scope.
 - `palette.color(_:otherwise:)` returns a new object on every call: never compare it to skip a write. Bake `resolved` into a `CGColor` only inside the drawing view's appearance (`resolved.cgColor(_:otherwise:in:)`).
 - **Hold every AppKit carrier** (`ThemeTextViewStyle`, `ThemeTableChrome`, never on a source list) **as a stored property.** Its subscription and row views hold it weakly, so one held in a local stops at the first theme change.
-- `NSTableHeaderView` paints over anything beneath it, so `ThemeTableChrome` swaps in `ThemeTableHeaderView` while the header is themed.
+- **Header and selection are always the system's.** No slot colors a table header, a records row's selection or its selected text, or the data grid's active-cell border, so they follow Accent, focus and Increase Contrast. `ThemeTableChrome` never replaces a header; only a code table recolors its selection, with `editor.selection`.
 - **A theme change has to reach the view.** SwiftUI caches `Color(nsColor:)` by object identity, so a view reading the engine holds `@ObservedObject private var themeEngine = ThemeEngine.shared`; an AppKit view that bakes a color re-bakes on `AppEvents.shared.themeChanged`. `withAlphaComponent` on a system color outside `NSColor(name:dynamicProvider:)` freezes it.
 - **No theme color on selectable-row text**: it does not turn white on the emphasized selection. Never put `.themeForeground` on a container of selectable rows; `ThemeTableChrome.recordsTextSlot(...)` picks a records cell's slot.
 
diff --git a/.claude/rules/ui-tests.md b/.claude/rules/ui-tests.md
index 4b86f08513..554dcf40de 100644
--- a/.claude/rules/ui-tests.md
+++ b/.claude/rules/ui-tests.md
@@ -52,7 +52,9 @@ The UI plan holds end-to-end flows only. Swift Testing rules, isolation and shar
 ## The grid
 
 - Every grid read and click goes through `FixtureGrid` (`cell`, `value`, `waitForValue`, `clickCell`, `editCell`, `clickHeader`) or `gridPoint(in:of:dy:)`.
-- `FixtureGrid` matches a cell by the identifier `DataGridCellAccessibilityView`, the leaf that carries the value, not the AXCell wrapper AppKit puts around it.
+- `dataGrid(in:)` matches the main table, `data-grid`, which publishes every column. The frozen pane laid over its leading edge, `data-grid-frozen`, is hidden from accessibility.
+- `FixtureGrid` matches a cell by the identifier `data-grid-cell`, the leaf that carries the value, not the AXCell wrapper AppKit puts around it, and by the label `Row r, column c: `. Both count from 1: `r` is the row number on screen, page offset included, and `c` the column's display position, so hiding or moving a column renumbers the ones after it.
+- A plain `clickHeader` sorts by that column alone and flips it on the next click; `clickHeader(_:modifiers: .option)` adds it as another key. A right-click opens the header or cell menu and never moves the selection.
 - `FixtureFile.rows` and `FixtureFile.execute` read and write the fixture database directly, to set up or check data without the UI.
 - Never call `click()` on a grid element. Rows and cells read as obscured by their columns, a row element has an empty frame so an offset click lands on the window's close button, and a header never becomes hittable. The app side is in `.claude/rules/data-grid.md`.
 - A point offset from the grid measures from its top edge, above the header. Take `dy` from a row's frame (`row.frame.midY - grid.frame.minY`); a small constant hits the header and opens the column menu.
diff --git a/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeImporter.swift b/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeImporter.swift
index 1e9b13c5b3..0274e07f98 100644
--- a/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeImporter.swift
+++ b/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeImporter.swift
@@ -167,7 +167,7 @@ private extension ThemeDefinition {
             switch slot.fallback {
             case .system, .defaultSyntax:
                 continue
-            case .slot, .derived, .paired:
+            case .slot, .derived:
                 var unset = result
                 unset.overrides[slot] = nil
                 if unset.value(for: slot) == result.value(for: slot) {
diff --git a/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeMapping.swift b/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeMapping.swift
index f59fdb5a22..0f0365a41c 100644
--- a/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeMapping.swift
+++ b/apple/Packages/TableProCore/Sources/TableProTheme/Import/VSCodeThemeMapping.swift
@@ -22,9 +22,7 @@ private extension VSCodeColorSource {
 }
 
 internal extension ThemeSlot {
-    // An empty list leaves the slot to its fallback. So does a source list that stops short: the
-    // alternate row, the header, the header text, the bools and the selection text are derived by
-    // `fallback` from the background, text and selection, which is what VS Code paints there too.
+    // A list that stops short leaves the slot to `fallback`, which derives the stripe and the bools the way VS Code paints them.
     var vscodeSources: [VSCodeColorSource] {
         switch self {
         case .windowBackdrop:
@@ -84,20 +82,8 @@ internal extension ThemeSlot {
             return [.color("editor.foreground")]
         case .gridAlternateRow:
             return [.color("keybindingTable.rowsBackground"), .color("tree.tableOddRowsBackground")]
-        case .gridHeaderBackground:
-            return [.color("keybindingTable.headerBackground"), .color("tree.tableOddRowsBackground")]
-        case .gridHeaderText:
-            return [.color("foreground")]
         case .gridLine:
             return [.color("tree.tableColumnsBorder")]
-        case .gridSelection:
-            return [.color("list.activeSelectionBackground")]
-        case .gridSelectionText:
-            return [.color("list.activeSelectionForeground")]
-        case .gridInactiveSelection:
-            return [.color("list.inactiveSelectionBackground")]
-        case .gridFocusBorder:
-            return [.color("list.focusOutline"), .color("focusBorder")]
         case .gridNullValue:
             // The grid draws NULL as placeholder text. `descriptionForeground` equals the text color in
             // One Dark Pro, so NULL would not read as absent.
diff --git a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeDefinition.swift b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeDefinition.swift
index cb71b8ac5a..06ed516b66 100644
--- a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeDefinition.swift
+++ b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeDefinition.swift
@@ -1,8 +1,5 @@
 import Foundation
 
-/// A theme is a set of colors for the content views and the window backdrop. A slot it leaves out
-/// draws what its `ThemeSlot.fallback` says, so Default Light and Default Dark declare nothing and
-/// render exactly like a native app, following Accent, Highlight and Increase Contrast.
 public struct ThemeDefinition: Identifiable, Equatable, Sendable {
     public var id: String
     public var name: String
@@ -35,26 +32,23 @@ public struct ThemeDefinition: Identifiable, Equatable, Sendable {
         !isBuiltIn
     }
 
-    /// The file sets this slot. Only the theme editor asks: a derived slot draws a theme color the
-    /// file never wrote, and an explicit selection text draws nothing without a selection.
+    // Only the theme editor asks: a derived slot draws a theme color the file never wrote.
     public func hasExplicitColor(_ slot: ThemeSlot) -> Bool {
         overrides[slot] != nil
     }
 
-    /// The format has no increased-contrast variant, so a slot that yields to Increase Contrast draws
-    /// native there even where the theme sets it.
+    // The format has no increased-contrast variant, so a yielding slot draws native there.
     public func value(for slot: ThemeSlot, highContrast: Bool = false) -> ThemeSlotValue {
         if slot.yieldsToIncreasedContrast, highContrast {
             return .system(slot)
         }
-        if let explicit = overrides[slot], allowsExplicitColor(for: slot, highContrast: highContrast) {
+        if let explicit = overrides[slot] {
             return .themed(slot.requiresOpaque ? explicit.opaque : explicit)
         }
         return fallbackValue(for: slot, highContrast: highContrast)
     }
 
-    /// The slot draws a theme color, set or derived. Every surface that swaps a native drawing path
-    /// for the theme's asks this.
+    // Set or derived. Every surface that swaps a native drawing path for the theme's asks this.
     public func isOverridden(_ slot: ThemeSlot, highContrast: Bool) -> Bool {
         value(for: slot, highContrast: highContrast).isThemed
     }
@@ -63,11 +57,6 @@ public struct ThemeDefinition: Identifiable, Equatable, Sendable {
         isOverridden(slot, highContrast: false)
     }
 
-    private func allowsExplicitColor(for slot: ThemeSlot, highContrast: Bool) -> Bool {
-        guard case let .paired(partner, _) = slot.fallback else { return true }
-        return value(for: partner, highContrast: highContrast).isThemed
-    }
-
     private func fallbackValue(for slot: ThemeSlot, highContrast: Bool) -> ThemeSlotValue {
         switch slot.fallback {
         case .system:
@@ -80,16 +69,11 @@ public struct ThemeDefinition: Identifiable, Equatable, Sendable {
         case let .derived(base, rule):
             guard let baseColor = value(for: base, highContrast: highContrast).themedColor else { return .system(slot) }
             return .themed(derive(rule, from: baseColor, highContrast: highContrast))
-        case let .paired(partner, fallback):
-            guard value(for: partner, highContrast: highContrast).isThemed else { return .system(slot) }
-            return value(for: fallback, highContrast: highContrast)
         }
     }
 
     private func derive(_ rule: ThemeDerivationRule, from base: ThemeColor, highContrast: Bool) -> ThemeColor {
         switch rule {
-        case .same:
-            return base
         case let .stripe(toward):
             let target = value(for: toward, highContrast: highContrast).themedColor
                 ?? (appearance == .dark ? .white : .black)
diff --git a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeFileFormat.swift b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeFileFormat.swift
index 26f6da07cf..a8ad66013d 100644
--- a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeFileFormat.swift
+++ b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeFileFormat.swift
@@ -1,11 +1,6 @@
 import Foundation
 
-/// Format 3 dropped the pane and status groups, made every color optional and removed `system:`
-/// values. Format 2 never shipped in a release, and format 1 files carried fonts the app now keeps in
-/// settings.
-///
-/// Adding a slot bumps `current`. The decoder keeps reading every older format, and an unknown key
-/// stays an error: a file is refused rather than loaded without colors its author wrote.
+// Removing a slot never bumps it: the slot's key joins `ThemeFileFormat.retiredKeys`.
 public enum ThemeSchema {
     public static let current = 3
 }
@@ -15,7 +10,7 @@ public enum ThemeIdentifier {
 
     private static let pattern = #"^[A-Za-z0-9._-]+$"#
 
-    /// Plain enough to be a file name on every file system TablePro writes to.
+    // Plain enough to be a file name on every file system TablePro writes to.
     public static func isValid(_ id: String) -> Bool {
         id.utf8.count <= maximumLength
             && id.range(of: pattern, options: .regularExpression) != nil
@@ -27,21 +22,24 @@ public enum ThemeIdentifier {
     }
 }
 
-/// The theme file format, and the only place a file can be rejected. Every color is optional: a
-/// slot the file leaves out draws its fallback. What is refused is anything that would otherwise
-/// load as something the author did not write: an unknown key, an unparseable color, missing
-/// metadata, another format.
-///
-/// Foundation keeps the first of two equal keys at one level, so that duplicate cannot be seen.
+// Foundation keeps the first of two equal keys at one level, so that duplicate cannot be seen.
 public enum ThemeFileFormat {
     public static let maximumTextLength = 100
 
-    /// What `decode` does with a name or author that is not one line of at most `maximumTextLength`.
+    // Removed slots: a file that still carries one loads without it.
+    static let retiredKeys: Set<String> = [
+        "dataGrid.headerBackground",
+        "dataGrid.headerText",
+        "dataGrid.selection",
+        "dataGrid.selectionText",
+        "dataGrid.inactiveSelection",
+        "dataGrid.focusBorder",
+    ]
+
     public enum TextPolicy: Sendable {
-        /// Refuses it: a file someone picked, and every record another Mac sent.
+        // A file someone picked, and every record another Mac sent.
         case strict
-        /// Folds it onto one line and cuts it at the cap. TablePro 0.81 wrote names and authors with
-        /// neither limit, and a theme it saved still loads; the next save writes the repaired text.
+        // TablePro 0.81 wrote names and authors with no limit; the next save writes the repaired text.
         case repaired
     }
 
@@ -97,7 +95,6 @@ public enum ThemeFileFormat {
         )
     }
 
-    /// Writes what `decode` reads back unchanged: a trimmed name and author, and opaque fills.
     public static func encode(_ theme: ThemeDefinition) throws -> Data {
         guard ThemeIdentifier.isValid(theme.id) else { throw ThemeLoadError.invalidIdentifier(theme.id) }
         let name = try validatedName(theme.name, policy: .strict)
@@ -124,8 +121,7 @@ public enum ThemeFileFormat {
 
     // MARK: - Reading
 
-    /// `JSONDecoder` rather than `JSONSerialization`: its underlying error names the character and
-    /// where it is, which is what a person fixing the file by hand needs.
+    // `JSONDecoder` over `JSONSerialization`: its error names the character and where it is.
     private static func parse(_ data: Data) throws -> ThemeJSONNode {
         do {
             return try JSONDecoder().decode(ThemeJSONNode.self, from: data)
@@ -141,6 +137,7 @@ public enum ThemeFileFormat {
         let leaves = root
             .filter { MetadataKey(rawValue: $0.key) == nil }
             .flatMap { key, node in node.leaves(prefix: key) }
+            .filter { !retiredKeys.contains($0.path) }
             .sorted { $0.path < $1.path }
 
         var parsed: [ThemeSlot: ThemeColor] = [:]
@@ -182,7 +179,7 @@ public enum ThemeFileFormat {
         return repaired(text)
     }
 
-    /// Every scalar `isSingleLine` refuses splits words, so the next save's strict check passes.
+    // Every scalar `isSingleLine` refuses splits words, so the next save's strict check passes.
     private static func repaired(_ text: String) -> String {
         let separators = CharacterSet.whitespacesAndNewlines.union(.controlCharacters)
         let words = text.components(separatedBy: separators).filter { !$0.isEmpty }
@@ -194,8 +191,7 @@ public enum ThemeFileFormat {
         text.trimmingCharacters(in: .whitespacesAndNewlines)
     }
 
-    /// `controlCharacters` holds the ASCII line breaks; `newlines` adds the Unicode line and paragraph
-    /// separators.
+    // `newlines` adds the Unicode line and paragraph separators to the ASCII breaks.
     private static func isSingleLine(_ text: String) -> Bool {
         !text.unicodeScalars.contains { CharacterSet.controlCharacters.contains($0) || CharacterSet.newlines.contains($0) }
     }
@@ -216,9 +212,7 @@ public enum ThemeFileFormat {
     }
 }
 
-/// A JSON value as far as the format cares. A number is kept only as an integer, which is all the
-/// schema field holds; anything else that is not a string or an object is `other`, so the decoder
-/// can name it rather than drop it.
+// Anything not a string, an integer or an object is `other`, so the decoder names it rather than drop it.
 private indirect enum ThemeJSONNode: Decodable {
     case string(String)
     case number(Int)
@@ -253,7 +247,7 @@ private indirect enum ThemeJSONNode: Decodable {
         return value
     }
 
-    /// Every leaf with its dotted path. A leaf that is not a string is kept as `nil`.
+    // A leaf that is not a string is kept as `nil`.
     func leaves(prefix: String) -> [(path: String, value: String?)] {
         switch self {
         case let .string(value):
diff --git a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlot.swift b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlot.swift
index 266db47654..29a24bf997 100644
--- a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlot.swift
+++ b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlot.swift
@@ -1,8 +1,5 @@
 import Foundation
 
-/// The single registry every slot goes through. A slot exists here because a call site reads it.
-/// The decoder, the encoder and the theme editor all enumerate this list rather than keeping their
-/// own copies.
 public enum ThemeSlot: String, CaseIterable, Sendable {
     case windowBackdrop = "window.background"
 
@@ -27,13 +24,7 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
     case gridBackground = "dataGrid.background"
     case gridText = "dataGrid.text"
     case gridAlternateRow = "dataGrid.alternateRow"
-    case gridHeaderBackground = "dataGrid.headerBackground"
-    case gridHeaderText = "dataGrid.headerText"
     case gridLine = "dataGrid.gridLine"
-    case gridSelection = "dataGrid.selection"
-    case gridSelectionText = "dataGrid.selectionText"
-    case gridInactiveSelection = "dataGrid.inactiveSelection"
-    case gridFocusBorder = "dataGrid.focusBorder"
     case gridNullValue = "dataGrid.nullValue"
     case gridBoolTrue = "dataGrid.boolTrue"
     case gridBoolFalse = "dataGrid.boolFalse"
@@ -43,7 +34,6 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
     case gridDeleted = "dataGrid.deleted"
     case gridDeletedText = "dataGrid.deletedText"
 
-    /// The group of the file format: the slot's dotted path starts with the group's key.
     public var group: ThemeSlotGroup {
         switch self {
         case .windowBackdrop:
@@ -54,15 +44,13 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
         case .syntaxKeyword, .syntaxString, .syntaxNumber, .syntaxComment,
              .syntaxNull, .syntaxOperator, .syntaxFunction, .syntaxType:
             return .syntax
-        case .gridBackground, .gridText, .gridAlternateRow, .gridHeaderBackground, .gridHeaderText,
-             .gridLine, .gridSelection, .gridSelectionText, .gridInactiveSelection, .gridFocusBorder,
+        case .gridBackground, .gridText, .gridAlternateRow, .gridLine,
              .gridNullValue, .gridBoolTrue, .gridBoolFalse, .gridRowNumber,
              .gridModified, .gridInserted, .gridDeleted, .gridDeletedText:
             return .dataGrid
         }
     }
 
-    /// Where the theme editor lists the slot.
     public var section: ThemeSlotSection {
         switch self {
         case .windowBackdrop:
@@ -73,50 +61,43 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
         case .syntaxKeyword, .syntaxString, .syntaxNumber, .syntaxComment,
              .syntaxNull, .syntaxOperator, .syntaxFunction, .syntaxType:
             return .syntax
-        case .gridBackground, .gridText, .gridAlternateRow, .gridHeaderBackground, .gridHeaderText,
-             .gridLine, .gridNullValue, .gridBoolTrue, .gridBoolFalse, .gridRowNumber:
+        case .gridBackground, .gridText, .gridAlternateRow, .gridLine,
+             .gridNullValue, .gridBoolTrue, .gridBoolFalse, .gridRowNumber:
             return .dataGrid
-        case .gridSelection, .gridSelectionText, .gridInactiveSelection, .gridFocusBorder:
-            return .selection
         case .gridModified, .gridInserted, .gridDeleted, .gridDeletedText:
             return .changes
         }
     }
 
-    /// Only the backdrop: content slots keep the theme under Increase Contrast, as they always have.
+    // Content keeps the theme under Increase Contrast; only the backdrop yields.
     public var yieldsToIncreasedContrast: Bool {
         group == .window
     }
 
-    /// Fills that sit under everything else. A translucent window color shows the desktop through the
-    /// window, so these never carry alpha.
+    // A translucent fill under everything else would show the desktop through the window.
     public var requiresOpaque: Bool {
         switch self {
-        case .windowBackdrop, .editorBackground, .gridBackground, .gridHeaderBackground:
+        case .windowBackdrop, .editorBackground, .gridBackground:
             return true
         case .editorText, .editorCursor, .editorSelection, .editorCurrentLine, .editorCurrentStatement,
              .editorLineNumber, .editorInvisibles,
              .syntaxKeyword, .syntaxString, .syntaxNumber, .syntaxComment,
              .syntaxNull, .syntaxOperator, .syntaxFunction, .syntaxType,
-             .gridText, .gridAlternateRow, .gridHeaderText, .gridLine, .gridSelection, .gridSelectionText,
-             .gridInactiveSelection, .gridFocusBorder, .gridNullValue, .gridBoolTrue, .gridBoolFalse,
+             .gridText, .gridAlternateRow, .gridLine, .gridNullValue, .gridBoolTrue, .gridBoolFalse,
              .gridRowNumber, .gridModified, .gridInserted, .gridDeleted, .gridDeletedText:
             return false
         }
     }
 
-    /// Washes drawn over content, where an alpha channel is the point.
     public var offersOpacity: Bool {
         switch self {
         case .editorSelection, .editorCurrentLine, .editorCurrentStatement, .editorInvisibles,
-             .gridAlternateRow, .gridSelection, .gridInactiveSelection,
-             .gridModified, .gridInserted, .gridDeleted, .gridDeletedText:
+             .gridAlternateRow, .gridModified, .gridInserted, .gridDeleted, .gridDeletedText:
             return true
         case .windowBackdrop, .editorBackground, .editorText, .editorCursor, .editorLineNumber,
              .syntaxKeyword, .syntaxString, .syntaxNumber, .syntaxComment,
              .syntaxNull, .syntaxOperator, .syntaxFunction, .syntaxType,
-             .gridBackground, .gridText, .gridHeaderBackground, .gridHeaderText, .gridLine,
-             .gridSelectionText, .gridFocusBorder, .gridNullValue, .gridBoolTrue, .gridBoolFalse,
+             .gridBackground, .gridText, .gridLine, .gridNullValue, .gridBoolTrue, .gridBoolFalse,
              .gridRowNumber:
             return false
         }
@@ -127,7 +108,7 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
         case .windowBackdrop, .editorBackground, .gridBackground: return String(localized: "Background")
         case .editorText, .gridText: return String(localized: "Text")
         case .editorCursor: return String(localized: "Cursor")
-        case .editorSelection, .gridSelection: return String(localized: "Selection")
+        case .editorSelection: return String(localized: "Selection")
         case .editorCurrentLine: return String(localized: "Current Line")
         case .editorCurrentStatement: return String(localized: "Current Statement")
         case .editorLineNumber: return String(localized: "Line Number")
@@ -141,12 +122,7 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
         case .syntaxFunction: return String(localized: "Function")
         case .syntaxType: return String(localized: "Type")
         case .gridAlternateRow: return String(localized: "Alternate Row")
-        case .gridHeaderBackground: return String(localized: "Header Background")
-        case .gridHeaderText: return String(localized: "Header Text")
         case .gridLine: return String(localized: "Grid Line")
-        case .gridSelectionText: return String(localized: "Selected Text")
-        case .gridInactiveSelection: return String(localized: "Inactive Selection")
-        case .gridFocusBorder: return String(localized: "Focus Border")
         case .gridNullValue: return String(localized: "NULL Value")
         case .gridBoolTrue: return String(localized: "Bool True")
         case .gridBoolFalse: return String(localized: "Bool False")
@@ -158,8 +134,7 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
         }
     }
 
-    /// `label` repeats across groups ("Background" three times), so VoiceOver gets the group too.
-    /// Whole phrases, because word order differs between languages.
+    // `label` repeats across groups, so VoiceOver gets whole phrases with the group in them.
     public var accessibilityLabel: String {
         switch self {
         case .windowBackdrop: return String(localized: "Window Background")
@@ -182,13 +157,7 @@ public enum ThemeSlot: String, CaseIterable, Sendable {
         case .gridBackground: return String(localized: "Data Grid Background")
         case .gridText: return String(localized: "Data Grid Text")
         case .gridAlternateRow: return String(localized: "Data Grid Alternate Row")
-        case .gridHeaderBackground: return String(localized: "Data Grid Header Background")
-        case .gridHeaderText: return String(localized: "Data Grid Header Text")
         case .gridLine: return String(localized: "Data Grid Line")
-        case .gridSelection: return String(localized: "Data Grid Selection")
-        case .gridSelectionText: return String(localized: "Data Grid Selected Text")
-        case .gridInactiveSelection: return String(localized: "Data Grid Inactive Selection")
-        case .gridFocusBorder: return String(localized: "Data Grid Focus Border")
         case .gridNullValue: return String(localized: "Data Grid NULL Value")
         case .gridBoolTrue: return String(localized: "Data Grid Bool True")
         case .gridBoolFalse: return String(localized: "Data Grid Bool False")
diff --git a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotFallback.swift b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotFallback.swift
index 1bcb69f835..9a0cce3b3a 100644
--- a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotFallback.swift
+++ b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotFallback.swift
@@ -1,40 +1,31 @@
 import Foundation
 
-/// What a slot draws when the theme leaves it out.
 public enum ThemeSlotFallback: Equatable, Sendable {
-    /// The slot's native color.
     case system
-    /// The same-appearance default's syntax color: syntax has no system color.
+    // Syntax has no system color, so it takes the same-appearance default's.
     case defaultSyntax
-    /// The other slot's theme color, else the slot's native color.
+    // The other slot's theme color, else the slot's native color.
     case slot(ThemeSlot)
-    /// Built from `base` while the theme sets it, else the slot's native color.
+    // Built from `base` while the theme sets it, else the slot's native color.
     case derived(base: ThemeSlot, rule: ThemeDerivationRule)
-    /// Only while the theme sets `with`: the slot's own color, else `fallback`'s value. Otherwise the
-    /// slot's native color, whatever the theme sets.
-    case paired(with: ThemeSlot, fallback: ThemeSlot)
 }
 
 public enum ThemeDerivationRule: Equatable, Sendable {
-    /// The base moved `stripeFraction` toward `toward`'s theme color, or toward black in a light theme
-    /// and white in a dark one.
+    // Toward `toward`'s theme color, else toward black in a light theme and white in a dark one.
     case stripe(toward: ThemeSlot)
-    /// The base itself.
-    case same
 
-    /// AppKit's alternate stripe sits about 4% from its row background in both appearances.
+    // AppKit's alternate stripe sits about 4% from its row background in both appearances.
     public static let stripeFraction = 0.04
 }
 
 public extension ThemeSlot {
-    /// Exhaustive, so a new slot cannot ship without a rule. A rule only names slots that fall back to
-    /// the system themselves, so resolution never chains.
+    // A rule only names slots that fall back to the system themselves, so resolution never chains.
     var fallback: ThemeSlotFallback {
         switch self {
         case .windowBackdrop,
              .editorBackground, .editorText, .editorCursor, .editorSelection,
              .editorCurrentLine, .editorCurrentStatement, .editorLineNumber, .editorInvisibles,
-             .gridBackground, .gridText, .gridLine, .gridSelection, .gridInactiveSelection, .gridFocusBorder,
+             .gridBackground, .gridText, .gridLine,
              .gridNullValue, .gridRowNumber, .gridModified, .gridInserted, .gridDeleted, .gridDeletedText:
             return .system
         case .syntaxKeyword, .syntaxString, .syntaxNumber, .syntaxComment,
@@ -42,18 +33,11 @@ public extension ThemeSlot {
             return .defaultSyntax
         case .syntaxOperator:
             return .slot(.editorText)
-        // A bool or a header label in labelColor next to themed cell text reads as a different table.
-        case .gridBoolTrue, .gridBoolFalse, .gridHeaderText:
+        // A bool in labelColor next to themed cell text reads as a different table.
+        case .gridBoolTrue, .gridBoolFalse:
             return .slot(.gridText)
         case .gridAlternateRow:
             return .derived(base: .gridBackground, rule: .stripe(toward: .gridText))
-        // Natively the header and the rows share controlBackgroundColor.
-        case .gridHeaderBackground:
-            return .derived(base: .gridBackground, rule: .same)
-        // AppKit's own selection keeps its white text, so a theme's selection text only means
-        // something over the theme's selection.
-        case .gridSelectionText:
-            return .paired(with: .gridSelection, fallback: .gridText)
         }
     }
 }
diff --git a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotSection.swift b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotSection.swift
index b1e2fc3606..67e87176f3 100644
--- a/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotSection.swift
+++ b/apple/Packages/TableProCore/Sources/TableProTheme/ThemeSlotSection.swift
@@ -1,13 +1,11 @@
 import Foundation
 
-/// The theme editor's grouping. It splits the data grid's file-format group so selection and row
-/// change colors, which are chosen together, sit together.
+// The theme editor's grouping: the row change colors, chosen together, get a section of their own.
 public enum ThemeSlotSection: String, CaseIterable, Sendable {
     case window
     case editor
     case syntax
     case dataGrid
-    case selection
     case changes
 
     public var label: String {
@@ -16,7 +14,6 @@ public enum ThemeSlotSection: String, CaseIterable, Sendable {
         case .editor: return String(localized: "Editor")
         case .syntax: return String(localized: "Syntax")
         case .dataGrid: return String(localized: "Data Grid")
-        case .selection: return String(localized: "Selection")
         case .changes: return String(localized: "Changes")
         }
     }
diff --git a/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeImportTests.swift b/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeImportTests.swift
index 5e4172abb3..1c6739c747 100644
--- a/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeImportTests.swift
+++ b/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeImportTests.swift
@@ -135,14 +135,13 @@ struct VSCodeThemeImportTests {
         #expect(dark.hex(.editorText) == nil)
     }
 
-    @Test("The four fills nothing themed sits under are flattened; washes keep their alpha")
+    @Test("The three fills nothing themed sits under are flattened; washes keep their alpha")
     func opaqueSlotsAreFlattened() throws {
         let theme = try Self.theme(
             """
             {"type": "dark", "colors": {
               "editor.background": "#20406080",
               "editorPane.background": "#FFFFFF33",
-              "keybindingTable.headerBackground": "#FFFFFF1A",
               "editor.selectionBackground": "#3050A080",
               "keybindingTable.rowsBackground": "#FFFFFF0A"
             }}
@@ -154,7 +153,6 @@ struct VSCodeThemeImportTests {
         #expect(theme.overrides[.editorBackground] == editor)
         #expect(theme.overrides[.gridBackground] == editor)
         #expect(theme.overrides[.windowBackdrop] == ThemeColor(red: 255, green: 255, blue: 255, alpha: 0x33).composited(over: editor))
-        #expect(theme.overrides[.gridHeaderBackground] == ThemeColor(red: 255, green: 255, blue: 255, alpha: 0x1A).composited(over: editor))
         for slot in ThemeSlot.allCases where slot.requiresOpaque {
             #expect(theme.overrides[slot]?.isOpaque == true, "\(slot)")
         }
@@ -168,34 +166,32 @@ struct VSCodeThemeImportTests {
             """
             {"colors": {
               "editor.background": "#202020",
-              "editor.foreground": "#E0E0E0",
-              "foreground": "#E0E0E0",
-              "keybindingTable.headerBackground": "#202020",
-              "list.activeSelectionForeground": "#FFFFFF"
+              "editor.foreground": "#E0E0E0"
             }, "tokenColors": [{"scope": "constant.language.boolean", "settings": {"foreground": "#E0E0E0"}}]}
             """
         )
 
-        #expect(theme.hex(.gridHeaderText) == nil)
-        #expect(theme.hex(.gridHeaderBackground) == nil)
-        #expect(theme.hex(.gridSelectionText) == nil)
         #expect(theme.hex(.gridBoolTrue) == nil)
         #expect(theme.hex(.gridBoolFalse) == nil)
-        #expect(theme.value(for: .gridHeaderText) == .themed(ThemeColor(red: 0xE0, green: 0xE0, blue: 0xE0)))
-        #expect(theme.value(for: .gridHeaderBackground) == .themed(ThemeColor(red: 0x20, green: 0x20, blue: 0x20)))
+        #expect(theme.value(for: .gridBoolTrue) == .themed(ThemeColor(red: 0xE0, green: 0xE0, blue: 0xE0)))
     }
 
-    @Test("Selection text is kept while the theme also sets the selection and the two differ from the text")
-    func pairedSelectionTextIsKept() throws {
+    @Test("A VS Code theme's list selection, focus and table header colors import nothing: those stay the system's")
+    func selectionAndHeaderColorsImportNothing() throws {
         let theme = try Self.theme(
             """
             {"colors": {"editor.background": "#202020", "editor.foreground": "#E0E0E0",
-              "list.activeSelectionBackground": "#0050A0", "list.activeSelectionForeground": "#FFFFFF"}}
+              "list.activeSelectionBackground": "#0050A0", "list.activeSelectionForeground": "#FFFFFF",
+              "list.inactiveSelectionBackground": "#00305080", "list.focusOutline": "#0080FF",
+              "focusBorder": "#3366FF", "keybindingTable.headerBackground": "#2A2A2A", "foreground": "#C0C0C0"}}
             """
         )
+        let imported = Set(theme.overrides.values.map(\.hex))
 
-        #expect(theme.hex(.gridSelection) == "#0050A0")
-        #expect(theme.hex(.gridSelectionText) == "#FFFFFF")
+        for hex in ["#0050A0", "#FFFFFF", "#00305080", "#0080FF", "#3366FF", "#2A2A2A", "#C0C0C0"] {
+            #expect(!imported.contains(hex), "\(hex)")
+        }
+        #expect(theme.hex(.gridBackground) == "#202020")
     }
 
     @Test("An imported theme survives the TablePro format unchanged")
diff --git a/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeMappingTests.swift b/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeMappingTests.swift
index 2e7f5fa335..62040133ce 100644
--- a/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeMappingTests.swift
+++ b/apple/Packages/TableProCore/Tests/TableProThemeTests/Import/VSCodeThemeMappingTests.swift
@@ -19,15 +19,8 @@ struct VSCodeThemeMappingTests {
       "editorLineNumber.foreground": "#808080",
       "editorWhitespace.foreground": "#404040",
       "keybindingTable.rowsBackground": "#252525",
-      "keybindingTable.headerBackground": "#2A2A2A",
       "tree.tableOddRowsBackground": "#999999",
-      "foreground": "#C0C0C0",
       "tree.tableColumnsBorder": "#303030",
-      "list.activeSelectionBackground": "#0050A0",
-      "list.activeSelectionForeground": "#FFFFFF",
-      "list.inactiveSelectionBackground": "#00305080",
-      "list.focusOutline": "#0080FF",
-      "focusBorder": "#999999",
       "input.placeholderForeground": "#707070",
       "gitDecoration.modifiedResourceForeground": "#E0C000",
       "diffEditor.insertedLineBackground": "#00FF0020",
@@ -73,13 +66,7 @@ struct VSCodeThemeMappingTests {
         case .gridBackground: return "#202020"
         case .gridText: return "#E0E0E0"
         case .gridAlternateRow: return "#252525"
-        case .gridHeaderBackground: return "#2A2A2A"
-        case .gridHeaderText: return "#C0C0C0"
         case .gridLine: return "#303030"
-        case .gridSelection: return "#0050A0"
-        case .gridSelectionText: return "#FFFFFF"
-        case .gridInactiveSelection: return "#00305080"
-        case .gridFocusBorder: return "#0080FF"
         case .gridNullValue: return "#707070"
         case .gridBoolTrue: return "#C00009"
         case .gridBoolFalse: return "#C0000A"
@@ -100,8 +87,6 @@ struct VSCodeThemeMappingTests {
       "editor.lineHighlightBorder": "#E0E0E0",
       "tree.tableOddRowsBackground": "#00000008",
       "foreground": "#404040",
-      "focusBorder": "#3366FF",
-      "list.activeSelectionForeground": "#FFFFFF",
       "diffEditor.insertedTextBackground": "#00AA0033",
       "diffEditor.removedTextBackground": "#AA000033"
     }, "tokenColors": [
@@ -132,15 +117,7 @@ struct VSCodeThemeMappingTests {
         case .gridBackground: return "#F8F8F8"
         case .gridText: return "#202020"
         case .gridAlternateRow: return "#00000008"
-        // #00000008 flattened over #F8F8F8.
-        case .gridHeaderBackground: return "#F0F0F0"
-        case .gridHeaderText: return "#404040"
         case .gridLine: return nil
-        case .gridSelection: return nil
-        // Without a theme selection AppKit keeps its own white text, so the color is dropped.
-        case .gridSelectionText: return nil
-        case .gridInactiveSelection: return nil
-        case .gridFocusBorder: return "#3366FF"
         case .gridNullValue: return "#40404080"
         case .gridBoolTrue: return nil
         case .gridBoolFalse: return nil
diff --git a/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeFileFormatTests.swift b/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeFileFormatTests.swift
index 6b0c0dc2a7..136641224c 100644
--- a/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeFileFormatTests.swift
+++ b/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeFileFormatTests.swift
@@ -2,8 +2,6 @@ import Foundation
 import TableProTheme
 import Testing
 
-/// Format 3: every color is optional, a slot left out draws its fallback, and the file is refused for
-/// anything that would otherwise load as something its author did not write.
 struct ThemeFileFormatTests {
     private static func data(_ object: [String: Any]) throws -> Data {
         try JSONSerialization.data(withJSONObject: object)
@@ -80,11 +78,11 @@ struct ThemeFileFormatTests {
     func slotsAreOptional() throws {
         var root = Self.metadata()
         Self.insert("#FF0000", at: ["editor", "syntax", "keyword"], into: &root)
-        Self.insert("#00000080", at: ["dataGrid", "selection"], into: &root)
+        Self.insert("#00000080", at: ["dataGrid", "alternateRow"], into: &root)
 
         let colors = try Self.decode(root).overrides.mapValues(\.hex)
 
-        #expect(colors == [.syntaxKeyword: "#FF0000", .gridSelection: "#00000080"])
+        #expect(colors == [.syntaxKeyword: "#FF0000", .gridAlternateRow: "#00000080"])
     }
 
     @Test("Every slot path is accepted")
@@ -107,7 +105,7 @@ struct ThemeFileFormatTests {
     }
 
     @Test("A fill that must be opaque loads without its alpha, and is written without it", arguments: [
-        ThemeSlot.windowBackdrop, .editorBackground, .gridBackground, .gridHeaderBackground,
+        ThemeSlot.windowBackdrop, .editorBackground, .gridBackground,
     ])
     func opaqueSlotsDropAlphaOnLoad(slot: ThemeSlot) throws {
         let theme = try Self.decode(Self.withColor("#282A3680", at: slot.rawValue.components(separatedBy: ".")))
@@ -119,6 +117,50 @@ struct ThemeFileFormatTests {
         #expect(reread.overrides[slot]?.hex == "#282A36")
     }
 
+    @Test("A file that still carries the retired header and selection keys loads without them, and saves without them")
+    func retiredKeysAreDropped() throws {
+        let text = """
+        {
+          "appearance": "dark",
+          "author": "Dracula Theme",
+          "dataGrid": {
+            "background": "#282A36",
+            "focusBorder": "#BD93F9",
+            "headerBackground": "#21222C",
+            "headerText": "#F8F8F2",
+            "inactiveSelection": "#44475A80",
+            "selection": "#44475A",
+            "selectionText": "#F8F8F2",
+            "text": "#F8F8F2"
+          },
+          "editor": {"selection": "#44475A"},
+          "id": "user.saved-before",
+          "name": "Saved Before",
+          "schema": 3
+        }
+        """
+
+        let theme = try ThemeFileFormat.decode(Data(text.utf8))
+        let colors = theme.overrides.mapValues(\.hex)
+
+        #expect(colors == [.gridBackground: "#282A36", .gridText: "#F8F8F2", .editorSelection: "#44475A"])
+        let object = try JSONSerialization.jsonObject(with: try ThemeFileFormat.encode(theme))
+        let grid = try #require((object as? [String: Any])?["dataGrid"] as? [String: String])
+        #expect(grid == ["background": "#282A36", "text": "#F8F8F2"])
+    }
+
+    @Test("A retired key is dropped whatever its value, nested or dotted, and only the retired keys are")
+    func onlyRetiredKeysAreDropped() throws {
+        var root = Self.metadata()
+        Self.insert("not a color", at: ["dataGrid", "selection"], into: &root)
+        Self.insert(16_777_215, at: ["dataGrid", "focusBorder"], into: &root)
+        root["dataGrid.headerText"] = "#FFFFFF"
+        #expect(try Self.decode(root).overrides.isEmpty)
+
+        Self.insert("#000000", at: ["dataGrid", "selectionBorder"], into: &root)
+        #expect(try Self.refusal(root) == .unknownKeys(["dataGrid.selectionBorder"]))
+    }
+
     @Test("Name and author are trimmed")
     func nameAndAuthorAreTrimmed() throws {
         var root = Self.metadata()
@@ -179,8 +221,7 @@ struct ThemeFileFormatTests {
         #expect(error?.localizedDescription.contains("editor.sidebar") == true)
     }
 
-    /// The pane and status groups of format 2 are gone, so a file that still carries them is
-    /// refused rather than loaded with those colors dropped.
+    // Refused rather than loaded with those colors dropped.
     @Test("Format 2 slot groups are refused")
     func formerGroupsAreRefused() throws {
         for path in [["panel", "background"], ["status", "warning"], ["content", "editor", "background"]] {
@@ -189,8 +230,7 @@ struct ThemeFileFormatTests {
         }
     }
 
-    /// A value that is not a string would otherwise be dropped silently, which loads the slot as
-    /// native under a key the author did write.
+    // Dropped silently, the slot would load as native under a key the author did write.
     @Test("A key whose value is not a color string is refused")
     func nonStringValueIsRefused() {
         var unknownNumber = Self.metadata()
diff --git a/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotFallbackTests.swift b/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotFallbackTests.swift
index 34baeefc82..8379816385 100644
--- a/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotFallbackTests.swift
+++ b/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotFallbackTests.swift
@@ -3,7 +3,7 @@ import TableProTheme
 import Testing
 
 struct ThemeSlotFallbackTests {
-    /// A typo gives a color no theme draws, so the expectation it sits in fails.
+    // A typo gives a color no theme draws, so the expectation it sits in fails.
     private static func color(_ hex: String) -> ThemeColor {
         ThemeColor(hex: hex) ?? ThemeColor(red: 1, green: 2, blue: 3, alpha: 4)
     }
@@ -44,13 +44,7 @@ struct ThemeSlotFallbackTests {
         .gridBackground: .system,
         .gridText: .system,
         .gridAlternateRow: .derived(base: .gridBackground, rule: .stripe(toward: .gridText)),
-        .gridHeaderBackground: .derived(base: .gridBackground, rule: .same),
-        .gridHeaderText: .slot(.gridText),
         .gridLine: .system,
-        .gridSelection: .system,
-        .gridSelectionText: .paired(with: .gridSelection, fallback: .gridText),
-        .gridInactiveSelection: .system,
-        .gridFocusBorder: .system,
         .gridNullValue: .system,
         .gridBoolTrue: .slot(.gridText),
         .gridBoolFalse: .slot(.gridText),
@@ -71,7 +65,7 @@ struct ThemeSlotFallbackTests {
         #expect(Set(Self.expected.keys) == Set(ThemeSlot.allCases))
     }
 
-    /// A rule that named another dependent slot would chain, and two such rules could loop.
+    // A rule that named another dependent slot would chain, and two such rules could loop.
     @Test("A rule only names slots that fall back to the system themselves")
     func rulesNeverChain() {
         for slot in ThemeSlot.allCases {
@@ -79,9 +73,7 @@ struct ThemeSlotFallbackTests {
             switch slot.fallback {
             case .system, .defaultSyntax: named = []
             case let .slot(source): named = [source]
-            case let .derived(base, rule):
-                if case let .stripe(toward) = rule { named = [base, toward] } else { named = [base] }
-            case let .paired(partner, fallback): named = [partner, fallback]
+            case let .derived(base, .stripe(toward)): named = [base, toward]
             }
             for other in named {
                 #expect(other.fallback == .system, "\(slot.rawValue) names \(other.rawValue)")
@@ -107,7 +99,7 @@ struct ThemeSlotFallbackTests {
         }
     }
 
-    @Test("An explicit color draws as set wherever its rule allows it")
+    @Test("An explicit color draws as set")
     func explicitColorDraws() throws {
         let theme = try Self.theme(.dark, [.syntaxKeyword: "#FF79C6", .gridAlternateRow: "#21222C80", .editorCursor: "#F8F8F2"])
         #expect(theme.value(for: .syntaxKeyword) == .themed(Self.color("#FF79C6")))
@@ -119,17 +111,15 @@ struct ThemeSlotFallbackTests {
 
     // MARK: - Derived slots
 
-    @Test("A light background-only theme stripes and heads the grid from its own background")
+    @Test("A light background-only theme stripes the grid from its own background")
     func backgroundOnlyLight() throws {
         let theme = try Self.theme(.light, [.gridBackground: "#FDF6E3"])
 
         #expect(theme.value(for: .gridAlternateRow) == .themed(Self.color("#F3ECDA")))
-        #expect(theme.value(for: .gridHeaderBackground) == .themed(Self.color("#FDF6E3")))
         #expect(theme.isOverridden(.gridAlternateRow))
-        #expect(theme.isOverridden(.gridHeaderBackground))
         #expect(!theme.hasExplicitColor(.gridAlternateRow))
         #expect(theme.value(for: .gridText) == .system(.gridText))
-        #expect(theme.value(for: .gridSelection) == .system(.gridSelection))
+        #expect(theme.value(for: .gridLine) == .system(.gridLine))
     }
 
     @Test("A dark background-only theme stripes toward white")
@@ -137,7 +127,6 @@ struct ThemeSlotFallbackTests {
         let theme = try Self.theme(.dark, [.gridBackground: "#282A36"])
 
         #expect(theme.value(for: .gridAlternateRow) == .themed(Self.color("#31333E")))
-        #expect(theme.value(for: .gridHeaderBackground) == .themed(Self.color("#282A36")))
     }
 
     @Test("The stripe moves toward the theme's own grid text when it sets one")
@@ -149,50 +138,25 @@ struct ThemeSlotFallbackTests {
         #expect(stripe.isOpaque)
     }
 
-    @Test("Without a themed background the derived slots stay native, even with themed text")
+    @Test("Without a themed background the stripe stays native, even with themed text")
     func derivedNeedsTheBase() throws {
         let theme = try Self.theme(.light, [.gridText: "#112233"])
         #expect(theme.value(for: .gridAlternateRow) == .system(.gridAlternateRow))
-        #expect(theme.value(for: .gridHeaderBackground) == .system(.gridHeaderBackground))
     }
 
-    @Test("An explicit alternate row and header win over the derived ones")
+    @Test("An explicit alternate row wins over the derived one")
     func explicitBeatsDerived() throws {
-        let theme = try Self.theme(.light, [.gridBackground: "#FDF6E3", .gridAlternateRow: "#EEE8D5", .gridHeaderBackground: "#E0DAC8"])
+        let theme = try Self.theme(.light, [.gridBackground: "#FDF6E3", .gridAlternateRow: "#EEE8D5"])
         #expect(theme.value(for: .gridAlternateRow) == .themed(Self.color("#EEE8D5")))
-        #expect(theme.value(for: .gridHeaderBackground) == .themed(Self.color("#E0DAC8")))
-    }
-
-    // MARK: - Selection text
-
-    @Test("Selection text without a themed selection stays native, ignoring the file")
-    func selectionTextNeedsASelection() throws {
-        let theme = try Self.theme(.dark, [.gridSelectionText: "#00FF00", .gridText: "#FF0000"])
-        #expect(theme.value(for: .gridSelectionText) == .system(.gridSelectionText))
-        #expect(!theme.isOverridden(.gridSelectionText))
-        #expect(theme.hasExplicitColor(.gridSelectionText))
-    }
-
-    @Test("Selection text over a themed selection is the file's, else the grid text's value")
-    func selectionTextPairsWithTheSelection() throws {
-        let explicit = try Self.theme(.dark, [.gridSelection: "#44475A", .gridSelectionText: "#00FF00"])
-        #expect(explicit.value(for: .gridSelectionText) == .themed(Self.color("#00FF00")))
-
-        let textOnly = try Self.theme(.dark, [.gridSelection: "#44475A", .gridText: "#F8F8F2"])
-        #expect(textOnly.value(for: .gridSelectionText) == .themed(Self.color("#F8F8F2")))
-
-        let nativeText = try Self.theme(.dark, [.gridSelection: "#44475A"])
-        #expect(nativeText.value(for: .gridSelectionText) == .system(.gridText))
-        #expect(!nativeText.isOverridden(.gridSelectionText))
     }
 
     // MARK: - Slot fallbacks
 
-    @Test("Bools and the header text follow themed grid text, and stay native without it")
+    @Test("Bools follow themed grid text, and stay native without it")
     func gridTextFollowers() throws {
         let themed = try Self.theme(.dark, [.gridText: "#F8F8F2"])
         let text = Self.color("#F8F8F2")
-        for slot in [ThemeSlot.gridBoolTrue, .gridBoolFalse, .gridHeaderText] {
+        for slot in [ThemeSlot.gridBoolTrue, .gridBoolFalse] {
             #expect(themed.value(for: slot) == .themed(text), "\(slot.rawValue)")
             #expect(ThemeDefinition.defaultDark.value(for: slot) == .system(slot), "\(slot.rawValue)")
         }
diff --git a/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotTests.swift b/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotTests.swift
index ffa4e3f785..d8edcf5f54 100644
--- a/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotTests.swift
+++ b/apple/Packages/TableProCore/Tests/TableProThemeTests/ThemeSlotTests.swift
@@ -23,9 +23,9 @@ struct ThemeSlotTests {
         }
     }
 
-    @Test("The registry holds 35 slots")
+    @Test("The registry holds 29 slots")
     func slotCount() {
-        #expect(ThemeSlot.allCases.count == 35)
+        #expect(ThemeSlot.allCases.count == 29)
     }
 
     @Test("Every slot belongs to exactly one group, listed in registry order")
@@ -44,20 +44,29 @@ struct ThemeSlotTests {
         #expect(sectioned.count == ThemeSlot.allCases.count)
     }
 
-    @Test("The editor sections split the data grid into rows, selection and changes")
+    @Test("The editor sections split the data grid into rows and changes")
     func sectionsSplitTheGrid() {
+        #expect(ThemeSlotSection.allCases == [.window, .editor, .syntax, .dataGrid, .changes])
         #expect(ThemeSlotSection.window.slots == [.windowBackdrop])
         #expect(ThemeSlotSection.editor.slots == ThemeSlotGroup.editor.slots)
         #expect(ThemeSlotSection.syntax.slots == ThemeSlotGroup.syntax.slots)
         #expect(ThemeSlotSection.dataGrid.slots == [
-            .gridBackground, .gridText, .gridAlternateRow, .gridHeaderBackground, .gridHeaderText,
+            .gridBackground, .gridText, .gridAlternateRow,
             .gridLine, .gridNullValue, .gridBoolTrue, .gridBoolFalse, .gridRowNumber,
         ])
-        #expect(ThemeSlotSection.selection.slots == [.gridSelection, .gridSelectionText, .gridInactiveSelection, .gridFocusBorder])
         #expect(ThemeSlotSection.changes.slots == [.gridModified, .gridInserted, .gridDeleted, .gridDeletedText])
     }
 
-    /// The theme editor lists one section per group in this order, so the window leads it.
+    @Test("Header and selection colors are the system's, so no slot names them")
+    func noHeaderOrSelectionSlot() {
+        for path in [
+            "dataGrid.headerBackground", "dataGrid.headerText", "dataGrid.selection",
+            "dataGrid.selectionText", "dataGrid.inactiveSelection", "dataGrid.focusBorder",
+        ] {
+            #expect(ThemeSlot(rawValue: path) == nil, "\(path)")
+        }
+    }
+
     @Test("The window group comes first and holds only the window background")
     func windowGroupLeads() {
         #expect(ThemeSlotGroup.allCases.first == .window)
@@ -76,16 +85,14 @@ struct ThemeSlotTests {
             #expect(slot.accessibilityLabel.contains(slot.label), "\(slot.rawValue)")
         }
         #expect(ThemeSlot.editorBackground.accessibilityLabel == "Editor Background")
-        #expect(ThemeSlot.gridSelection.accessibilityLabel == "Data Grid Selection")
+        #expect(ThemeSlot.gridAlternateRow.accessibilityLabel == "Data Grid Alternate Row")
         #expect(ThemeSlot.windowBackdrop.accessibilityLabel == "Window Background")
     }
 
     @Test("Only the fills under everything else require an opaque color")
     func opaqueSlots() {
         let opaque = Set(ThemeSlot.allCases.filter { $0.requiresOpaque })
-        #expect(opaque == [
-            .windowBackdrop, .editorBackground, .gridBackground, .gridHeaderBackground,
-        ])
+        #expect(opaque == [.windowBackdrop, .editorBackground, .gridBackground])
     }
 
     @Test("Opacity is offered on the washes and never on a slot that must be opaque")
@@ -93,8 +100,7 @@ struct ThemeSlotTests {
         let translucent = Set(ThemeSlot.allCases.filter { $0.offersOpacity })
         #expect(translucent == [
             .editorSelection, .editorCurrentLine, .editorCurrentStatement, .editorInvisibles,
-            .gridAlternateRow, .gridSelection, .gridInactiveSelection,
-            .gridModified, .gridInserted, .gridDeleted, .gridDeletedText,
+            .gridAlternateRow, .gridModified, .gridInserted, .gridDeleted, .gridDeletedText,
         ])
         for slot in ThemeSlot.allCases {
             #expect(!(slot.offersOpacity && slot.requiresOpaque), "\(slot.rawValue)")
diff --git a/apple/TablePro/Core/Coordinators/FindCoordinator.swift b/apple/TablePro/Core/Coordinators/FindCoordinator.swift
index c796b1f32e..146c4ac2af 100644
--- a/apple/TablePro/Core/Coordinators/FindCoordinator.swift
+++ b/apple/TablePro/Core/Coordinators/FindCoordinator.swift
@@ -3,130 +3,67 @@
 //  TablePro
 //
 
-import Combine
 import Foundation
-import SwiftUI
 
 @MainActor
-final class FindCoordinator: ObservableObject {
+final class FindCoordinator {
     unowned let parent: MainContentCoordinator
-    private var searchDebounce: DispatchWorkItem?
 
     init(parent: MainContentCoordinator) {
         self.parent = parent
     }
 
-    var selectedTabFindState: TabFindState? {
-        parent.tabManager.selectedTab?.findState
+    private var model: DataGridModel? {
+        parent.activeGridModel
     }
 
-    func show() {
-        mutateSelectedTabFindState { $0.isVisible = true }
+    var hasActiveFind: Bool {
+        guard let find = model?.find else { return false }
+        return find.isVisible && !find.matches.isEmpty
     }
 
-    func dismiss() {
-        searchDebounce?.cancel()
-        searchDebounce = nil
-        mutateSelectedTabFindState {
-            $0.isVisible = false
-            $0.term = ""
-            $0.clearMatches()
-        }
-        parent.dataTabDelegate?.tableViewCoordinator?.applyFindMatch(nil)
-    }
-
-    /// The scan is synchronous and main-actor bound, and a wide table is the expensive case:
-    /// CLAUDE.md flags 500+ columns as the real data-grid cost, so a 1,000-row page is hundreds of
-    /// thousands of range searches per keystroke. Coalescing means one scan per pause, not per key.
-    func setTerm(_ term: String) {
-        mutateSelectedTabFindState { $0.term = term }
-        searchDebounce?.cancel()
-        let work = DispatchWorkItem { [weak self] in self?.runSearch() }
-        searchDebounce = work
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.12, execute: work)
-    }
-
-    func stepForward() {
-        mutateSelectedTabFindState { $0.stepForward() }
-        syncGridToCurrentMatch()
+    func showFind(replace: Bool = false) {
+        model?.showFind(replace: replace)
     }
 
-    func stepBackward() {
-        mutateSelectedTabFindState { $0.stepBackward() }
-        syncGridToCurrentMatch()
+    func findNext() {
+        model?.findNext()
     }
 
-    /// Promotes the term into a server-side filter so the answer covers rows this page never
-    /// loaded. It builds its own filter rows rather than going through `addFilter`, which would
-    /// consult the user's default-column setting, and it never touches the filters they already
-    /// applied.
-    func escalateToAllRows() {
-        guard let tab = parent.tabManager.selectedTab else { return }
-        let term = tab.findState.term.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !term.isEmpty else { return }
-
-        let buffer = parent.tabSessionRegistry.tableRows(for: tab.id)
-        let readsAnyColumn = parent.connection.type.patternFiltersReadAnyColumn
-        let searchable = buffer.columns.indices.filter { index in
-            guard index < buffer.columnTypes.count else { return true }
-            return FindMatcher.isServerSearchable(buffer.columnTypes[index], patternReadsAnyColumn: readsAnyColumn)
-        }
-        guard !searchable.isEmpty else { return }
-
-        dismiss()
-        parent.filterCoordinator.applyCrossColumnSearch(
-            term: term,
-            columns: searchable.map { buffer.columns[$0] }
-        )
+    func findPrevious() {
+        model?.findPrevious()
     }
 
-    func runSearch() {
-        guard let tab = parent.tabManager.selectedTab,
-              let grid = parent.dataTabDelegate?.tableViewCoordinator
-        else { return }
-
-        let term = tab.findState.term.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !term.isEmpty else {
-            invalidateMatches()
-            grid.applyFindMatch(nil)
-            return
-        }
-
-        let matches = grid.runFind(term: term)
-        let anchor = grid.selectedDisplayRow ?? 0
-        mutateSelectedTabFindState { state in
-            state.matches = matches
-            state.scope = self.scope(for: tab)
-            state.currentMatchIndex = FindMatcher.nearestMatchIndex(to: anchor, in: matches)
-        }
-        syncGridToCurrentMatch()
+    func useSelectionForFind() {
+        model?.useSelectionForFind()
     }
 
-    private func syncGridToCurrentMatch() {
-        guard let grid = parent.dataTabDelegate?.tableViewCoordinator else { return }
-        grid.applyFindMatch(parent.tabManager.selectedTab?.findState.currentMatch)
-    }
+    // MARK: - Search All Rows
 
-    /// Rows were replaced underneath the find bar, so the match list describes rows that no
-    /// longer exist. Keep the term and the bar, drop what is stale.
-    func invalidateMatches() {
-        mutateSelectedTabFindState { $0.clearMatches() }
+    func offersSearchAllRows(forTab tabID: UUID) -> Bool {
+        // The search replaces the filter set with one OR group, so it never runs over filters the user applied.
+        guard let tab = parent.tabManager.tabs.first(where: { $0.id == tabID }),
+              tab.tabType == .table,
+              parent.supportsMatchAnyFilters,
+              tab.filterState.filters.isEmpty else { return false }
+        let rows = parent.tabSessionRegistry.tableRows(for: tabID)
+        return tab.pagination.hasUnloadedRows(loadedRowCount: rows.rows.count) && !serverSearchableColumns(in: rows).isEmpty
     }
 
-    /// `hasMoreRows` is the query-tab truncation flag and is never set for a table tab, which pages
-    /// through `currentPage`/`totalPages` instead. Reading only that flag made every table tab claim
-    /// its page was the whole table, which is the exact answer this feature exists to avoid.
-    func scope(for tab: QueryTab) -> FindScope {
-        let loadedRowCount = parent.tabSessionRegistry.tableRows(for: tab.id).rows.count
-        let hasUnloadedRows = tab.pagination.hasMoreRows
-            || tab.pagination.canGoToNextPage(loadedRowCount: loadedRowCount)
-        return hasUnloadedRows ? .pageOfMore : .allRowsLoaded
+    // Its own filter rows: addFilter would apply the user's default-column setting.
+    func searchAllRows(term: String, tabID: UUID) {
+        guard parent.tabManager.selectedTabId == tabID else { return }
+        let columns = serverSearchableColumns(in: parent.tabSessionRegistry.tableRows(for: tabID))
+        guard !columns.isEmpty else { return }
+        parent.filterCoordinator.applyCrossColumnSearch(term: term, columns: columns)
     }
 
-    private func mutateSelectedTabFindState(_ mutate: (inout TabFindState) -> Void) {
-        guard let index = parent.tabManager.selectedTabIndex else { return }
-        var newState = parent.tabManager.tabs[index].findState
-        mutate(&newState)
-        parent.tabManager.mutate(at: index) { $0.findState = newState }
+    func serverSearchableColumns(in rows: TableRows) -> [String] {
+        let readsAnyColumn = parent.connection.type.patternFiltersReadAnyColumn
+        return rows.columns.indices.compactMap { index in
+            let columnType = index < rows.columnTypes.count ? rows.columnTypes[index] : nil
+            guard FindMatcher.isServerSearchable(columnType, patternReadsAnyColumn: readsAnyColumn) else { return nil }
+            return rows.columns[index]
+        }
     }
 }
diff --git a/apple/TablePro/Core/Coordinators/FindMatcher.swift b/apple/TablePro/Core/Coordinators/FindMatcher.swift
index 5c9cfae430..5932ba42ed 100644
--- a/apple/TablePro/Core/Coordinators/FindMatcher.swift
+++ b/apple/TablePro/Core/Coordinators/FindMatcher.swift
@@ -6,9 +6,7 @@
 import Foundation
 
 enum FindMatcher {
-    /// A binary column is searchable once a display format has turned its bytes into characters.
-    /// Left as hex it is not, which is why the exclusion was unconditional while hex was the only
-    /// thing a binary column could show.
+    // A binary column is searchable once a display format has turned its bytes into characters; hex is not.
     static func isSearchable(_ columnType: ColumnType?, displayFormat: ValueDisplayFormat? = nil) -> Bool {
         switch columnType {
         case .blob: displayFormat?.rendersBinaryAsText == true
@@ -17,11 +15,8 @@ enum FindMatcher {
         }
     }
 
-    /// Columns a `LIKE` comparison can be built against without a cast. Postgres has no implicit
-    /// integer to text conversion, so `id ILIKE '%abc%'` fails the whole query rather than matching
-    /// nothing. Client-side matching is looser on purpose: it compares the text already on screen.
-    /// An engine whose pattern filters read a scalar column by its shown text searches those too. A nested value's
-    /// JSON is text only on screen.
+    // Postgres has no implicit integer to text cast, so `id ILIKE '%abc%'` fails the whole query instead of matching
+    // nothing. An engine whose patterns read a scalar column by its shown text searches those too; JSON is text only on screen.
     static func isServerSearchable(_ columnType: ColumnType?, patternReadsAnyColumn: Bool = false) -> Bool {
         if patternReadsAnyColumn, columnType?.isJsonType != true { return isSearchable(columnType) }
         return switch columnType {
@@ -29,34 +24,4 @@ enum FindMatcher {
         default: false
         }
     }
-
-    static func matches(
-        term: String,
-        displayRowCount: Int,
-        columnCount: Int,
-        isColumnSearchable: (Int) -> Bool,
-        cellText: (Int, Int) -> String?
-    ) -> [FindMatch] {
-        let needle = term.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !needle.isEmpty, displayRowCount > 0, columnCount > 0 else { return [] }
-
-        let searchableColumns = (0 ..< columnCount).filter(isColumnSearchable)
-        guard !searchableColumns.isEmpty else { return [] }
-
-        var found: [FindMatch] = []
-        for displayRow in 0 ..< displayRowCount {
-            for column in searchableColumns {
-                guard let text = cellText(displayRow, column), !text.isEmpty else { continue }
-                guard text.range(of: needle, options: [.caseInsensitive, .diacriticInsensitive]) != nil else { continue }
-                found.append(FindMatch(displayRow: displayRow, columnIndex: column))
-            }
-        }
-        return found
-    }
-
-    static func nearestMatchIndex(to displayRow: Int, in matches: [FindMatch]) -> Int? {
-        guard !matches.isEmpty else { return nil }
-        if let forward = matches.firstIndex(where: { $0.displayRow >= displayRow }) { return forward }
-        return 0
-    }
 }
diff --git a/apple/TablePro/Core/Coordinators/PaginationCoordinator.swift b/apple/TablePro/Core/Coordinators/PaginationCoordinator.swift
index 00e7e4e257..820863abb4 100644
--- a/apple/TablePro/Core/Coordinators/PaginationCoordinator.swift
+++ b/apple/TablePro/Core/Coordinators/PaginationCoordinator.swift
@@ -51,7 +51,7 @@ final class PaginationCoordinator: ObservableObject {
         paginateIfPossible { $0.updatePageSize(pageSize) }
     }
 
-    /// Every page move asks this, because an engine that cannot skip rows has only the first page.
+    // An engine that cannot skip rows has only the first page.
     private var canSeek: Bool {
         parent.paginationCapability.allowsSeeking
     }
@@ -64,12 +64,7 @@ final class PaginationCoordinator: ObservableObject {
         paginateIfPossible(where: condition, mutate: mutate)
     }
 
-    /// Only ever sized from a real count.
-    ///
-    /// It used to accept the driver's estimate, so a table MySQL guessed at 420,000 rows loaded
-    /// `LIMIT 420000` and silently dropped the rest while the bar reported the page as complete.
-    /// `Count Exactly` in the status bar is the route to an exact total, and it sits next to the
-    /// estimate that makes this unavailable.
+    // Only sized from a real count: the driver's estimate (MySQL guessed 420,000) loaded a LIMIT that silently dropped rows.
     func showAllRows() {
         guard canSeek,
               let (tab, _) = parent.tabManager.selectedTabAndIndex,
@@ -151,8 +146,7 @@ final class PaginationCoordinator: ObservableObject {
 
     // MARK: - Cancel Current Query
 
-    /// Stop and `Cmd+.` act on the tab the user is looking at. A window-wide stop is what let one
-    /// tab's Stop roll back the batch another tab was running.
+    // Acts on the visible tab: a window-wide stop let one tab's Stop roll back another tab's batch.
     func cancelCurrentQuery() {
         guard let tabId = parent.tabManager.selectedTabId else { return }
         parent.stopExecution(for: tabId)
@@ -171,8 +165,7 @@ final class PaginationCoordinator: ObservableObject {
         let schemaName = tab.tableContext.schemaName
         let filters = tab.filterState.hasAppliedFilters ? tab.filterState.appliedFilters : []
         let logicMode = tab.filterState.filterLogicMode
-        /// A browse narrowed by the plugin's own search runs that search instead of the table
-        /// filters, so the count has to read the same search or it counts the whole table.
+        // A plugin search replaces the table filters in a narrowed browse, so the count must read it or it counts the whole table.
         let browseFilters = parent.filterCoordinator.activeBrowseSearch(for: tab.filterState)?.pluginQueryFilters
         let isNonSQL = PluginManager.shared.editorLanguage(for: parent.connection.type) != .sql
         let queryColumns = parent.queryColumns(for: tab)
@@ -181,9 +174,7 @@ final class PaginationCoordinator: ObservableObject {
             columns: queryColumns.columns, columnTypes: queryColumns.columnTypes
         )
 
-        /// Taking the task slot supersedes whatever automatic count held it, so this claims that
-        /// count's flag too. Leaving it set would strand it: the superseded task's completion finds
-        /// the token changed and correctly declines to clear a successor's state.
+        // Claims the superseded automatic count's flag too: its task finds the token changed and won't clear a successor's state.
         parent.tabManager.mutate(at: index) { tab in
             tab.pagination.isCountingExact = true
             tab.pagination.isCountPending = false
@@ -202,13 +193,9 @@ final class PaginationCoordinator: ObservableObject {
                 countSQL: countSQL
             )
 
-            /// The flag says a count is running, so it has to clear on every way out. Returning
-            /// early on cancellation left it set, and a page turn cancels this task, so turning a
-            /// page during a long COUNT(*) used to leave a spinner that never stopped and a
-            /// `Count Exactly` that never came back for that tab.
+            // Clears on every exit: returning early on cancel left a page turn during COUNT(*) with an endless spinner and no Count Exactly.
             let isCurrent = !Task.isCancelled && parent.tabExecution.isSameContent(contentEpoch, for: tabId)
-            /// Cancelling through `Cmd+.` clears the flag and lets a second count start, so a late
-            /// first task would otherwise stop the second one's spinner while its query still runs.
+            // `Cmd+.` clears the flag and allows a second count, so a late first task must not stop the second one's spinner.
             let ownsIndicator = parent.releaseExactCount(for: tabId, token: token)
             parent.clearRowCountTask(for: tabId, token: token)
             parent.tabManager.mutate(tabId: tabId) { tab in
@@ -240,8 +227,7 @@ final class PaginationCoordinator: ObservableObject {
         }
     }
 
-    /// The user asked for this count, so a failure is shown on the tab rather than dropped: an engine whose count
-    /// only its driver can run, such as a throttled DynamoDB scan, has no other answer to fall back on.
+    // User-requested, so a failure shows on the tab: an engine only its driver can count (throttled DynamoDB scan) has no fallback.
     private static func exactRowCount(
         scope: DatabaseScope,
         tableName: String,
@@ -268,8 +254,7 @@ final class PaginationCoordinator: ObservableObject {
 
     // MARK: - Fetch All Rows
 
-    /// The scope is read before the confirmation alert, so a database change made while
-    /// the alert is open cannot send the tab's own query somewhere else.
+    // The scope is read before the alert, so a database change while it is open can't redirect the tab's query.
     func fetchAllRows() {
         guard let (tab, _) = parent.tabManager.selectedTabAndIndex,
               !tab.pagination.isLoadingMore,
@@ -308,12 +293,7 @@ final class PaginationCoordinator: ObservableObject {
         }
     }
 
-    /// Only the driver work runs inside the lease. Applying the rows to the tab stays
-    /// outside it, because the connection's driver gate is not reentrant.
-    ///
-    /// The rows belong to the result the fetch was started on. A result switch leaves the content
-    /// epoch alone, so the fetch is fenced on the result set as well, or the full row set lands on
-    /// whichever result is showing when it arrives, normalized to that result's column count.
+    // Only driver work runs in the lease (the gate isn't reentrant). Fenced on the result set too: a result switch keeps the epoch.
     internal func performFetchAll(tabId: UUID, baseQuery: String, scope: DatabaseScope) {
         guard let idx = parent.tabManager.tabs.firstIndex(where: { $0.id == tabId }) else { return }
         guard !parent.tabManager.tabs[idx].pagination.isLoadingMore else { return }
@@ -324,10 +304,7 @@ final class PaginationCoordinator: ObservableObject {
 
         parent.tabManager.mutate(at: idx) { $0.pagination.isLoadingMore = true }
 
-        /// Fetch All extends the result already on screen instead of replacing it, so it validates
-        /// against the tab's content epoch and cannot claim the tab: claiming mints a new epoch and
-        /// would discard its own rows. It registers as unclaimed work instead, which is what keeps
-        /// the titlebar reporting it, and releases that on every exit including cancellation.
+        // Can't claim the tab: claiming mints a new epoch and drops its own rows. Unclaimed work keeps the titlebar reporting it.
         let workToken = parent.tabExecution.beginUnclaimedWork(for: tabId)
         let owner = TabQueryTaskOwner.unclaimedWork(tabId: tabId, token: workToken)
         let lease = DriverLeaseOwner()
@@ -335,9 +312,7 @@ final class PaginationCoordinator: ObservableObject {
         let lengthColumns = isTableTab ? parent.unloadedValueLengthColumns(for: parent.tabManager.tabs[idx]) : []
 
         let startedAt = ContinuousClock.Instant.now
-        /// Both releases belong to the whole task rather than to its exits: the cancelled path used
-        /// to clear the loading flag and bare return, leaving a finished fetch installed under the
-        /// tab's id, and the next `installQueryTask` read it as a live displaced entry and ended it.
+        // Both releases cover the whole task: a cancelled bare return left a finished fetch installed, which `installQueryTask` then ended.
         let fetchAllTask = Task { [weak self, parent] in
             defer {
                 parent.tabExecution.endUnclaimedWork(workToken, for: tabId)
@@ -364,12 +339,7 @@ final class PaginationCoordinator: ObservableObject {
                 progressLog.info("[fetchAll] rows=\(result.rows.count) fetchTime=\(String(format: "%.3f", fetchTime))s")
 
                 guard !Task.isCancelled else {
-                    /// Every other exit from this function clears the flag, and this one used to
-                    /// bare return, so a fetch-all cancelled after its rows had already arrived
-                    /// left the tab showing "Loading…" for good with Fetch All hidden, healed
-                    /// only by re-running the query. Deterministic on any driver whose
-                    /// `cancelQuery()` is the PluginKit no-op default, because the fetch always
-                    /// runs to completion there and returns straight into this guard.
+                    // Clears the flag like every exit: a bare return stuck the tab on Loading after a late cancel (no-op `cancelQuery()` drivers).
                     await MainActor.run { [weak self] in
                         self?.parent.tabManager.mutate(tabId: tabId) { tab in
                             tab.pagination.isLoadingMore = false
@@ -388,7 +358,7 @@ final class PaginationCoordinator: ObservableObject {
                     }
                     guard let idx = parent.tabManager.tabs.firstIndex(where: { $0.id == tabId }) else { return }
 
-                    let replaceDelta = parent.mutateActiveTableRows(for: tabId) { rows in
+                    parent.mutateActiveTableRows(for: tabId) { rows in
                         rows.replace(
                             rows: result.rows,
                             rowLocators: isTableTab ? result.rowLocators : nil,
@@ -402,7 +372,6 @@ final class PaginationCoordinator: ObservableObject {
                         tab.pagination.resetLoadMore()
                         tab.display.activeResultSet?.isTruncated = false
                     }
-                    parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(replaceDelta)
                     parent.toolbarState.recordQueryTiming(result.resolvedTiming, for: tabId)
 
                     let totalTime = CFAbsoluteTimeGetCurrent() - start
diff --git a/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Helpers.swift b/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Helpers.swift
index fa85298a11..241ff38ad0 100644
--- a/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Helpers.swift
+++ b/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Helpers.swift
@@ -30,7 +30,6 @@ extension QueryExecutionCoordinator {
         return cap
     }
 
-    /// The text to send for a tab's read and the cap the app keeps on its result.
     func resolveStatement(sql: String, tabType: TabType, bypassLimit: Bool = false) -> LeadingRowsStatement {
         LeadingRowsStatement.resolve(
             sql,
@@ -51,8 +50,7 @@ extension QueryExecutionCoordinator {
         )
     }
 
-    /// History belongs to the database the tab actually ran on, not to wherever the
-    /// sidebar happens to point when the entry is written.
+    // History belongs to the database the tab ran on, not wherever the sidebar points when the entry is written.
     func historyDatabaseName(tabId: UUID) -> String {
         guard let tab = parent.tabManager.tabs.first(where: { $0.id == tabId }) else {
             return parent.browseDatabaseName
@@ -65,16 +63,13 @@ extension QueryExecutionCoordinator {
         return parent.scope(for: tab)?.schema
     }
 
-    /// A table tab's SQL is generated by the app for browsing, paging, sorting and filtering.
-    /// It is recorded so the user can audit what was sent, but it is not something they authored.
+    // A table tab's SQL is app-generated: recorded so the user can audit it, but not something they authored.
     func historySource(tabId: UUID) -> QueryHistorySource {
         guard let tab = parent.tabManager.tabs.first(where: { $0.id == tabId }) else { return .editor }
         return tab.tabType == .table ? .tableBrowse : .editor
     }
 
-    /// Never after the table's definition changed: the keys, defaults, generated columns and row
-    /// match policy the tab holds describe the table before the change, and reusing them builds the
-    /// next edit against the old definition.
+    // Never after a definition change: the cached keys, defaults, generated columns and match policy describe the old table.
     func isMetadataCached(tabId: UUID, tableName: String) -> Bool {
         guard let idx = parent.tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               !parent.tabSessionRegistry.needsDefinition(tabId)
@@ -100,12 +95,7 @@ extension QueryExecutionCoordinator {
         return cached
     }
 
-    /// Deliberately does not set `foreignKeysFetched`. The prefetch answers which columns carry the
-    /// arrow, which is all the first paint needs; defaults, primary keys, nullability and comments
-    /// still come from the table's own metadata fetch, and claiming they had arrived would let
-    /// `isMetadataCached` skip it.
-    ///
-    /// The table load started this scope's read beside its rows; a miss here starts it for a load that did not.
+    // Leaves `foreignKeysFetched` unset: the prefetch covers only FK arrows, and claiming more lets `isMetadataCached` skip it.
     private func prefetchedForeignKeys(tabIndex: Int, tableName: String) -> [String: ForeignKeyInfo]? {
         guard tabIndex < parent.tabManager.tabs.count,
               let scope = parent.scope(for: parent.tabManager.tabs[tabIndex])
@@ -131,13 +121,7 @@ extension QueryExecutionCoordinator {
         var foreignKeysFetched = false
     }
 
-    /// A rerun answered from cache carries no metadata of its own, so it takes the snapshot the
-    /// caller captured when it made that cache decision. That includes the non-writable set, which
-    /// `configureForTable` clears on every execution and only a schema fetch refills.
-    ///
-    /// The snapshot is never re-read from the session here. Reading it at this point reads whichever
-    /// result is active by then, and selecting a pinned result while the rerun was in flight made
-    /// the rerun adopt that other result's identity and non-writable sets.
+    // The caller's snapshot, never re-read: selecting a pinned result mid-rerun gave the rerun that result's identity.
     private func resolveDisplayMetadata(
         metadata: ParsedSchemaMetadata?,
         columns: [String],
@@ -174,9 +158,7 @@ extension QueryExecutionCoordinator {
         return resolved
     }
 
-    /// The keys a committed result is edited by. Keys the tab held for the same table carry over
-    /// while its definition is unchanged, until phase 2 reports them. After a definition change they
-    /// describe the table as it was, so they are never carried into the new result.
+    // Same-table keys carry over until phase 2 reports, but never across a definition change: they describe the old table.
     static func resolvedPrimaryKeys(
         reported: [String]?,
         engineDefault: String?,
@@ -276,9 +258,7 @@ extension QueryExecutionCoordinator {
         let definitionChanged = parent.tabSessionRegistry.needsDefinition(existingTabId)
         parent.flushBufferToActiveResult(tabId: existingTabId, pinnedOnly: true)
         parent.setActiveTableRows(newTableRows, for: existingTabId, viewport: viewport, source: source)
-        /// A count that started before the change can land after it, while the tab is out of sight,
-        /// and put the old total back. Kept, a total above the automatic-count threshold stops the
-        /// count this read launches, so paging stays bounded by the table as it was.
+        // A pre-change count can land late with the old total; a kept total over the auto-count threshold stops this read's count.
         let answeredRowsChange = parent.tabSessionRegistry.recordRead(read, for: existingTabId)
         let usesBrowseSearch = parent.filterCoordinator.usesBrowseSearch
 
@@ -468,9 +448,7 @@ extension QueryExecutionCoordinator {
         let contentEpoch = parent.tabExecution.contentEpoch(for: tabId)
         let resultSetId = parent.tabManager.tabs.first { $0.id == tabId }?.display.activeResultSetId
         Task(priority: .utility) { [weak self, parent] in
-            /// The caller marked the total pending when it committed to this phase. Every way out of
-            /// here that does not reach `resolveRowCount` has to take that back, or the tab reports a
-            /// count that is never coming and never offers `Count Exactly` again.
+            // The caller marked the total pending; every exit that skips `resolveRowCount` must release it, or Count Exactly never returns.
             guard let self else {
                 parent.releaseCountPending(for: tabId)
                 return
@@ -490,8 +468,7 @@ extension QueryExecutionCoordinator {
                 if let schema {
                     applySchemaMetadata(schema, tabId: tabId, tableName: tableName, resultSetId: resultSetId)
                 }
-                /// A retarget or a re-execution that overtook this one owns the tab's state now, and
-                /// it raised its own pending mark. Clearing here would release the successor's.
+                // A retarget or newer run owns the tab now with its own pending mark; clearing here would release the successor's.
                 guard parent.tabExecution.isSameContent(contentEpoch, for: tabId) else { return }
                 resolveRowCount(
                     tableName: tableName,
@@ -516,11 +493,7 @@ extension QueryExecutionCoordinator {
         }
     }
 
-    /// Stamps the active result with the table its rows came from.
-    ///
-    /// `QueryTab.tableContext` always describes the newest execution, so a result the user later
-    /// clicks back to has to carry its own identity or an edit made on it is written against
-    /// whatever ran last (#2243).
+    // `QueryTab.tableContext` tracks the newest run, so each result carries its own origin or edits hit whatever ran last (#2243).
     func captureOrigin(
         tabIndex: Int,
         tabId: UUID,
@@ -542,10 +515,7 @@ extension QueryExecutionCoordinator {
         )
     }
 
-    /// Phase-2 metadata belongs to the result its fetch was launched for, not to whatever the tab
-    /// happens to be showing when it lands. A query tab can hold several results and the user can
-    /// switch between them while the schema round trips, so keying on the tab's current table name
-    /// paints one table's foreign keys, defaults and primary keys onto another table's rows.
+    // Keyed on the result the fetch was for: keying on the tab's table name painted one table's FKs and keys onto another's rows.
     private func resultStillActive(_ tabId: UUID, _ resultSetId: UUID?) -> Bool {
         parent.tabManager.tabs.contains { $0.id == tabId && $0.display.activeResultSetId == resultSetId }
     }
@@ -564,9 +534,7 @@ extension QueryExecutionCoordinator {
     ) {
         let parsed = parseSchemaMetadata(schema)
         guard resultStillActive(tabId, resultSetId) else {
-            /// The result this was fetched for is still there, the user is just looking at another
-            /// one. Dropping the metadata left it with no account of which columns the server owns,
-            /// and nothing re-fetches on the way back, so the result stayed that way for good.
+            // Dropping it left the result with no account of server-owned columns, and nothing re-fetches on the way back.
             applyPhase2MetadataToInactiveResult(parsed: parsed, tabId: tabId, resultSetId: resultSetId)
             helpersLogger.info("[fk] phase2 applied to an inactive result table=\(tableName, privacy: .private(mask: .hash))")
             return
@@ -621,9 +589,6 @@ extension QueryExecutionCoordinator {
             return .columnsReplaced
         }
         parent.tabManager.mutate(tabId: tabId) { $0.metadataVersion += 1 }
-        if isActiveTab(tabId) {
-            parent.dataTabDelegate?.tableViewCoordinator?.refreshCellPresentations()
-        }
     }
 
     private func applyPhase2Metadata(parsed: ParsedSchemaMetadata, tabId: UUID) {
@@ -666,9 +631,10 @@ extension QueryExecutionCoordinator {
             parent.changeManager.setRowMatchPolicy(parsed.rowMatchPolicy)
         }
 
+        // The metadata delta rebuilt the model's columns; the foreign key arrows need the rows redrawn.
         let refreshed = isActiveTab(tabId)
         if refreshed {
-            parent.dataTabDelegate?.tableViewCoordinator?.refreshCellPresentations()
+            parent.existingGridModel(forTab: tabId)?.repaintAllRows()
         }
         helpersLogger.info(
             "[fk] phase2 applied tab=\(tabId, privacy: .public) fks=\(parsed.columnForeignKeys?.count ?? -1) defaults=\(parsed.columnDefaults.count) activeTabRefreshed=\(refreshed)"
@@ -687,9 +653,7 @@ extension QueryExecutionCoordinator {
         )
     }
 
-    /// Validates against the tab's content identity, not the execution claim. The claim is settled
-    /// the moment phase 1 is applied, which happens before phase 2 is even dispatched, so a claim
-    /// check here is false on every run and the count never lands.
+    // Checks content identity, not the execution claim: the claim settles before phase 2 dispatches, so the count never landed.
     func resolveRowCount(
         tableName: String,
         tabId: UUID,
@@ -742,9 +706,7 @@ extension QueryExecutionCoordinator {
             )
 
             await MainActor.run {
-                /// The flag says a count is running, so it has to clear on every way out, including
-                /// the ones that apply nothing. Only the task that still owns the slot may clear it,
-                /// or a superseded task would release the successor that replaced it.
+                // Clears the running flag on every exit, but only for the slot's owner, or a superseded task releases its successor.
                 let ownsCount = parent.clearRowCountTask(for: tabId, token: token)
                 let isCurrent = parent.tabExecution.isSameContent(contentEpoch, for: tabId)
                 parent.tabManager.mutate(tabId: tabId) { tab in
@@ -759,8 +721,7 @@ extension QueryExecutionCoordinator {
         parent.setRowCountTask(task, token: token, for: tabId)
     }
 
-    /// Runs the plan the caller resolved. Split out so `resolveRowCount` has one exit that clears
-    /// `isCountPending`, rather than an early return per plan that leaves it set.
+    // Split out so `resolveRowCount` has one exit that clears `isCountPending`.
     private static func rowCountOutcome(
         plan: RowCountPlan,
         count exactCount: ExactCountInput?,
@@ -816,13 +777,7 @@ extension QueryExecutionCoordinator {
         }
     }
 
-    /// `countsAutomatically` is `PluginManager.countsRowsAutomatically(for:)`: an engine that cannot skip rows, or
-    /// whose count is a billed scan, is only counted when the user asks.
-    ///
-    /// `browseSearch` is the search the browse runs in place of the table filters, such as a Redis key
-    /// pattern. The table's estimate measures the whole database, not the keys that search lists, so it is
-    /// never the answer. A search change retires the total, which is why nothing is cleared here: a page
-    /// turn after `Count Exactly` keeps that count.
+    // A browse search never takes the table estimate (it covers the whole database); not clearing keeps Count Exactly across pages.
     static func rowCountPlan(
         isNonSQL: Bool,
         filterState: TabFilterState,
@@ -849,8 +804,7 @@ extension QueryExecutionCoordinator {
         return exceedsThreshold ? .skip : .exactCount(filtered: false)
     }
 
-    /// Reports a failure that belongs to this tab. Ownership of the window's task handle and the
-    /// spinner is settled by the caller before this runs, so nothing here touches them.
+    // The caller settles the window's task handle and spinner before this runs, so nothing here touches them.
     func handleQueryExecutionError(
         _ error: Error,
         sql: String,
@@ -887,9 +841,7 @@ extension QueryExecutionCoordinator {
 }
 
 extension QueryExecutionCoordinator {
-    /// Shows a failure on the tab it belongs to without recording a statement that never ran, so a
-    /// step that fails before the tab's query, such as the database switch in front of it, leaves
-    /// no history row and nothing for Fix with AI to rewrite.
+    // Records no history: a step failing before the tab's query (such as the database switch) leaves nothing for Fix with AI.
     func presentTabFailure(
         _ message: String,
         announcing diagnosis: String,
@@ -901,14 +853,12 @@ extension QueryExecutionCoordinator {
             tab.pagination.isLoading = false
             recordingExecution(&tab)
 
-            // The banner lives at the top of the results pane, so a collapsed pane hides the only
-            // thing telling the user their query failed. Every success path opens it the same way.
+            // The error banner sits at the top of the results pane, so a collapsed pane would hide the only sign the query failed.
             if tab.display.isResultsCollapsed {
                 tab.display.isResultsCollapsed = false
             }
         }
-        // The toolbar mirrors the selected tab, so a failure on a tab in the background describes
-        // itself on its own tab and leaves the window chrome to whatever is actually on screen.
+        // The toolbar mirrors the selected tab, so a background tab's failure leaves the window chrome alone.
         if parent.tabManager.selectedTabId == tabId {
             parent.toolbarState.isResultsCollapsed = false
             parent.toolbarState.clearQueryTiming(forTab: tabId)
@@ -936,13 +886,7 @@ enum RowCountOutcome: Equatable {
     case count(Int, isApproximate: Bool)
     case clear
 
-    /// An estimate of zero or less means "unknown", never "this table is empty": an un-analyzed
-    /// table reports 0 or -1 while holding millions of rows. An exact zero is trustworthy.
-    ///
-    /// Returns nil for "no answer", which is not the same as an answer of nothing. Phase 1 has
-    /// usually already put an estimate on screen by the time this lands, so an unusable estimate
-    /// must leave that alone rather than blank it. Only `.clear` means the count is genuinely
-    /// gone, which is what a filter change asks for.
+    // Nil is no answer, not zero: an estimate <= 0 is unknown (un-analyzed tables report 0 or -1), so phase 1's estimate stays.
     var appliedTotal: (total: Int?, isApproximate: Bool)? {
         switch self {
         case .clear:
diff --git a/apple/TablePro/Core/Coordinators/RowEditingCoordinator+Discard.swift b/apple/TablePro/Core/Coordinators/RowEditingCoordinator+Discard.swift
index e20e625615..8d6ce18209 100644
--- a/apple/TablePro/Core/Coordinators/RowEditingCoordinator+Discard.swift
+++ b/apple/TablePro/Core/Coordinators/RowEditingCoordinator+Discard.swift
@@ -10,9 +10,7 @@ import TableProPluginKit
 extension RowEditingCoordinator {
     // MARK: - Sidebar Transaction
 
-    /// Edits made in the row inspector belong to the selected tab, so they run on that
-    /// tab's database. The scope is read before the authorization prompt, which awaits a
-    /// sheet and Touch ID and gives the selection time to move somewhere else.
+    // Scope is read before the authorization prompt (sheet and Touch ID), which gives the selection time to move.
     func executeSidebarChanges(steps: [DataWriteStep]) async throws {
         guard let scope = parent.selectedTabScope else {
             throw DatabaseError.notConnected
@@ -68,71 +66,31 @@ extension RowEditingCoordinator {
         parent.resumeDeferredTableRefresh()
     }
 
-    /// Puts the loaded rows back the way the server last reported them.
-    ///
-    /// An edit is written straight into the tab's `TableRows` as well as being recorded, so
-    /// clearing the change records alone leaves the edited values on screen with nothing tracking
-    /// them, and the next edit captures an unsaved value as its baseline. A discard that re-queries
-    /// replaces the buffer wholesale and needs none of this; one that does not has to undo it here.
+    // Edits are written into the loaded rows too; a discard that does not re-query must undo them here or they stay untracked.
     func restoreRowBufferToOriginals() {
-        var deltas: [Delta] = []
-        if let (tab, _) = parent.tabManager.selectedTabAndIndex,
-           let tableRows = parent.tabSessionRegistry.existingTableRows(for: tab.id) {
-            let tabId = tab.id
-            let insertedIDs = parent.changeManager.insertedRowIDs
-            var restoredCells: [(rowID: RowID, columnIndex: Int)] = []
-            var absentCells: Set<CellPosition> = []
-            let edits = parent.changeManager.getOriginalValues().compactMap { original in
-                tableRows.index(of: original.rowID).map { storageRow -> (row: Int, column: Int, value: PluginCellValue) in
-                    restoredCells.append((rowID: original.rowID, columnIndex: original.columnIndex))
-                    if original.isAbsent {
-                        absentCells.insert(CellPosition(row: storageRow, column: original.columnIndex))
-                    }
-                    return (row: storageRow, column: original.columnIndex, value: original.value)
-                }
-            }
-            if !edits.isEmpty {
-                let editDelta = parent.mutateActiveTableRows(for: tabId) { rows in
-                    rows.editMany(edits, absentCells: absentCells)
-                }
-                /// `editMany` names the rows it changed by their position in storage, and the grid
-                /// reads a delta's rows as display positions.
-                if editDelta != .none {
-                    deltas.append(restoredCellsDelta(restoredCells, in: tableRows))
-                }
-            }
-            if !insertedIDs.isEmpty {
-                let removeDelta = parent.mutateActiveTableRows(for: tabId) { rows in
-                    rows.remove(rowIDs: insertedIDs)
-                }
-                if removeDelta != .none {
-                    deltas.append(removeDelta)
+        guard let (tab, _) = parent.tabManager.selectedTabAndIndex,
+              let tableRows = parent.tabSessionRegistry.existingTableRows(for: tab.id) else {
+            parent.gridDisplayRevision &+= 1
+            return
+        }
+        let tabId = tab.id
+        let insertedIDs = parent.changeManager.insertedRowIDs
+        var absentCells: Set<CellPosition> = []
+        let edits = parent.changeManager.getOriginalValues().compactMap { original in
+            tableRows.index(of: original.rowID).map { storageRow -> (row: Int, column: Int, value: PluginCellValue) in
+                if original.isAbsent {
+                    absentCells.insert(CellPosition(row: storageRow, column: original.columnIndex))
                 }
+                return (row: storageRow, column: original.columnIndex, value: original.value)
             }
         }
-
-        for delta in deltas {
-            parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(delta)
+        if !edits.isEmpty {
+            parent.mutateActiveTableRows(for: tabId) { rows in rows.editMany(edits, absentCells: absentCells) }
         }
-        /// The row inspector reads its fields from the buffer this just rewrote, and nothing else
-        /// in `InspectorTrigger` moves on a discard.
-        parent.gridDisplayRevision &+= 1
-    }
-
-    private func restoredCellsDelta(
-        _ cells: [(rowID: RowID, columnIndex: Int)],
-        in tableRows: TableRows
-    ) -> Delta {
-        let displayIDs = parent.activeGridDisplayIDs
-        var positions: Set<CellPosition> = []
-        for cell in cells {
-            guard let displayRow = DisplayRowMapping.displayIndex(
-                forRowID: cell.rowID,
-                displayIDs: displayIDs,
-                in: tableRows
-            ) else { continue }
-            positions.insert(CellPosition(row: displayRow, column: cell.columnIndex))
+        if !insertedIDs.isEmpty {
+            parent.mutateActiveTableRows(for: tabId) { rows in rows.remove(rowIDs: insertedIDs) }
         }
-        return positions.isEmpty ? .none : .cellsChanged(positions)
+        // The inspector reads its fields from the rows this rewrote, and nothing else it watches moves on a discard.
+        parent.gridDisplayRevision &+= 1
     }
 }
diff --git a/apple/TablePro/Core/Coordinators/RowEditingCoordinator.swift b/apple/TablePro/Core/Coordinators/RowEditingCoordinator.swift
index 1924913fec..6d1197fa6b 100644
--- a/apple/TablePro/Core/Coordinators/RowEditingCoordinator.swift
+++ b/apple/TablePro/Core/Coordinators/RowEditingCoordinator.swift
@@ -11,11 +11,7 @@ import TableProPluginKit
 final class RowEditingCoordinator: ObservableObject {
     unowned let parent: MainContentCoordinator
 
-    /// A save is between assembling its statements and hearing back.
-    ///
-    /// Nothing clears the pending changes until the write returns, so a second Cmd+S inside the
-    /// round trip finds them still there, assembles the same statements again and commits them
-    /// twice. Over a slow link that is easy to do by accident.
+    // Nothing clears the pending changes until the write returns, so a second Cmd+S in the round trip would commit twice.
     private(set) var isSaveInFlight = false
 
     init(parent: MainContentCoordinator) {
@@ -32,9 +28,7 @@ final class RowEditingCoordinator: ObservableObject {
         isSaveInFlight = false
     }
 
-    /// A row command selects the row it just made so the grid can highlight it and scroll to it.
-    /// No other mode has a grid to point at, and the JSON view reads the same selection as "show
-    /// only these rows", so writing it there collapses the document to the one new row.
+    // A row command selects the row it made. The JSON view reads the selection as "show only these rows".
     private var selectionPointsTheGrid: Bool {
         parent.tabManager.selectedTab?.display.resultsViewMode == .data
     }
@@ -47,12 +41,11 @@ final class RowEditingCoordinator: ObservableObject {
               tab.tableContext.tableName != nil else { return }
 
         let tabId = tab.id
-        /// A new row is pre-filled from the schema's account of which columns the server owns, so
-        /// staging one before that account exists writes NULL into an identity column.
+        // Pre-filled from the schema's account of which columns the server owns; without it an identity gets NULL.
         let tableRows = parent.tabSessionRegistry.tableRows(for: tabId)
         guard tableRows.hasAuthoritativeSchema else { return }
 
-        parent.dataTabDelegate?.tableViewCoordinator?.commitActiveCellEdit()
+        parent.commitActiveGridEdit()
 
         let uuidKeys = uuidKeyForms(in: tableRows, tab: tab)
         var addResult: RowOperationsManager.AddNewRowResult?
@@ -65,17 +58,18 @@ final class RowEditingCoordinator: ObservableObject {
         guard let result = addResult else { return }
 
         parent.tabManager.mutate(at: tabIndex) { $0.hasUserInteraction = true }
-        parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(result.delta)
         selectAndEditInsertedRow(result.rowID, tabId: tabId, skipping: result.prefilledColumns)
     }
 
-    func deleteSelectedRows(indices: Set<Int>) {
+    func deleteRows(_ rowIDs: [RowID]) {
         guard parent.canEditActiveResult,
               let (tab, tabIndex) = parent.tabManager.selectedTabAndIndex,
-              !indices.isEmpty else { return }
+              !rowIDs.isEmpty else { return }
 
         let tabId = tab.id
-        let displayIDs = parent.activeGridDisplayIDs
+        let model = parent.gridModel(forTab: tabId)
+        let displayIndices = Set(rowIDs.compactMap { model.displayIndex(of: $0) })
+        let displayCount = model.rowCount
 
         var deleteResult = RowOperationsManager.DeleteRowsResult(
             nextRowToSelect: -1,
@@ -83,9 +77,10 @@ final class RowEditingCoordinator: ObservableObject {
             delta: .none
         )
         parent.mutateActiveTableRows(for: tabId) { rows in
-            let result = parent.rowOperationsManager.deleteSelectedRows(
-                selectedIndices: indices,
-                displayIDs: displayIDs,
+            let result = parent.rowOperationsManager.deleteRows(
+                rowIDs,
+                selectedDisplayIndices: displayIndices,
+                displayCount: displayCount,
                 tableRows: &rows
             )
             deleteResult = result
@@ -95,24 +90,27 @@ final class RowEditingCoordinator: ObservableObject {
         guard deleteResult.stagedRowCount > 0 else { return }
 
         parent.tabManager.mutate(at: tabIndex) { $0.hasUserInteraction = true }
+        model.repaintRows(rowIDs)
 
-        if !deleteResult.physicallyRemovedIndices.isEmpty {
-            parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(deleteResult.delta)
+        guard selectionPointsTheGrid else { return }
+        if let next = model.rowID(at: deleteResult.nextRowToSelect) {
+            model.selectRows([next])
         } else {
-            parent.dataTabDelegate?.tableViewCoordinator?.invalidateCachesForUndoRedo()
+            model.clearSelection()
         }
+    }
 
-        guard selectionPointsTheGrid else { return }
-        let displayCount = parent.activeGridDisplayIDs?.count
-            ?? parent.tabSessionRegistry.tableRows(for: tabId).count
-        if deleteResult.nextRowToSelect >= 0 && deleteResult.nextRowToSelect < displayCount {
-            parent.selectionState.indices = [deleteResult.nextRowToSelect]
-        } else {
-            parent.selectionState.indices.removeAll()
+    func undoRowDeletions(_ rowIDs: [RowID]) {
+        guard parent.canEditActiveResult, let tabId = parent.tabManager.selectedTabId else { return }
+        let deleted = rowIDs.filter { parent.changeManager.isRowDeleted($0) }
+        guard !deleted.isEmpty else { return }
+        for rowID in deleted {
+            parent.changeManager.undoRowDeletion(rowID: rowID)
         }
+        parent.existingGridModel(forTab: tabId)?.repaintRows(deleted)
     }
 
-    func duplicateSelectedRow(index: Int) {
+    func duplicateRow(_ rowID: RowID) {
         guard parent.canEditActiveResult,
               let (tab, tabIndex) = parent.tabManager.selectedTabAndIndex,
               tab.tableContext.tableName != nil else { return }
@@ -120,14 +118,12 @@ final class RowEditingCoordinator: ObservableObject {
         let tabId = tab.id
         let tableRows = parent.tabSessionRegistry.tableRows(for: tabId)
         guard tableRows.hasAuthoritativeSchema,
-              let storageIndex = DisplayRowMapping.rowIndex(
-                  forDisplay: index, displayIDs: parent.activeGridDisplayIDs, in: tableRows
-              ) else { return }
-        guard parent.unloadedValuesAreLoaded(displayRows: [index], retry: { [weak self] in
-            self?.duplicateSelectedRow(index: index)
+              let storageIndex = tableRows.index(of: rowID) else { return }
+        guard parent.unloadedValuesAreLoaded(rowIDs: [rowID], retry: { [weak self] in
+            self?.duplicateRow(rowID)
         }) else { return }
 
-        parent.dataTabDelegate?.tableViewCoordinator?.commitActiveCellEdit()
+        parent.commitActiveGridEdit()
 
         let uuidKeys = uuidKeyForms(in: tableRows, tab: tab)
         var dupResult: RowOperationsManager.AddNewRowResult?
@@ -144,18 +140,33 @@ final class RowEditingCoordinator: ObservableObject {
         guard let result = dupResult else { return }
 
         parent.tabManager.mutate(at: tabIndex) { $0.hasUserInteraction = true }
-        parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(result.delta)
         selectAndEditInsertedRow(result.rowID, tabId: tabId, skipping: result.prefilledColumns)
     }
 
-    /// The caret skips a key the row was given a fresh UUID for, so the first keystroke does not replace it.
+    // The caret skips a key the row was given a fresh UUID for, so the first keystroke does not replace it.
     private func selectAndEditInsertedRow(_ rowID: RowID, tabId: UUID, skipping prefilled: Set<Int>) {
         guard selectionPointsTheGrid,
-              let displayIndex = displayIndex(of: rowID, tabId: tabId) else { return }
-        parent.selectionState.indices = [displayIndex]
-        parent.dataTabDelegate?.tableViewCoordinator?.beginEditingFirstEditableColumn(
-            displayRow: displayIndex, skipping: prefilled
-        )
+              let model = parent.existingGridModel(forTab: tabId),
+              let displayRow = model.displayIndex(of: rowID) else { return }
+        let row = model.rows.row(withID: rowID)
+        let typable = model.columns.columns.filter { model.isColumnWritable($0) && Self.takesTypedText($0, in: row) }
+        // Column 0 is where the row starts, not always where it can be typed into: the server may own it.
+        guard let column = typable.first(where: { !prefilled.contains($0.dataIndex) }) ?? typable.first ?? model.columns.columns.first,
+              let displayColumn = model.columns.displayPosition(of: column.id) else {
+            model.selectRows([rowID])
+            model.reveal(rowID: rowID)
+            return
+        }
+        model.selectCell(GridCoord(row: displayRow, displayColumn: displayColumn))
+        model.reveal(rowID: rowID, columnID: column.id)
+        if typable.contains(where: { $0.id == column.id }) {
+            model.beginEditing(rowID: rowID, columnID: column.id)
+        }
+    }
+
+    // The grid's text editor refuses bytes, so a BLOB column would take the caret and open nothing.
+    private static func takesTypedText(_ column: DataGridColumn, in row: Row?) -> Bool {
+        column.type?.isBlobType != true && row?[column.dataIndex].asBytes == nil
     }
 
     private func uuidKeyForms(in tableRows: TableRows, tab: QueryTab) -> [Int: UUIDCellForm] {
@@ -170,9 +181,7 @@ final class RowEditingCoordinator: ObservableObject {
         )
     }
 
-    /// The key columns a new, duplicated or pasted row gets a fresh UUID in: a UUID key the server does not fill,
-    /// whose `__DEFAULT__` would leave the key out of the INSERT. Asked of `SetValueOptions`, so a foreign key, a
-    /// read-only column or a writer that cannot store UUID text gets none, exactly as Generate UUID is hidden.
+    // A UUID key the server does not fill; asked of SetValueOptions, so it is skipped wherever Generate UUID is hidden.
     static func uuidKeyForms(
         in tableRows: TableRows,
         primaryKeyColumns: [String],
@@ -214,36 +223,12 @@ final class RowEditingCoordinator: ObservableObject {
         return nil
     }
 
-    private func displayIndex(of rowID: RowID, tabId: UUID) -> Int? {
-        DisplayRowMapping.displayIndex(
-            forRowID: rowID,
-            displayIDs: parent.activeGridDisplayIDs,
-            in: parent.tabSessionRegistry.tableRows(for: tabId)
-        )
-    }
-
-    private func displayIndices(of rowIDs: Set<RowID>, tabId: UUID) -> Set<Int> {
-        guard let displayIDs = parent.activeGridDisplayIDs else {
-            let tableRows = parent.tabSessionRegistry.tableRows(for: tabId)
-            return Set(rowIDs.compactMap { tableRows.index(of: $0) })
-        }
-        return Set(displayIDs.indices.filter { rowIDs.contains(displayIDs[$0]) })
-    }
-
-    /// Ends the typed run an inspector field was building, so the next thing to register an undo
-    /// step lands after it rather than inside it.
+    // The next undo step then lands after the typed run, not inside it.
     func endInspectorEditRun() {
         parent.changeManager.endCoalescedUndoRun()
     }
 
-    /// Stages a row inspector field edit exactly as the grid's own cell editor stages one: the
-    /// change, the shared `TableRows` buffer both surfaces read, and the repaint.
-    ///
-    /// The rows are named by `RowID` rather than by the display positions the selection carries,
-    /// and each contributes its own `oldValue`. A shared one is wrong the moment a multi-row
-    /// selection disagrees on the field, where the inspector holds no value for it at all.
-    ///
-    /// `isExpression` stages `value`, SQL from `CellExpressionVocabulary`, to be written unquoted.
+    // By RowID, each row with its own oldValue: a shared one is wrong when a multi-row selection disagrees on the field.
     func stageInspectorFieldEdit(
         columnIndex: Int,
         value: PluginCellValue,
@@ -259,18 +244,12 @@ final class RowEditingCoordinator: ObservableObject {
         )
     }
 
-    /// A value of its own for each row, one undo step for all of them.
+    // One undo step for all rows.
     func stageInspectorFieldValues(columnIndex: Int, valuesByRow: [RowID: PluginCellValue]) {
         stageInspectorEdits(valuesByRow: valuesByRow, columnIndex: columnIndex, continuity: .discrete)
     }
 
-    /// Puts a field back to the values the inspector was configured with.
-    ///
-    /// A field the selected rows disagree on has no value of its own, and clearing it asks for each
-    /// row's own value back rather than for one value across all of them.
-    ///
-    /// `absentRowIDs` are the rows that had no field for the column, which it goes back to missing, and
-    /// `expressionRowIDs` the rows whose value was staged SQL, which goes back as SQL rather than as text.
+    // Disagreeing rows get their own values back; absentRowIDs go back to missing, expressionRowIDs back to SQL.
     func revertInspectorFieldEdit(
         columnIndex: Int,
         valuesByRow: [RowID: PluginCellValue],
@@ -286,8 +265,7 @@ final class RowEditingCoordinator: ObservableObject {
         )
     }
 
-    /// Takes the field out of every row the inspector is showing, for an engine that tells a
-    /// missing field from NULL.
+    // For an engine that tells a missing field from NULL.
     func stageInspectorFieldRemoval(columnIndex: Int, rowIDs: [RowID]) {
         guard parent.changeManager.supportsFieldRemoval else { return }
         stageInspectorEdits(
@@ -313,14 +291,11 @@ final class RowEditingCoordinator: ObservableObject {
         let tableRows = parent.tabSessionRegistry.tableRows(for: tabId)
         guard tableRows.columns.indices.contains(columnIndex) else { return }
         let columnName = tableRows.columns[columnIndex]
-        /// Before the rows are touched, not after: a column the server owns is refused when the
-        /// change is recorded, and editing here first would paint a value into the grid that no
-        /// statement will ever carry.
+        // Checked before touching rows: a server-owned column is refused later, so the grid would show a value nothing writes.
         guard parent.changeManager.isColumnWritable(columnName) else { return }
 
         var edits: [(row: Int, column: Int, value: PluginCellValue)] = []
         var removedCells: Set<CellPosition> = []
-        var editedRowIDs: Set<RowID> = []
         for (rowID, value) in valuesByRow {
             guard let storageRow = tableRows.index(of: rowID) else { continue }
             let row = tableRows.rows[storageRow]
@@ -362,35 +337,42 @@ final class RowEditingCoordinator: ObservableObject {
             if removesField {
                 removedCells.insert(CellPosition(row: storageRow, column: columnIndex))
             }
-            editedRowIDs.insert(rowID)
         }
         guard !edits.isEmpty else { return }
 
         parent.mutateActiveTableRows(for: tabId) { rows in rows.editMany(edits, absentCells: removedCells) }
         parent.tabManager.mutate(at: tabIndex) { $0.hasUserInteraction = true }
-        repaintInspectorEdit(rowIDs: editedRowIDs, columnIndex: columnIndex, in: tableRows)
         parent.inspectorRowContentChanged.send()
     }
 
-    /// `editMany` reports the rows it changed by their position in storage, and the grid reads a
-    /// delta's rows as display positions, so a sort or a value filter would repaint the wrong ones.
-    ///
-    /// Resolved in one pass over the display order rather than a search per row, because that order
-    /// is as long as the result.
-    private func repaintInspectorEdit(rowIDs: Set<RowID>, columnIndex: Int, in tableRows: TableRows) {
-        var positions: Set<CellPosition> = []
-        if let displayIDs = parent.activeGridDisplayIDs {
-            for (displayRow, rowID) in displayIDs.enumerated() where rowIDs.contains(rowID) {
-                positions.insert(CellPosition(row: displayRow, column: columnIndex))
-            }
-        } else {
-            for rowID in rowIDs {
-                guard let displayRow = tableRows.index(of: rowID) else { continue }
-                positions.insert(CellPosition(row: displayRow, column: columnIndex))
+    // One user command, one undo step named for it; the buffer write reaches the grid as one delta.
+    func commitGridEdits(_ resolved: [DataGridResolvedEdit], actionName: String, tabId: UUID) -> Bool {
+        let changeManager = parent.changeManager
+        let tableRows = parent.tabSessionRegistry.tableRows(for: tabId)
+        var edits: [(row: Int, column: Int, value: PluginCellValue)] = []
+        var removedCells: Set<CellPosition> = []
+        for edit in resolved {
+            guard let storageRow = tableRows.index(of: edit.rowID) else { continue }
+            changeManager.recordCellChange(
+                rowID: edit.rowID,
+                columnIndex: edit.dataIndex,
+                columnName: edit.columnName,
+                oldValue: edit.oldValue,
+                newValue: edit.newValue,
+                originalRow: edit.originalRow,
+                absence: edit.absence,
+                isExpression: edit.isExpression
+            )
+            edits.append((row: storageRow, column: edit.dataIndex, value: edit.newValue))
+            if edit.absence.isAbsent {
+                removedCells.insert(CellPosition(row: storageRow, column: edit.dataIndex))
             }
         }
-        guard !positions.isEmpty else { return }
-        parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(.cellsChanged(positions))
+        guard !edits.isEmpty else { return false }
+        changeManager.undoManagerProvider?()?.setActionName(actionName)
+        parent.mutateActiveTableRows(for: tabId) { rows in rows.editMany(edits, absentCells: removedCells) }
+        parent.tabManager.mutate(tabId: tabId) { $0.hasUserInteraction = true }
+        return true
     }
 
     func handleUndoResult(_ result: UndoResult) {
@@ -398,79 +380,65 @@ final class RowEditingCoordinator: ObservableObject {
 
         let tabId = tab.id
 
-        var application = RowOperationsManager.UndoApplicationResult(adjustedSelection: nil, delta: .none)
+        var application = RowOperationsManager.UndoApplicationResult(clearsSelection: false, delta: .none)
         parent.mutateActiveTableRows(for: tabId) { rows in
             let applied = parent.rowOperationsManager.applyUndoResult(result, tableRows: &rows)
             application = applied
             return applied.delta
         }
 
-        if let adjustedSelection = application.adjustedSelection {
-            parent.selectionState.indices = adjustedSelection
+        let model = parent.existingGridModel(forTab: tabId)
+        if application.clearsSelection {
+            model?.clearSelection()
         }
 
         parent.tabManager.mutate(at: tabIndex) { $0.hasUserInteraction = true }
-        parent.dataTabDelegate?.tableViewCoordinator?.invalidateCachesForUndoRedo()
-        parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(application.delta)
-        /// The row inspector reads its fields from the `TableRows` this just rewrote, and nothing
-        /// else in `InspectorTrigger` moves on an undo.
+        model?.repaintAllRows()
+        // The inspector reads its fields from the rows this rewrote, and nothing else it watches moves on an undo.
         parent.gridDisplayRevision &+= 1
     }
 
-    func copySelectedRowsToClipboard(indices: Set<Int>) {
-        guard let (tab, _) = parent.tabManager.selectedTabAndIndex, !indices.isEmpty else { return }
-        guard parent.unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copySelectedRowsToClipboard(indices: indices)
+    func copyRowsToClipboard(_ rowIDs: [RowID], includeHeaders: Bool = false) {
+        guard let (tab, _) = parent.tabManager.selectedTabAndIndex, !rowIDs.isEmpty else { return }
+        guard parent.unloadedValuesAreLoaded(rowIDs: rowIDs, retry: { [weak self] in
+            self?.copyRowsToClipboard(rowIDs, includeHeaders: includeHeaders)
         }) else { return }
-        let tableRows = parent.tabSessionRegistry.tableRows(for: tab.id)
-        parent.rowOperationsManager.copySelectedRowsToClipboard(
-            selectedIndices: indices,
-            tableRows: tableRows,
-            displayIDs: parent.activeGridDisplayIDs,
-            visibleColumnIndices: parent.dataTabDelegate?.tableViewCoordinator?.visibleColumnDataIndices()
-        )
-    }
-
-    func copySelectedRowsWithHeaders(indices: Set<Int>) {
-        guard let (tab, _) = parent.tabManager.selectedTabAndIndex, !indices.isEmpty else { return }
-        guard parent.unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copySelectedRowsWithHeaders(indices: indices)
-        }) else { return }
-        let tableRows = parent.tabSessionRegistry.tableRows(for: tab.id)
-        parent.rowOperationsManager.copySelectedRowsToClipboard(
-            selectedIndices: indices,
-            tableRows: tableRows,
-            displayIDs: parent.activeGridDisplayIDs,
-            includeHeaders: true,
-            visibleColumnIndices: parent.dataTabDelegate?.tableViewCoordinator?.visibleColumnDataIndices()
+        parent.rowOperationsManager.copyRowsToClipboard(
+            rowIDs,
+            tableRows: parent.tabSessionRegistry.tableRows(for: tab.id),
+            includeHeaders: includeHeaders,
+            visibleColumnIndices: presentedColumnIndices(tabId: tab.id)
         )
     }
 
-    func copySelectedRowsAsJson(indices: Set<Int>) {
-        guard let (tab, _) = parent.tabManager.selectedTabAndIndex, !indices.isEmpty else { return }
-        guard parent.unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copySelectedRowsAsJson(indices: indices)
+    func copyRowsAsJson(_ rowIDs: [RowID]) {
+        guard let (tab, _) = parent.tabManager.selectedTabAndIndex, !rowIDs.isEmpty else { return }
+        guard parent.unloadedValuesAreLoaded(rowIDs: rowIDs, retry: { [weak self] in
+            self?.copyRowsAsJson(rowIDs)
         }) else { return }
+        let model = parent.gridModel(forTab: tab.id)
         let output = ResultJsonSerializer.serialize(
             tableRows: parent.tabSessionRegistry.tableRows(for: tab.id),
-            displayIDs: parent.activeGridDisplayIDs,
-            selectedDisplayIndices: indices,
-            columns: VisibleColumnProjection(
-                indices: parent.dataTabDelegate?.tableViewCoordinator?.visibleColumnDataIndices()
-            )
+            displayIDs: model.displayedRowIDs,
+            selectedDisplayIndices: Set(rowIDs.compactMap { model.displayIndex(of: $0) }),
+            columns: VisibleColumnProjection(indices: presentedColumnIndices(tabId: tab.id))
         )
         guard output.rowCount > 0 else { return }
         ClipboardService.shared.writeText(output.json)
     }
 
+    // The columns the grid presents, in its order: hidden ones go, moved ones follow.
+    private func presentedColumnIndices(tabId: UUID) -> [Int] {
+        parent.gridModel(forTab: tabId).columns.columns.map(\.dataIndex)
+    }
+
     func pasteRows() {
         guard parent.canEditActiveResult,
               let (tab, tabIndex) = parent.tabManager.selectedTabAndIndex,
               tab.tabType == .table else { return }
 
         let tabId = tab.id
-        /// Pasted rows hand the columns the server owns back to it, which only the schema names, so pasting waits for
-        /// it the way Add Row does rather than staging an identity value the save would send.
+        // Pasted rows hand the server-owned columns back to it, which only the schema names, so this waits for it.
         let tableRows = parent.tabSessionRegistry.tableRows(for: tabId)
         guard tableRows.hasAuthoritativeSchema else { return }
         let columns = tableRows.columns
@@ -490,23 +458,9 @@ final class RowEditingCoordinator: ObservableObject {
 
         guard !pasteResult.pastedRows.isEmpty else { return }
 
-        let newIndices = displayIndices(of: Set(pasteResult.pastedRows.map(\.rowID)), tabId: tabId)
+        parent.tabManager.mutate(at: tabIndex) { $0.hasUserInteraction = true }
         if selectionPointsTheGrid {
-            parent.selectionState.indices = newIndices
+            parent.existingGridModel(forTab: tabId)?.selectRows(pasteResult.pastedRows.map(\.rowID))
         }
-
-        parent.tabManager.mutate(at: tabIndex) { tab in
-            tab.selectedRowIndices = newIndices
-            /// The pasted rows are the selection now. Left behind, the stored rectangle would
-            /// outrank them in `selectedDisplayRows` and come back instead of them.
-            tab.cellSelection = .empty
-            tab.hasUserInteraction = true
-        }
-        parent.dataTabDelegate?.tableViewCoordinator?.applyDelta(pasteResult.delta)
-    }
-
-    func updateCellInTab(rowIndex: Int, columnIndex: Int, value: PluginCellValue) {
-        guard let (_, tabIndex) = parent.tabManager.selectedTabAndIndex else { return }
-        parent.tabManager.mutate(at: tabIndex) { $0.hasUserInteraction = true }
     }
 }
diff --git a/apple/TablePro/Core/DataFiles/DataFileController+Editing.swift b/apple/TablePro/Core/DataFiles/DataFileController+Editing.swift
index d31806303a..6a0229f272 100644
--- a/apple/TablePro/Core/DataFiles/DataFileController+Editing.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileController+Editing.swift
@@ -45,8 +45,12 @@ extension DataFileController {
     }
 
     func setCell(pageRow: Int, column: Int, text: String?) {
-        guard isEditable, let table, let key = key(forPageRow: pageRow),
-              columnNames.ids.indices.contains(column) else { return }
+        guard let key = key(forPageRow: pageRow) else { return }
+        setCell(key: key, column: column, text: text)
+    }
+
+    func setCell(key: Int, column: Int, text: String?) {
+        guard isEditable, let table, columnNames.ids.indices.contains(column) else { return }
         let id = columnNames.ids[column]
         guard let tabularColumn = table.column(id) else { return }
         let original = table.cell(key: key, column: tabularColumn)
@@ -61,8 +65,7 @@ extension DataFileController {
         commit(updated, actionName: String(localized: "Edit Cell"))
     }
 
-    /// The cell edits made inside `work` are one undo step and one page refresh, rather than a whole page rebuilt
-    /// for every cell of a paste.
+    // One undo step and one page refresh for every cell edit made inside `work`.
     func batchCellEdits(actionName: String, _ work: () -> Void) {
         guard pendingCellEdits == nil else {
             work()
@@ -241,9 +244,10 @@ extension DataFileController {
         } else {
             kindOverrides[id] = nil
         }
-        gridCoordinator?.selectionSummaryTracker.rulesDidChange()
         if sortState.isSorting || !filterState.appliedFilters.isEmpty {
             runQuery()
+        } else {
+            gridModel.summaryRulesDidChange()
         }
     }
 }
diff --git a/apple/TablePro/Core/DataFiles/DataFileController+Find.swift b/apple/TablePro/Core/DataFiles/DataFileController+Find.swift
index 44982cec56..994ca66d45 100644
--- a/apple/TablePro/Core/DataFiles/DataFileController+Find.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileController+Find.swift
@@ -7,204 +7,111 @@ import Foundation
 import TableProTabular
 import TableProTabularIO
 
-struct DataFileFindMatch: Equatable, Hashable {
-    let key: Int
-    let column: TabularColumnID
-}
-
-struct DataFileFindState: Equatable {
-    var isVisible = false
-    var isReplaceVisible = false
-    var text = ""
-    var replacement = ""
-    var matchesCase = false
-    var matchesWholeWords = false
-    var isRegularExpression = false
-    var scopeColumn: TabularColumnID?
-    var matches: [DataFileFindMatch] = []
-    var currentIndex: Int?
-    var isSearching = false
-    var isPatternInvalid = false
-
-    var hasQuery: Bool { !text.isEmpty }
-}
-
+// The window's Find menu items land on the grid's model, which owns the bar. Its search and replace
+// cover the whole file through the methods below, not only the loaded page.
 extension DataFileController {
     func showFind(replacing: Bool) {
-        find.isVisible = true
-        if replacing, isEditable {
-            find.isReplaceVisible = true
-        }
-        if find.hasQuery {
-            runFind()
-        }
+        gridModel.showFind(replace: replacing)
     }
 
     func hideFind() {
-        find = DataFileFindState(
-            matchesCase: find.matchesCase,
-            matchesWholeWords: find.matchesWholeWords,
-            isRegularExpression: find.isRegularExpression
-        )
-        findTask?.cancel()
-        gridCoordinator?.applyFindMatch(nil)
+        gridModel.hideFind()
     }
 
-    func scopeFind(to column: TabularColumnID) {
-        find.scopeColumn = column
-        showFind(replacing: true)
+    func findNext() {
+        gridModel.findNext()
     }
 
-    func scheduleFind() {
-        findDebounceTask?.cancel()
-        findDebounceTask = Task { [weak self] in
-            try? await Task.sleep(for: Self.queryDebounce)
-            guard !Task.isCancelled else { return }
-            self?.runFind()
-        }
+    func findPrevious() {
+        gridModel.findPrevious()
     }
 
-    func findQuery() -> TabularFindQuery {
-        let hidden = columnLayout.hiddenColumns
-        let columns: [TabularColumnID]
-        if let scope = find.scopeColumn, columnNames.ids.contains(scope) {
-            columns = [scope]
-        } else {
-            columns = zip(columnNames.ids, columnNames.displayNames).filter { !hidden.contains($0.1) }.map(\.0)
-        }
-        return TabularFindQuery(
-            text: find.text,
-            matchesCase: find.matchesCase,
-            matchesWholeWords: find.matchesWholeWords,
-            isRegularExpression: find.isRegularExpression,
-            columns: columns
-        )
+    func useSelectionForFind() {
+        gridModel.useSelectionForFind()
     }
 
-    func runFind() {
-        findTask?.cancel()
-        guard let table, find.hasQuery else {
-            find.matches = []
-            find.currentIndex = nil
-            find.isPatternInvalid = false
-            gridCoordinator?.applyFindMatch(nil)
-            return
-        }
-        let query = findQuery()
-        guard TabularFindMatcher.validate(query) else {
-            find.isPatternInvalid = true
-            find.matches = []
-            find.currentIndex = nil
-            gridCoordinator?.applyFindMatch(nil)
-            return
-        }
-        find.isPatternInvalid = false
-        find.isSearching = true
-        let keys = visibleKeys()
-        let activityID = beginActivity(title: String(localized: "Finding…"), isMutation: false)
-        let reporter = progressReporter(for: activityID)
-        findTask = Task { [weak self] in
-            do {
-                let found = try await TabularFinder.findAll(query, keys: keys, in: table, progress: reporter)
-                let matches = found.map { DataFileFindMatch(key: $0.key, column: $0.column) }
-                self?.finishFind(matches, activityID: activityID)
-            } catch {
-                self?.endActivity(activityID)
-                if !error.isDataFileCancellation {
-                    self?.find.isSearching = false
-                }
-            }
+    // The grid finds only in the columns it shows, so a hidden column is shown first.
+    func scopeFind(to column: TabularColumnID) {
+        guard let id = findColumns.first(where: { $0.tabular == column })?.grid else { return }
+        if let name = columnNames.name(for: column), columnLayout.hiddenColumns.contains(name) {
+            columnLayout.hiddenColumns.remove(name)
         }
+        gridModel.findInColumn(id, replace: true)
     }
 
-    private func finishFind(_ matches: [DataFileFindMatch], activityID: UUID) {
-        endActivity(activityID)
-        find.isSearching = false
-        find.matches = matches
-        find.currentIndex = matches.isEmpty ? nil : 0
-        showCurrentMatch()
-    }
+    // MARK: - Whole file
 
-    func findNext() {
-        guard !find.matches.isEmpty else {
-            runFind()
-            return
-        }
-        find.currentIndex = ((find.currentIndex ?? -1) + 1) % find.matches.count
-        showCurrentMatch()
-    }
-
-    func findPrevious() {
-        guard !find.matches.isEmpty else {
-            runFind()
-            return
+    func findMatches(_ query: GridDatasetFindQuery) async throws -> [GridFindState.Match] {
+        guard let table, let tabularQuery = tabularFindQuery(for: query) else { return [] }
+        let gridIDs = Dictionary(findColumns.map { ($0.tabular, $0.grid) }, uniquingKeysWith: { first, _ in first })
+        let keys = visibleKeys()
+        // A running mutation keeps the activity, so its progress and busy state stay on screen.
+        let activityID = activity?.isMutation == true
+            ? nil
+            : beginActivity(title: String(localized: "Finding…"), isMutation: false)
+        defer {
+            if let activityID {
+                endActivity(activityID)
+            }
         }
-        let count = find.matches.count
-        find.currentIndex = ((find.currentIndex ?? 0) - 1 + count) % count
-        showCurrentMatch()
-    }
-
-    func showCurrentMatch() {
-        guard let index = find.currentIndex, find.matches.indices.contains(index) else {
-            gridCoordinator?.applyFindMatch(nil)
-            return
+        let progress: @Sendable (Double) -> Void
+        if let activityID {
+            progress = progressReporter(for: activityID)
+        } else {
+            progress = { _ in }
         }
-        let match = find.matches[index]
-        reveal(key: match.key, selecting: false)
-        guard let pageRow = pageKeys.firstIndex(of: match.key), let column = columnNames.index(of: match.column) else {
-            return
+        let found = try await TabularFinder.findAll(tabularQuery, keys: keys, in: table, progress: progress)
+        return found.compactMap { match in
+            gridIDs[match.column].map { GridFindState.Match(rowID: .existing(match.key), columnID: $0) }
         }
-        gridCoordinator?.applyFindMatch(FindMatch(displayRow: pageRow, columnIndex: column))
-    }
-
-    func useSelectionForFind() {
-        guard let table, let cell = activeCell(), let column = table.column(cell.column) else { return }
-        find.text = table.cell(key: cell.key, column: column).text
-        showFind(replacing: false)
-        runFind()
     }
 
-    func replaceCurrent() {
-        guard isEditable, let index = find.currentIndex, find.matches.indices.contains(index),
-              let table, let matcher = try? TabularFindMatcher(findQuery()) else { return }
-        let match = find.matches[index]
-        guard let column = table.column(match.column) else { return }
-        let original = table.cell(key: match.key, column: column)
-        let replaced = matcher.replacing(in: original.text, with: find.replacement)
-        guard replaced.replacements > 0 else {
-            findNext()
-            return
-        }
+    func replaceMatch(_ match: GridFindState.Match, query: GridDatasetFindQuery, with template: String) -> Bool {
+        guard isEditable, !hasMutationInFlight,
+              case .existing(let key) = match.rowID,
+              let table,
+              let id = findColumns.first(where: { $0.grid == match.columnID })?.tabular,
+              let column = table.column(id),
+              let tabularQuery = tabularFindQuery(for: query),
+              let matcher = try? TabularFindMatcher(tabularQuery) else { return false }
+        let original = table.cell(key: key, column: column)
+        guard !original.kind.isNullLike else { return false }
+        let replaced = matcher.replacing(in: original.text, with: template)
+        guard replaced.replacements > 0, replaced.text != original.text else { return false }
         var updated = table
-        updated.setCells([(key: match.key, columnID: match.column, cell: editedCell(replaced.text, replacing: original, column: match.column))])
+        updated.setCells([(key: key, columnID: id, cell: editedCell(replaced.text, replacing: original, column: id))])
         commit(updated, actionName: String(localized: "Replace"))
-        find.matches.remove(at: index)
-        find.currentIndex = find.matches.isEmpty ? nil : min(index, find.matches.count - 1)
-        showCurrentMatch()
+        return true
     }
 
-    func replaceAll() {
-        guard isEditable, find.hasQuery else { return }
-        let query = findQuery()
-        let template = find.replacement
+    func replaceAll(_ query: GridDatasetFindQuery, with template: String) {
+        guard let tabularQuery = tabularFindQuery(for: query) else { return }
         let keys = visibleKeys()
         runMutation(title: String(localized: "Replacing…"), actionName: String(localized: "Replace All")) { table, progress in
-            let result = try await TabularFinder.replaceAll(query, with: template, keys: keys, in: table, progress: progress)
+            let result = try await TabularFinder.replaceAll(tabularQuery, with: template, keys: keys, in: table, progress: progress)
+            let message = GridFindEngine.replacementMessage(replacements: result.replacements, cells: result.changedCells)
             guard result.changedCells > 0 else {
-                return DataFileMutationOutcome(table: nil, message: String(localized: "No matches to replace."))
+                return DataFileMutationOutcome(table: nil, message: message)
             }
-            return DataFileMutationOutcome(
-                table: Self.applying(result.values, to: table),
-                message: Self.replacementMessage(replacements: result.replacements, cells: result.changedCells)
-            )
+            return DataFileMutationOutcome(table: Self.applying(result.values, to: table), message: message)
         }
     }
 
-    nonisolated static func replacementMessage(replacements: Int, cells: Int) -> String {
-        String(
-            format: String(localized: "Replaced %1$@ in %2$@."),
-            DataFileCountPhrase.matches(replacements),
-            DataFileCountPhrase.cells(cells)
+    // The grid names a column by its display name, the table by its id.
+    private var findColumns: [(grid: DataGridColumnID, tabular: TabularColumnID)] {
+        zip(DataGridColumnSet.columnIDs(for: columnNames.displayNames), columnNames.ids).map { (grid: $0, tabular: $1) }
+    }
+
+    private func tabularFindQuery(for query: GridDatasetFindQuery) -> TabularFindQuery? {
+        let tabularIDs = Dictionary(findColumns.map { ($0.grid, $0.tabular) }, uniquingKeysWith: { first, _ in first })
+        let columns = query.columns.compactMap { tabularIDs[$0] }
+        guard !columns.isEmpty else { return nil }
+        return TabularFindQuery(
+            text: query.term,
+            matchesCase: query.options.matchesCase,
+            matchesWholeWords: query.options.matchesWholeWord,
+            isRegularExpression: query.options.usesRegularExpression,
+            columns: columns
         )
     }
 }
diff --git a/apple/TablePro/Core/DataFiles/DataFileController+Mutations.swift b/apple/TablePro/Core/DataFiles/DataFileController+Mutations.swift
index 25f2298f97..7c5b4ef6a0 100644
--- a/apple/TablePro/Core/DataFiles/DataFileController+Mutations.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileController+Mutations.swift
@@ -69,9 +69,6 @@ extension DataFileController {
         if let message = outcome.message {
             showMessage(message)
         }
-        if find.isVisible, find.hasQuery {
-            runFind()
-        }
     }
 
     private func abandonMutation(error: Error, activityID: UUID) {
diff --git a/apple/TablePro/Core/DataFiles/DataFileController+Query.swift b/apple/TablePro/Core/DataFiles/DataFileController+Query.swift
index f1edcfa1a4..3218ddafc6 100644
--- a/apple/TablePro/Core/DataFiles/DataFileController+Query.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileController+Query.swift
@@ -63,7 +63,7 @@ extension DataFileController {
         filterState.executedFilters = filterState.appliedFilters
         let predicate = currentPredicate()
         let sortKeys = currentSortKeys()
-        selectedRowIndices = []
+        gridModel.clearSelection()
         pageOffset = 0
         guard !predicate.isTrivial || !sortKeys.isEmpty else {
             setQueryTask(nil)
diff --git a/apple/TablePro/Core/DataFiles/DataFileController+Selection.swift b/apple/TablePro/Core/DataFiles/DataFileController+Selection.swift
index ec0897ad61..487d9a9f25 100644
--- a/apple/TablePro/Core/DataFiles/DataFileController+Selection.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileController+Selection.swift
@@ -3,17 +3,15 @@
 //  TablePro
 //
 
-import Foundation
+import AppKit
 import TableProTabular
 
-/// One column and the rows a command changes in it.
 struct DataFileColumnCells: Equatable, Sendable {
     let column: TabularColumnID
     let keys: [Int]
 }
 
-/// Each column keeps its own rows, so a selection of separate cells changes those cells and not the rows and columns
-/// between them.
+// Each column keeps its own rows, so a selection of separate cells changes those cells and not the ones between them.
 struct DataFileCellTarget: Equatable {
     let cells: [DataFileColumnCells]
     let coversWholeColumns: Bool
@@ -25,28 +23,32 @@ struct DataFileCellTarget: Equatable {
 
 extension DataFileController {
     var gridSelection: GridSelection {
-        gridCoordinator?.selectionController.selection ?? .empty
+        gridModel.selection
+    }
+
+    func columnID(atDisplayPosition position: Int) -> TabularColumnID? {
+        guard let dataIndex = gridModel.columns.dataIndex(atDisplayPosition: position),
+              columnNames.ids.indices.contains(dataIndex) else { return nil }
+        return columnNames.ids[dataIndex]
     }
 
     func selectedColumnIDs() -> [TabularColumnID] {
-        guard let coordinator = gridCoordinator else { return [] }
-        return coordinator.dataColumnIndices(in: gridSelection.columns).compactMap { index in
-            columnNames.ids.indices.contains(index) ? columnNames.ids[index] : nil
-        }
+        gridSelection.columns.compactMap { columnID(atDisplayPosition: $0) }
+    }
+
+    // Nil for a hidden column or an unmounted grid.
+    func headerAnchor(for id: TabularColumnID) -> (view: NSView, rect: NSRect)? {
+        guard let dataIndex = columnNames.index(of: id),
+              let position = gridModel.columns.displayPosition(ofDataIndex: dataIndex),
+              let column = gridModel.columns.column(at: position) else { return nil }
+        return gridModel.anchor(for: column)
     }
 
     func activeCell() -> (key: Int, column: TabularColumnID)? {
-        guard let coordinator = gridCoordinator else { return nil }
-        if let active = gridSelection.activeCell {
-            guard let key = key(forPageRow: active.row),
-                  let column = coordinator.dataColumnIndex(atDisplayPosition: active.displayColumn),
-                  columnNames.ids.indices.contains(column) else { return nil }
-            return (key, columnNames.ids[column])
-        }
-        guard let focused = (coordinator.tableView as? KeyHandlingTableView)?.pasteAnchorCell(),
-              let key = key(forPageRow: focused.row),
-              columnNames.ids.indices.contains(focused.column) else { return nil }
-        return (key, columnNames.ids[focused.column])
+        guard let active = gridModel.activeCell,
+              case .existing(let key) = active.rowID,
+              columnNames.ids.indices.contains(active.column.dataIndex) else { return nil }
+        return (key, columnNames.ids[active.column.dataIndex])
     }
 
     func cellTarget(explicitColumn: TabularColumnID? = nil) -> DataFileCellTarget? {
@@ -57,45 +59,33 @@ extension DataFileController {
         if !columns.isEmpty {
             return .wholeColumns(columns, keys: visibleKeys())
         }
-        guard let coordinator = gridCoordinator else { return nil }
-        guard !gridSelection.isEmpty else { return focusedCellTarget() }
-        var pairs: [(column: Int, pageRow: Int)] = []
-        for row in gridSelection.affectedRows {
-            for column in coordinator.dataColumnIndices(in: gridSelection.columns(in: row)) {
-                pairs.append((column: column, pageRow: row))
+        let selection = gridSelection
+        // A click or picked rows span every column; the commands act on the cursor's column of each row.
+        guard !selection.isEmpty, !selection.isRows else { return focusedCellTarget() }
+        var cells: [(column: TabularColumnID, key: Int)] = []
+        for row in selection.affectedRows {
+            guard let key = key(forPageRow: row) else { continue }
+            for position in selection.columns(in: row) {
+                guard let column = columnID(atDisplayPosition: position) else { continue }
+                cells.append((column: column, key: key))
             }
         }
-        return cellTarget(pairs: pairs)
+        return cellTarget(cells: cells)
     }
 
-    /// The cells the grid resolved, read the way `cellTarget()` reads a selection: whole selected columns cover every
-    /// visible row, and anything else covers those cells only.
-    func cellTarget(for targets: [SetValueTarget]) -> DataFileCellTarget? {
-        guard let target = cellTarget(pairs: targets.map { (column: $0.columnIndex, pageRow: $0.displayRow) }) else {
-            return nil
-        }
-        let wholeColumns = selectedColumnIDs()
-        let columns = target.cells.map(\.column)
-        guard !wholeColumns.isEmpty, Set(columns).isSubset(of: Set(wholeColumns)) else { return target }
-        return .wholeColumns(columns, keys: visibleKeys())
-    }
-
-    private func cellTarget(pairs: [(column: Int, pageRow: Int)]) -> DataFileCellTarget? {
-        var order: [Int] = []
-        var keysByColumn: [Int: [Int]] = [:]
-        var seen: [Int: Set<Int>] = [:]
-        for pair in pairs where columnNames.ids.indices.contains(pair.column) {
-            guard let key = key(forPageRow: pair.pageRow), seen[pair.column, default: []].insert(key).inserted else {
-                continue
-            }
-            if keysByColumn[pair.column] == nil {
-                order.append(pair.column)
+    func cellTarget(cells: [(column: TabularColumnID, key: Int)]) -> DataFileCellTarget? {
+        var order: [TabularColumnID] = []
+        var keysByColumn: [TabularColumnID: [Int]] = [:]
+        var seen: [TabularColumnID: Set<Int>] = [:]
+        for cell in cells where seen[cell.column, default: []].insert(cell.key).inserted {
+            if keysByColumn[cell.column] == nil {
+                order.append(cell.column)
             }
-            keysByColumn[pair.column, default: []].append(key)
+            keysByColumn[cell.column, default: []].append(cell.key)
         }
         guard !order.isEmpty else { return nil }
-        let cells = order.map { DataFileColumnCells(column: columnNames.ids[$0], keys: keysByColumn[$0] ?? []) }
-        return DataFileCellTarget(cells: cells, coversWholeColumns: false)
+        let targets = order.map { DataFileColumnCells(column: $0, keys: keysByColumn[$0] ?? []) }
+        return DataFileCellTarget(cells: targets, coversWholeColumns: false)
     }
 
     private func focusedCellTarget() -> DataFileCellTarget? {
diff --git a/apple/TablePro/Core/DataFiles/DataFileController+Undo.swift b/apple/TablePro/Core/DataFiles/DataFileController+Undo.swift
index 01a637146b..e517cce37e 100644
--- a/apple/TablePro/Core/DataFiles/DataFileController+Undo.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileController+Undo.swift
@@ -88,8 +88,5 @@ extension DataFileController {
         } else {
             runQuery()
         }
-        if find.isVisible, find.hasQuery {
-            scheduleFind()
-        }
     }
 }
diff --git a/apple/TablePro/Core/DataFiles/DataFileController.swift b/apple/TablePro/Core/DataFiles/DataFileController.swift
index fd23f77560..b21c574439 100644
--- a/apple/TablePro/Core/DataFiles/DataFileController.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileController.swift
@@ -47,7 +47,12 @@ final class DataFileController: ObservableObject {
 
     @Published var filterState = TabFilterState()
     @Published var searchText = ""
-    @Published var sortState = SortState()
+    @Published var sortState = SortState() {
+        didSet {
+            guard gridModel.store.sortState != sortState else { return }
+            gridModel.store.sortState = sortState
+        }
+    }
     var sortReferences: [DataFileSortReference] = []
     @Published private(set) var displayKeys: [Int]?
     @Published private(set) var isQueryRunning = false
@@ -56,21 +61,21 @@ final class DataFileController: ObservableObject {
     @Published var pageSize: Int
     @Published private(set) var tableRows = TableRows()
     @Published private(set) var pageRevision = 0
-    @Published var selectedRowIndices: Set<Int> = []
-    @Published var columnLayout = ColumnLayoutState()
+    // The page rows the grid's selection covers, published for the status bar and the row details.
+    @Published private(set) var selectedRowIndices: Set<Int> = []
     @Published var isInspectorVisible = false
 
-    @Published var find = DataFileFindState()
     @Published private(set) var activity: DataFileActivity?
     @Published var statusMessage: String?
 
     let changeManager: DataFileChangeManager
     let anyChangeManager: AnyChangeManager
-    let selectionSummary = SelectionSummaryState()
+    let selectionSummary: SelectionSummaryState
+    let gridModel: DataGridModel
+    let gridAdapter: DataFileGridAdapter
     weak var undoManager: UndoManager?
-    weak var gridCoordinator: TableViewCoordinator?
     var onEdited: (() -> Void)?
-    /// Set while `batchCellEdits` runs, so the cell edits made inside it land as one commit.
+    // Set while `batchCellEdits` runs, so the cell edits made inside it land as one commit.
     var pendingCellEdits: [(key: Int, columnID: TabularColumnID, cell: TabularCell)]?
 
     private(set) var kind: DataFileKind?
@@ -81,8 +86,6 @@ final class DataFileController: ObservableObject {
     private var queryTask: Task<Void, Never>?
     private var mutationTask: Task<Void, Never>?
     private var queryDebounceTask: Task<Void, Never>?
-    var findTask: Task<Void, Never>?
-    var findDebounceTask: Task<Void, Never>?
     var transferTask: Task<Void, Never>?
     private var activityRevealTask: Task<Void, Never>?
     private var messageTask: Task<Void, Never>?
@@ -93,6 +96,39 @@ final class DataFileController: ObservableObject {
         pageSize = max(1, AppSettingsManager.shared.dataGrid.defaultPageSize)
         changeManager = DataFileChangeManager()
         anyChangeManager = AnyChangeManager(changeManager)
+        let summary = SelectionSummaryState()
+        selectionSummary = summary
+        gridModel = DataGridModel(selectionSummary: summary)
+        gridAdapter = DataFileGridAdapter(model: gridModel)
+        gridAdapter.controller = self
+        gridModel.$selectionRevision
+            .sink { [weak self] _ in self?.gridSelectionDidChange() }
+            .store(in: &cancellables)
+    }
+
+    // The grid's column layout is the one home of hidden columns, widths and order.
+    var columnLayout: ColumnLayoutState {
+        get { gridModel.store.columnLayout }
+        set {
+            guard newValue != gridModel.store.columnLayout else { return }
+            objectWillChange.send()
+            gridModel.updateColumnLayout { $0 = newValue }
+        }
+    }
+
+    private func gridSelectionDidChange() {
+        let rows = Set(gridModel.selection.affectedRows.filter { $0 < pageKeys.count })
+        guard rows != selectedRowIndices else { return }
+        selectedRowIndices = rows
+    }
+
+    func selectRows(pageRows: Set<Int>) {
+        let rowIDs = pageRows.sorted().compactMap { key(forPageRow: $0) }.map { RowID.existing($0) }
+        if rowIDs.isEmpty {
+            gridModel.clearSelection()
+        } else {
+            gridModel.selectRows(rowIDs)
+        }
     }
 
     var isEditable: Bool {
@@ -141,9 +177,8 @@ final class DataFileController: ObservableObject {
         await queryDebounceTask?.value
         await queryTask?.value
         await mutationTask?.value
-        await findDebounceTask?.value
-        await findTask?.value
         await transferTask?.value
+        await gridModel.findSearchSettled()
     }
 
     private func performLoad(_ request: DataFileLoadRequest) async {
@@ -198,7 +233,6 @@ final class DataFileController: ObservableObject {
     private func loadSheet(at index: Int) {
         guard let workbook = content?.workbook, let workbookSheet = sheets[index].workbookSheet else { return }
         queryTask?.cancel()
-        findTask?.cancel()
         loadTask?.cancel()
         table = nil
         loadState = .loading
@@ -235,10 +269,11 @@ final class DataFileController: ObservableObject {
         sortReferences = []
         displayKeys = nil
         pageOffset = 0
-        selectedRowIndices = []
+        gridModel.clearSelection()
         refreshColumnNames()
         refreshPage()
         loadState = .loaded
+        gridModel.findDatasetDidChange()
     }
 
     func refreshColumnNames() {
@@ -291,10 +326,12 @@ final class DataFileController: ObservableObject {
     }
 
     func refreshPage() {
+        let previousColumns = tableRows.columns
         guard let table else {
             tableRows = TableRows()
             pageKeys = []
             changeManager.bumpReload()
+            gridModel.reloadHeldRows(columnsChanged: !previousColumns.isEmpty)
             return
         }
         let visible = visibleRowCount
@@ -338,14 +375,14 @@ final class DataFileController: ObservableObject {
             columnNullable: Dictionary(uniqueKeysWithValues: names.map { ($0, holdsNull) })
         )
         changeManager.bumpReload()
-        gridCoordinator?.applyDelta(.fullReplace)
+        gridModel.reloadHeldRows(columnsChanged: previousColumns != names || gridModel.columns.isEmpty)
     }
 
     func goToPage(offsetBy delta: Int) {
         let target = pageOffset + delta * pageSize
         guard target >= 0, target < max(visibleRowCount, 1) else { return }
         pageOffset = target
-        selectedRowIndices = []
+        gridModel.clearSelection()
         refreshPage()
     }
 
@@ -359,15 +396,8 @@ final class DataFileController: ObservableObject {
         }
         let row = position - pageOffset
         guard selecting, row >= 0, row < pageKeys.count else { return }
-        selectedRowIndices = [row]
-        DispatchQueue.main.async { [weak self] in
-            guard let coordinator = self?.gridCoordinator, let tableView = coordinator.tableView,
-                  row < tableView.numberOfRows else { return }
-            coordinator.isApplyingProgrammaticRowSelection = true
-            tableView.selectRowIndexes(IndexSet(integer: row), byExtendingSelection: false)
-            coordinator.isApplyingProgrammaticRowSelection = false
-            tableView.scrollRowToVisible(row)
-        }
+        gridModel.selectRows([.existing(key)])
+        gridModel.reveal(rowID: .existing(key))
     }
 
     func showMessage(_ message: String) {
@@ -414,8 +444,8 @@ final class DataFileController: ObservableObject {
     func cancelActivity() {
         queryTask?.cancel()
         mutationTask?.cancel()
-        findTask?.cancel()
         transferTask?.cancel()
+        gridModel.stopFindSearch()
     }
 
     func tearDown() {
@@ -423,11 +453,10 @@ final class DataFileController: ObservableObject {
         queryTask?.cancel()
         mutationTask?.cancel()
         queryDebounceTask?.cancel()
-        findTask?.cancel()
-        findDebounceTask?.cancel()
         transferTask?.cancel()
         activityRevealTask?.cancel()
         messageTask?.cancel()
+        gridModel.stopFindSearch()
         workingCopy = nil
     }
 
@@ -468,14 +497,17 @@ final class DataFileController: ObservableObject {
 
     func setDisplayKeys(_ keys: [Int]?) {
         displayKeys = keys
+        gridModel.findDatasetDidChange()
     }
 
+    // Every edit, mutation and undo lands here, so find searches the file again.
     func replaceTable(_ newTable: TabularTable) {
         table = newTable
         if sheets.indices.contains(selectedSheetIndex) {
             sheets[selectedSheetIndex].table = newTable
         }
         refreshColumnNames()
+        gridModel.findDatasetDidChange()
     }
 
     func setInferredKind(_ kind: TabularInferredKind, for id: TabularColumnID) {
diff --git a/apple/TablePro/Core/DataFiles/DataFileCountPhrase.swift b/apple/TablePro/Core/DataFiles/DataFileCountPhrase.swift
index 8ebebf27d6..bc6b4a708e 100644
--- a/apple/TablePro/Core/DataFiles/DataFileCountPhrase.swift
+++ b/apple/TablePro/Core/DataFiles/DataFileCountPhrase.swift
@@ -20,10 +20,6 @@ enum DataFileCountPhrase {
         count == 1 ? String(localized: "1 cell") : String(format: String(localized: "%@ cells"), count.formatted())
     }
 
-    static func matches(_ count: Int) -> String {
-        count == 1 ? String(localized: "1 match") : String(format: String(localized: "%@ matches"), count.formatted())
-    }
-
     static func duplicateRows(_ count: Int) -> String {
         count == 1
             ? String(localized: "1 duplicate row")
diff --git a/apple/TablePro/Core/DataGrid/DataGridDisplayState.swift b/apple/TablePro/Core/DataGrid/DataGridDisplayState.swift
index b4f23d2920..53e13177b9 100644
--- a/apple/TablePro/Core/DataGrid/DataGridDisplayState.swift
+++ b/apple/TablePro/Core/DataGrid/DataGridDisplayState.swift
@@ -2,53 +2,12 @@
 //  DataGridDisplayState.swift
 //  TablePro
 //
-//  The formatted-cell cache and viewport anchor a tab keeps while its grid is unmounted.
-//
 
-import AppKit
 import Foundation
 
-/// What a display cache was built from.
-///
-/// A cache that outlives its grid has to carry the inputs that decided its text, because nothing
-/// invalidates it while no grid is mounted to notice them change.
-struct DataGridDisplayIdentity: Equatable {
-    let bufferEpoch: Int
-    let resultSetId: UUID?
-    let columns: [String]
-    let columnTypes: [ColumnType]
-    let displayFormats: [ValueDisplayFormat?]
-    let dateFormat: DateFormatOption
-    let nullDisplay: String
-    let smartValueDetection: Bool
-    /// A Unix-timestamp column renders an instant in the reader's own zone, so text derived before
-    /// the Mac's zone moved is wrong. Nothing else in this identity moves with it.
-    let systemTimeZoneGeneration: Int
-}
-
-/// Whether the rows under a mounted grid were replaced, as opposed to the grid being rebuilt over
-/// the same rows. A remount is not a content change and must not discard formatted text.
-struct DataGridContentIdentity: Equatable {
-    let reloadVersion: Int
-    let contentRevision: Int
-}
-
-/// The per-result state a mounted grid derives, kept by an owner that outlives the view.
-///
-/// SwiftUI destroys `TableViewCoordinator` whenever the grid leaves the view tree, and the editor
-/// mounts the grid as `.id(tab.id)`, so every tab switch threw away a whole result's formatted text
-/// and rebuilt it: `CellDisplayFormatter` over every loaded row of every column, on the main actor,
-/// growing with the rows the tab held. The owner keeps this the same way it already keeps the value
-/// filter and the resolved display order. (#2424)
+// Formatted text kept by the model, so a remount of the grid draws from it instead of formatting every row again (#2424).
 @MainActor
 final class DataGridDisplayState {
     let cache = RowDisplayCache()
-    var contentIdentity: DataGridContentIdentity?
-    var firstVisibleRow: Int = 0
-    /// The two derived values a coordinator compares against to decide the cache is stale. A fresh
-    /// coordinator starts both empty, so without carrying them the first update of every remount
-    /// reports a schema and a format change and clears the text it was just handed.
-    var identitySchema: ColumnIdentitySchema?
-    var displayFormats: [ValueDisplayFormat?]?
     var highlightRuleSetKey: HighlightRuleSet.Key?
 }
diff --git a/apple/TablePro/Core/DataGrid/DataGridModel+Find.swift b/apple/TablePro/Core/DataGrid/DataGridModel+Find.swift
new file mode 100644
index 0000000000..8ff206ca42
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/DataGridModel+Find.swift
@@ -0,0 +1,433 @@
+import Foundation
+import TableProPluginKit
+
+// An owner holding more rows than the grid loaded (a data file's other pages) answers find for all of them.
+// A match's rowID is the one its row carries once loaded; the owner calls findDatasetDidChange() when its rows change.
+@MainActor
+protocol DataGridDatasetFinding: AnyObject {
+    // Every match in display order, row then column; progress and cancel go through the owner's activity UI.
+    func gridFindAll(_ query: GridDatasetFindQuery) async throws -> [GridFindState.Match]
+    func gridDisplayPosition(of rowID: RowID) -> Int?
+    // Loads the row's page without selecting anything; false when the row is gone.
+    func gridLoadRow(_ rowID: RowID) -> Bool
+    // One undoable step; false when the cell no longer holds the term.
+    func gridReplace(_ match: GridFindState.Match, query: GridDatasetFindQuery, with template: String) -> Bool
+    // One undoable step over every match, with the owner's progress, cancel and outcome message.
+    func gridReplaceAll(_ query: GridDatasetFindQuery, with template: String)
+}
+
+struct GridDatasetFindQuery: Equatable {
+    // A literal term arrives trimmed, as the loaded-rows search trims it.
+    let term: String
+    let options: GridFindState.Options
+    // In display order.
+    let columns: [DataGridColumnID]
+}
+
+extension DataGridModel {
+    var datasetFinder: (any DataGridDatasetFinding)? {
+        get { find.datasetFinder }
+        set { find.datasetFinder = newValue }
+    }
+
+    var canReplaceInFind: Bool {
+        configuration.isEditable && actions != nil
+    }
+
+    // A dataset finder already searches every row.
+    var findCoversPageOnly: Bool {
+        datasetFinder == nil && dataSource?.gridHasUnloadedRows == true
+    }
+
+    var offersSearchAllRows: Bool {
+        datasetFinder == nil && configuration.commands.contains(.searchAllRows) && actions != nil
+    }
+
+    var hasFindTerm: Bool {
+        if find.options.usesRegularExpression { return !find.term.isEmpty }
+        return !find.term.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    var canReplaceCurrentFindMatch: Bool {
+        guard canReplaceInFind,
+              let match = find.currentMatch,
+              let column = columns.column(id: match.columnID) else { return false }
+        return isColumnWritable(column)
+    }
+
+    // MARK: - Showing
+
+    func showFind(replace: Bool = false) {
+        if replace, canReplaceInFind {
+            find.showsReplace = true
+        }
+        let wasVisible = find.isVisible
+        find.isVisible = true
+        if !wasVisible {
+            refreshFind()
+        }
+    }
+
+    func findInColumn(_ columnID: DataGridColumnID, replace: Bool = false) {
+        find.options.columnScope = columnID
+        if replace, canReplaceInFind {
+            find.showsReplace = true
+        }
+        find.isVisible = true
+        findQueryDidChange()
+    }
+
+    func hideFind() {
+        guard find.isVisible else { return }
+        find.reset()
+        find.options.columnScope = nil
+        find.showsReplace = false
+        find.isVisible = false
+        focus()
+    }
+
+    // MARK: - Searching
+
+    // The term or an option changed: search again and select the first match from the cursor.
+    func findQueryDidChange() {
+        guard find.isVisible else { return }
+        if datasetFinder != nil {
+            searchDataset(revealsFirstMatch: true)
+            return
+        }
+        let source = findSource
+        let result = GridFindEngine.search(find.term, options: find.options, in: source)
+        let current = GridFindEngine.index(
+            atOrAfter: selection.activeCell,
+            in: GridFindEngine.positions(of: result.matches, in: source)
+        )
+        find.setResults(result.matches, current: current, problem: result.problem)
+        revealCurrentFindMatch()
+    }
+
+    // The rows changed under the bar: keep the current match when it survives and leave the selection alone.
+    func refreshFind() {
+        guard find.isVisible else { return }
+        if datasetFinder != nil {
+            // Another page changes the grid's rows, not the owner's; only another column set searches again.
+            guard datasetFindQuery != find.datasetQuery else { return }
+            searchDataset(revealsFirstMatch: false)
+            return
+        }
+        let source = findSource
+        let previous = find.currentMatch
+        let result = GridFindEngine.search(find.term, options: find.options, in: source)
+        let current: Int?
+        if let previous, let kept = result.matches.firstIndex(of: previous) {
+            current = kept
+        } else {
+            current = GridFindEngine.index(
+                atOrAfter: selection.activeCell,
+                in: GridFindEngine.positions(of: result.matches, in: source)
+            )
+        }
+        find.setResults(result.matches, current: current, problem: result.problem)
+    }
+
+    // The owner's rows changed (an edit, an undo, a filter): search them again, keeping the current match.
+    func findDatasetDidChange() {
+        guard find.isVisible, datasetFinder != nil, find.datasetQuery != nil else { return }
+        // One change can arrive in several calls; the search starts once the owner has finished it.
+        find.deferDatasetSearch(Task { [weak self] in
+            guard let self, !Task.isCancelled else { return }
+            guard self.datasetFinder != nil, self.find.isVisible else {
+                self.find.cancelDatasetSearch()
+                return
+            }
+            self.searchDataset(revealsFirstMatch: false)
+        })
+    }
+
+    func stopFindSearch() {
+        find.stopDatasetSearch()
+    }
+
+    // Returns once no whole-dataset search is waiting or running.
+    func findSearchSettled() async {
+        while let task = find.datasetSearch {
+            await task.value
+            if find.datasetSearch == task { return }
+        }
+    }
+
+    func findNext() {
+        stepFind(forward: true)
+    }
+
+    func findPrevious() {
+        stepFind(forward: false)
+    }
+
+    func useSelectionForFind() {
+        let source = findSource
+        guard let active = activeCell, let row = source.rows.row(withID: active.rowID) else { return }
+        // A dataset finder matches the stored value, which the cell shows capped to one line.
+        let shown = datasetFinder == nil
+            ? GridFindEngine.searchableText(in: row, column: active.column, source: source)
+            : storedText(in: row, column: active.column)
+        guard let text = shown else { return }
+        find.term = find.options.usesRegularExpression ? NSRegularExpression.escapedPattern(for: text) : text
+        find.isVisible = true
+        findQueryDidChange()
+    }
+
+    // The server matches the plain term in any column, ignoring case; any other option would change what it finds.
+    var searchAllRowsKeepsTheOptions: Bool {
+        find.options == GridFindState.Options()
+    }
+
+    func searchAllRows() {
+        guard offersSearchAllRows, searchAllRowsKeepsTheOptions, let actions else { return }
+        let term = find.term.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !term.isEmpty else { return }
+        hideFind()
+        actions.gridSearchAllRows(term: term)
+    }
+
+    // MARK: - Replacing
+
+    func replaceCurrentMatch() {
+        guard canReplaceInFind, find.problem == nil, let match = find.currentMatch, commitEditing() else { return }
+        if let finder = datasetFinder {
+            replaceDatasetMatch(match, finder: finder)
+            return
+        }
+        let source = findSource
+        let replacement = GridFindEngine.replacements(
+            for: [match],
+            term: find.term,
+            options: find.options,
+            template: find.replacement,
+            in: source,
+            isWritable: { isColumnWritable($0) }
+        )
+        guard !replacement.edits.isEmpty else {
+            findNext()
+            return
+        }
+        let replaced = GridFindEngine.position(of: match, in: source)
+        guard commit(replacement.edits, actionName: String(localized: "Replace")) else { return }
+        refreshFind()
+        guard !find.matches.isEmpty else { return }
+        let positions = GridFindEngine.positions(of: find.matches, in: findSource)
+        find.setCurrentIndex(replaced.flatMap { GridFindEngine.index(after: $0, in: positions) } ?? 0)
+        revealCurrentFindMatch()
+    }
+
+    // Nil when nothing was committed here: a dataset finder commits and reports the outcome itself.
+    // An empty replacement when every match sits where Replace cannot write.
+    @discardableResult
+    func replaceAllMatches() -> GridFindEngine.Replacement? {
+        guard canReplaceInFind, commitEditing() else { return nil }
+        if let finder = datasetFinder {
+            replaceAllDatasetMatches(finder: finder)
+            return nil
+        }
+        let source = findSource
+        let result = GridFindEngine.search(find.term, options: find.options, in: source)
+        guard result.problem == nil else { return nil }
+        let replacement = GridFindEngine.replacements(
+            for: result.matches,
+            term: find.term,
+            options: find.options,
+            template: find.replacement,
+            in: source,
+            isWritable: { isColumnWritable($0) }
+        )
+        guard !replacement.edits.isEmpty else { return replacement }
+        guard commit(replacement.edits, actionName: String(localized: "Replace All")) else { return nil }
+        refreshFind()
+        return replacement
+    }
+
+    // MARK: - Private
+
+    private var findSource: GridFindEngine.Source {
+        GridFindEngine.Source(
+            rows: rows,
+            order: order,
+            columns: columns,
+            displayFormats: store.displayFormats,
+            databaseType: configuration.traits.databaseType,
+            revealsInvisibleCharacters: AppSettingsManager.shared.dataGrid.showInvisibleCharacters
+        )
+    }
+
+    private func stepFind(forward: Bool) {
+        guard find.isVisible else { return }
+        if let finder = datasetFinder {
+            stepDatasetFind(finder, forward: forward)
+            return
+        }
+        if find.matches.isEmpty {
+            refreshFind()
+        }
+        guard !find.matches.isEmpty else { return }
+        let index = GridFindEngine.step(
+            from: find.currentIndex,
+            active: selection.activeCell,
+            positions: GridFindEngine.positions(of: find.matches, in: findSource),
+            forward: forward
+        )
+        find.setCurrentIndex(index)
+        revealCurrentFindMatch()
+    }
+
+    // The match becomes the active cell, so Copy, Return and the arrow keys act on the found column.
+    private func revealCurrentFindMatch() {
+        guard let match = find.currentMatch else { return }
+        if displayIndex(of: match.rowID) == nil {
+            guard let finder = datasetFinder, finder.gridLoadRow(match.rowID) else { return }
+        }
+        guard let row = displayIndex(of: match.rowID),
+              let column = columns.displayPosition(of: match.columnID) else { return }
+        selectCell(GridCoord(row: row, displayColumn: column))
+        reveal(rowID: match.rowID, columnID: match.columnID)
+    }
+
+    private func storedText(in row: Row, column: DataGridColumn) -> String? {
+        guard column.dataIndex < row.values.count,
+              case .text(let text) = row.values[column.dataIndex],
+              !text.isEmpty else { return nil }
+        return text
+    }
+
+    // MARK: - Dataset
+
+    private var datasetFindQuery: GridDatasetFindQuery? {
+        guard hasFindTerm else { return nil }
+        let term = find.options.usesRegularExpression
+            ? find.term
+            : find.term.trimmingCharacters(in: .whitespacesAndNewlines)
+        return GridDatasetFindQuery(
+            term: term,
+            options: find.options,
+            columns: GridFindEngine.searchedColumns(options: find.options, in: findSource).map(\.id)
+        )
+    }
+
+    private func searchDataset(revealsFirstMatch: Bool) {
+        let query = datasetFindQuery
+        let generation = find.beginDatasetSearch(query, clearsResults: revealsFirstMatch || query == nil)
+        guard let query, !query.columns.isEmpty else {
+            find.setResults([], current: nil, problem: nil)
+            return
+        }
+        if let problem = GridFindEngine.problem(term: query.term, options: query.options) {
+            find.setResults([], current: nil, problem: problem)
+            return
+        }
+        find.attachDatasetSearch(Task { [weak self] in
+            guard !Task.isCancelled, let finder = self?.datasetFinder else {
+                self?.find.abandonDatasetSearch(generation: generation)
+                return
+            }
+            do {
+                let found = try await finder.gridFindAll(query)
+                self?.finishDatasetSearch(found, generation: generation, revealsFirstMatch: revealsFirstMatch)
+            } catch {
+                self?.find.abandonDatasetSearch(generation: generation)
+            }
+        }, generation: generation)
+    }
+
+    private func finishDatasetSearch(_ found: [GridFindState.Match], generation: Int, revealsFirstMatch: Bool) {
+        guard find.isCurrentDatasetSearch(generation) else { return }
+        var current: Int?
+        if let finder = datasetFinder, !found.isEmpty {
+            let position = { (index: Int) in self.datasetPosition(of: found[index], finder: finder) }
+            if let previous = find.currentMatch,
+               let cell = datasetPosition(of: previous, finder: finder),
+               let index = GridFindEngine.sortedIndex(atOrAfter: cell, count: found.count, position: position),
+               found[index] == previous {
+                current = index
+            } else if let cursor = datasetCursor(finder) {
+                current = GridFindEngine.sortedIndex(atOrAfter: cursor, count: found.count, position: position)
+            } else {
+                current = 0
+            }
+        }
+        find.finishDatasetSearch(found, current: current, generation: generation)
+        if revealsFirstMatch {
+            revealCurrentFindMatch()
+        }
+    }
+
+    private func stepDatasetFind(_ finder: any DataGridDatasetFinding, forward: Bool) {
+        let matches = find.matches
+        guard !matches.isEmpty else {
+            // A search that finished empty stays empty until the owner reports a change.
+            if !find.isSearching, find.searchStopped || datasetFindQuery != find.datasetQuery {
+                searchDataset(revealsFirstMatch: true)
+            }
+            return
+        }
+        let count = matches.count
+        let position = { (index: Int) in self.datasetPosition(of: matches[index], finder: finder) }
+        let next: Int?
+        if let active = selection.activeCell, currentFindMatchCell != active, let cursor = datasetCursor(finder) {
+            next = forward
+                ? GridFindEngine.sortedIndex(after: cursor, count: count, position: position)
+                : GridFindEngine.sortedIndex(before: cursor, count: count, position: position)
+        } else if let current = find.currentIndex {
+            next = forward ? (current + 1) % count : (current - 1 + count) % count
+        } else {
+            next = forward ? 0 : count - 1
+        }
+        find.setCurrentIndex(next)
+        revealCurrentFindMatch()
+    }
+
+    private func replaceDatasetMatch(_ match: GridFindState.Match, finder: any DataGridDatasetFinding) {
+        guard let index = find.currentIndex,
+              let query = datasetFindQuery,
+              let column = columns.column(id: match.columnID),
+              isColumnWritable(column) else { return }
+        guard finder.gridReplace(match, query: query, with: find.replacement) else {
+            findNext()
+            return
+        }
+        // The owner's change searches again in the background; until then the list drops the replaced cell.
+        find.removeMatch(at: index)
+        revealCurrentFindMatch()
+    }
+
+    private func replaceAllDatasetMatches(finder: any DataGridDatasetFinding) {
+        guard let query = datasetFindQuery,
+              GridFindEngine.problem(term: query.term, options: query.options) == nil else { return }
+        let writable = query.columns.filter { id in
+            columns.column(id: id).map { isColumnWritable($0) } ?? false
+        }
+        guard !writable.isEmpty else { return }
+        finder.gridReplaceAll(
+            GridDatasetFindQuery(term: query.term, options: query.options, columns: writable),
+            with: find.replacement
+        )
+    }
+
+    private var currentFindMatchCell: GridCoord? {
+        guard let match = find.currentMatch,
+              let row = displayIndex(of: match.rowID),
+              let column = columns.displayPosition(of: match.columnID) else { return nil }
+        return GridCoord(row: row, displayColumn: column)
+    }
+
+    private func datasetPosition(of match: GridFindState.Match, finder: any DataGridDatasetFinding) -> GridCoord? {
+        guard let row = finder.gridDisplayPosition(of: match.rowID),
+              let column = columns.displayPosition(of: match.columnID) else { return nil }
+        return GridCoord(row: row, displayColumn: column)
+    }
+
+    // The active cell in the owner's display order.
+    private func datasetCursor(_ finder: any DataGridDatasetFinding) -> GridCoord? {
+        guard let active = selection.activeCell,
+              let rowID = rowID(at: active.row),
+              let row = finder.gridDisplayPosition(of: rowID) else { return nil }
+        return GridCoord(row: row, displayColumn: active.displayColumn)
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/DataGridModel.swift b/apple/TablePro/Core/DataGrid/DataGridModel.swift
new file mode 100644
index 0000000000..9e9cd17f68
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/DataGridModel.swift
@@ -0,0 +1,500 @@
+import AppKit
+import Combine
+import TableProPluginKit
+import TableProTheme
+
+@MainActor
+protocol DataGridMountedView: AnyObject {
+    func apply(_ change: DataGridChange)
+    func selectionDidChange()
+    func configurationDidChange()
+    func reveal(row: Int, displayColumn: Int?)
+    func revealColumn(_ displayColumn: Int)
+    func sortDidChange()
+    func summaryRulesDidChange()
+    func viewportSample() -> (row: Int, offset: CGFloat)?
+    @discardableResult func beginEditing(row: Int, displayColumn: Int) -> Bool
+    var isEditing: Bool { get }
+    func commitEditing() -> Bool
+    func discardEditing()
+    @discardableResult func focus() -> Bool
+    // Where a popover about a column (statistics, value filter) points.
+    func anchor(forColumn displayColumn: Int) -> (view: NSView, rect: NSRect)?
+}
+
+@MainActor
+final class DataGridModel: ObservableObject {
+    let id = UUID()
+    weak var dataSource: (any DataGridDataSource)?
+    weak var actions: (any DataGridActions)?
+    let store: any DataGridStateStore
+    let display = DataGridDisplayState()
+    let find = GridFindState()
+    let selectionSummary: SelectionSummaryState?
+
+    var configuration: DataGridConfiguration {
+        didSet {
+            guard configuration != oldValue else { return }
+            mountedView?.configurationDidChange()
+            editabilityRevision &+= 1
+        }
+    }
+
+    var themeScope: ThemeScope {
+        didSet { mountedView?.configurationDidChange() }
+    }
+
+    private(set) var columns: DataGridColumnSet = .empty
+    private(set) var order: DataGridRowOrder = .unfiltered
+    private(set) var selection: GridSelection = .empty
+
+    @Published private(set) var displayRevision = 0
+    @Published private(set) var selectionRevision = 0
+    @Published private(set) var editabilityRevision = 0
+
+    private(set) weak var mountedView: (any DataGridMountedView)?
+    private var orderRevision = 0
+
+    init(
+        store: any DataGridStateStore = InMemoryDataGridStateStore(),
+        configuration: DataGridConfiguration = DataGridConfiguration(),
+        themeScope: ThemeScope = .live,
+        selectionSummary: SelectionSummaryState? = nil
+    ) {
+        self.store = store
+        self.configuration = configuration
+        self.themeScope = themeScope
+        self.selectionSummary = selectionSummary
+    }
+
+    // MARK: - Rows
+
+    var rows: TableRows { dataSource?.gridRows ?? TableRows() }
+    var changeState: AnyChangeManager? { dataSource?.gridChangeState }
+    var rowCount: Int { order.count(in: rows) }
+
+    func rowID(at displayIndex: Int) -> RowID? {
+        order.rowID(at: displayIndex, in: rows)
+    }
+
+    func row(at displayIndex: Int) -> Row? {
+        order.row(at: displayIndex, in: rows)
+    }
+
+    func displayIndex(of rowID: RowID) -> Int? {
+        order.displayIndex(of: rowID, in: rows)
+    }
+
+    func reloadRows() {
+        let current = rows
+        store.valueFilter = store.valueFilter.remapped(toColumns: current.columns)
+        let rebuilt = DataGridColumnSet(tableRows: current, layout: store.columnLayout)
+        if rebuilt != columns {
+            columns = rebuilt
+            mountedView?.apply(.columnsChanged)
+        }
+        order = resolveOrder(in: current)
+        display.cache.removeAll()
+        restoreSelection(in: current)
+        displayRevision &+= 1
+        mountedView?.apply(.reload)
+        refreshFind()
+    }
+
+    func apply(_ delta: Delta) {
+        if delta == .fullReplace {
+            reloadRows()
+            return
+        }
+        let current = rows
+        if delta.changesRowSet || delta == .columnsReplaced {
+            if delta == .columnsReplaced {
+                columns = DataGridColumnSet(tableRows: current, layout: store.columnLayout)
+            }
+            let previous = order
+            order = resolveOrder(in: current)
+            let change = DataGridChange.from(delta, order: previous, rows: current, columns: columns)
+            if change == .reload || change == .columnsChanged {
+                display.cache.removeAll()
+            }
+            restoreSelection(in: current)
+            displayRevision &+= 1
+            mountedView?.apply(change)
+            refreshFind()
+            return
+        }
+        let change = DataGridChange.from(delta, order: order, rows: current, columns: columns)
+        guard !change.isNone else { return }
+        if case .rowsUpdated(let displayRows, _) = change {
+            for displayRow in displayRows {
+                if let id = order.rowID(at: displayRow, in: current) {
+                    display.cache.clearValues(forID: id)
+                }
+            }
+        }
+        // An edited row stays where the filter put it until the filter or the row set changes (#2667).
+        mountedView?.apply(change)
+        refreshFind()
+    }
+
+    private func resolveOrder(in rows: TableRows) -> DataGridRowOrder {
+        let ids = GridDisplayOrderResolver.resolve(
+            tableRows: rows,
+            valueFilter: store.valueFilter,
+            displayFormats: store.displayFormats,
+            databaseType: configuration.traits.databaseType
+        )
+        orderRevision &+= 1
+        return DataGridRowOrder(filteredIDs: ids, revision: orderRevision)
+    }
+
+    // MARK: - Selection
+
+    var selectedRowIDs: [RowID] {
+        order.rowIDs(atDisplayIndexes: selection.affectedRows, in: rows)
+    }
+
+    var activeCell: (rowID: RowID, column: DataGridColumn)? {
+        guard let active = selection.activeCell,
+              let rowID = order.rowID(at: active.row, in: rows),
+              let column = columns.column(at: active.displayColumn) else { return nil }
+        return (rowID, column)
+    }
+
+    func setSelection(_ newSelection: GridSelection) {
+        let clamped = newSelection.clamped(rowLimit: rowCount, columnLimit: columns.count)
+        guard clamped != selection else { return }
+        selection = clamped
+        store.selectionSnapshot = GridSelectionSnapshot(clamped, order: order, rows: rows, columns: columns)
+        selectionRevision &+= 1
+        mountedView?.selectionDidChange()
+    }
+
+    // Selects the cell's row and puts the cursor on the cell, which is what a click does.
+    func selectCell(_ cell: GridCoord) {
+        setSelection(GridSelectionReducer.cursor(cell, in: GridSelectionContext(rowCount: rowCount, columnCount: columns.count)))
+    }
+
+    func selectRows(_ rowIDs: [RowID]) {
+        let current = rows
+        var rects: [GridRect] = []
+        let lastColumn = max(columns.count - 1, 0)
+        for range in order.displayIndexes(of: rowIDs, in: current).rangeView {
+            rects.append(GridRect(rows: range.lowerBound...(range.upperBound - 1), columns: 0...lastColumn))
+        }
+        let active = rects.first.map { GridCoord(row: $0.rows.lowerBound, displayColumn: selection.activeCell?.displayColumn ?? 0) }
+        setSelection(GridSelection(rectangles: rects, activeCell: active, anchor: active, mode: rects.isEmpty ? .cells : .rows))
+    }
+
+    func clearSelection() {
+        setSelection(.empty)
+    }
+
+    // The change that follows tells the view: a selection moved ahead of it would end an open edit.
+    private func restoreSelection(in rows: TableRows) {
+        let resolved = store.selectionSnapshot
+            .resolved(order: order, rows: rows, columns: columns)
+            .clamped(rowLimit: order.count(in: rows), columnLimit: columns.count)
+        guard resolved != selection else { return }
+        selection = resolved
+        selectionRevision &+= 1
+    }
+
+    // MARK: - View state
+
+    func setSort(_ sort: SortState) {
+        guard sort != store.sortState else { return }
+        store.sortState = sort
+        actions?.gridSortDidChange(sort)
+        mountedView?.sortDidChange()
+    }
+
+    // An owner changed or declined a sort outside the header; the header re-reads it.
+    func sortStateDidChange() {
+        mountedView?.sortDidChange()
+    }
+
+    func setValueFilter(_ filter: GridValueFilterState) {
+        guard filter != store.valueFilter else { return }
+        guard let actions else {
+            applyValueFilter(filter)
+            return
+        }
+        actions.gridConfirmDisplayOrderChange { [weak self] in
+            self?.applyValueFilter(filter)
+        }
+    }
+
+    private func applyValueFilter(_ filter: GridValueFilterState) {
+        store.valueFilter = filter
+        let current = rows
+        order = resolveOrder(in: current)
+        restoreSelection(in: current)
+        displayRevision &+= 1
+        mountedView?.apply(.reload)
+        refreshFind()
+    }
+
+    func updateColumnLayout(_ mutate: (inout ColumnLayoutState) -> Void) {
+        var layout = store.columnLayout
+        mutate(&layout)
+        guard layout != store.columnLayout else { return }
+        store.columnLayout = layout
+        let current = rows
+        let rebuilt = DataGridColumnSet(tableRows: current, layout: layout)
+        if rebuilt != columns {
+            let snapshot = store.selectionSnapshot
+            columns = rebuilt
+            selection = snapshot.resolved(order: order, rows: current, columns: rebuilt)
+                .clamped(rowLimit: rowCount, columnLimit: rebuilt.count)
+            selectionRevision &+= 1
+            mountedView?.apply(.columnsChanged)
+            mountedView?.selectionDidChange()
+            refreshFind()
+        } else {
+            mountedView?.apply(.columnsChanged)
+        }
+    }
+
+    func setDisplayFormat(_ format: ValueDisplayFormat?, for column: DataGridColumn) {
+        let current = rows
+        let previous = displayFormat(for: column)
+        guard previous != format else { return }
+        let formats = DisplayFormatArray.setting(
+            format, at: column.dataIndex, in: store.displayFormats, columnCount: current.columns.count
+        )
+        // A filter stores the shown text, so the values the user picked follow the new format.
+        if let remapped = remappedValueFilter(column: column, from: previous, to: format, in: current) {
+            store.valueFilter = remapped
+        }
+        store.displayFormats = formats
+        display.cache.removeAll()
+        if store.valueFilter.isActive {
+            order = resolveOrder(in: current)
+            restoreSelection(in: current)
+            displayRevision &+= 1
+            mountedView?.apply(.reload)
+        } else {
+            mountedView?.apply(.rowsUpdated(IndexSet(0..<rowCount), columns: columns.displayPosition(of: column.id).map { IndexSet(integer: $0) }))
+        }
+        refreshFind()
+    }
+
+    private func remappedValueFilter(
+        column: DataGridColumn,
+        from oldFormat: ValueDisplayFormat?,
+        to newFormat: ValueDisplayFormat?,
+        in rows: TableRows
+    ) -> GridValueFilterState? {
+        let dataIndex = column.dataIndex
+        guard let existing = store.valueFilter.filter(forColumn: dataIndex) else { return nil }
+        let databaseType = configuration.traits.databaseType
+        var removed = Set<String>()
+        var added = Set<String>()
+        for row in rows.rows where dataIndex < row.values.count {
+            let raw = row.values[dataIndex]
+            guard raw != .null else { continue }
+            let old = GridDisplayOrderResolver.displayValue(
+                raw, columnType: column.type, displayFormat: oldFormat, databaseType: databaseType
+            )
+            guard existing.selectedValues.contains(old) else { continue }
+            let new = GridDisplayOrderResolver.displayValue(
+                raw, columnType: column.type, displayFormat: newFormat, databaseType: databaseType
+            )
+            if old != new {
+                removed.insert(old)
+                added.insert(new)
+            }
+        }
+        var selected = existing.selectedValues
+        selected.subtract(removed)
+        selected.formUnion(added)
+        guard selected != existing.selectedValues else { return nil }
+        var filter = store.valueFilter
+        filter.set(
+            ColumnValueFilter(selectedValues: selected, includesNull: existing.includesNull),
+            columnName: column.name,
+            forColumn: dataIndex
+        )
+        return filter
+    }
+
+    func displayFormat(for column: DataGridColumn) -> ValueDisplayFormat? {
+        let formats = store.displayFormats
+        return column.dataIndex < formats.count ? formats[column.dataIndex] : nil
+    }
+
+    // MARK: - Editing
+
+    func isColumnWritable(_ column: DataGridColumn) -> Bool {
+        guard configuration.isEditable else { return false }
+        let name = column.name
+        if configuration.lockedColumns.contains(name) { return false }
+        if configuration.traits.immutableColumns.contains(name) { return false }
+        if changeState?.generatedColumns.contains(name) == true { return false }
+        return true
+    }
+
+    var isEditing: Bool { mountedView?.isEditing ?? false }
+
+    // Owners that deferred work while an editor was open resume here.
+    var onEditingEnded: (@MainActor () -> Void)?
+
+    func editingDidEnd() {
+        onEditingEnded?()
+    }
+
+    @discardableResult
+    func beginEditing(rowID: RowID, columnID: DataGridColumnID) -> Bool {
+        guard let row = displayIndex(of: rowID), let column = columns.displayPosition(of: columnID) else { return false }
+        return mountedView?.beginEditing(row: row, displayColumn: column) ?? false
+    }
+
+    // Owners call this before anything that repoints or replaces what an edit was made against.
+    @discardableResult
+    func commitEditing() -> Bool {
+        mountedView?.commitEditing() ?? true
+    }
+
+    func discardEditing() {
+        mountedView?.discardEditing()
+    }
+
+    @discardableResult
+    func commit(_ edits: [DataGridCellEdit], actionName: String) -> Bool {
+        guard let actions else { return false }
+        let current = rows
+        let resolved = edits.compactMap { resolve($0, in: current) }
+        guard !resolved.isEmpty else { return false }
+        return actions.gridCommit(resolved, actionName: actionName)
+    }
+
+    private func resolve(_ edit: DataGridCellEdit, in rows: TableRows) -> DataGridResolvedEdit? {
+        guard let column = columns.column(id: edit.columnID) ?? columnOutsidePresentation(edit.columnID, in: rows),
+              isColumnWritable(column),
+              let storageIndex = rows.index(of: edit.rowID) else { return nil }
+        let row = rows.rows[storageIndex]
+        let dataIndex = column.dataIndex
+        guard dataIndex < row.values.count, changeState?.isRowDeleted(edit.rowID) != true else { return nil }
+        guard row.unloadedByteCount(dataIndex) == nil else { return nil }
+
+        let newValue: PluginCellValue
+        let isExpression: Bool
+        var removesField = false
+        switch edit.value {
+        case .enteredText(let text):
+            if let text,
+               let databaseType = configuration.traits.databaseType,
+               let typed = CellEntry.typed(
+                   text,
+                   columnType: rows.editingColumnType(at: dataIndex),
+                   databaseType: databaseType,
+                   writer: configuration.traits.cellWriterSupport
+               ) {
+                newValue = typed.value
+                isExpression = typed.isExpression
+            } else if let entered = rows.enteredValue(text, forColumn: dataIndex) {
+                newValue = entered
+                isExpression = false
+            } else {
+                return nil
+            }
+        case .value(let value, let expression):
+            newValue = value
+            isExpression = expression
+        case .removeField:
+            guard configuration.traits.supportsFieldRemoval else { return nil }
+            newValue = .null
+            isExpression = false
+            removesField = true
+        }
+
+        let oldValue = row.values[dataIndex]
+        let absence = FieldAbsence(
+            wasAbsent: row.isAbsent(dataIndex),
+            isAbsent: removesField,
+            originalRow: row.absentColumns
+        )
+        let wasExpression = changeState?.isExpression(rowID: row.id, columnIndex: dataIndex) ?? false
+        guard oldValue != newValue || absence.wasAbsent != absence.isAbsent || wasExpression != isExpression else {
+            return nil
+        }
+        return DataGridResolvedEdit(
+            rowID: row.id,
+            dataIndex: dataIndex,
+            columnName: column.name,
+            oldValue: oldValue,
+            newValue: newValue,
+            originalRow: Array(row.values),
+            absence: absence,
+            isExpression: isExpression
+        )
+    }
+
+    // An owner-built edit can target a column the user hid.
+    private func columnOutsidePresentation(_ id: DataGridColumnID, in rows: TableRows) -> DataGridColumn? {
+        let ids = DataGridColumnSet.columnIDs(for: rows.columns)
+        guard let dataIndex = ids.firstIndex(of: id) else { return nil }
+        return DataGridColumn(
+            id: id,
+            dataIndex: dataIndex,
+            type: dataIndex < rows.columnTypes.count ? rows.columnTypes[dataIndex] : nil,
+            comment: rows.columnComments[id.name]
+        )
+    }
+
+    // MARK: - Mounting
+
+    func attach(_ view: any DataGridMountedView) {
+        mountedView = view
+    }
+
+    func detach(_ view: any DataGridMountedView) {
+        guard mountedView === view else { return }
+        mountedView = nil
+    }
+
+    var isMounted: Bool { mountedView != nil }
+
+    func revealColumn(_ id: DataGridColumnID) {
+        guard let position = columns.displayPosition(of: id) else { return }
+        mountedView?.revealColumn(position)
+    }
+
+    func viewportSample() -> (row: Int, offset: CGFloat)? {
+        mountedView?.viewportSample()
+    }
+
+    // A pending-change mark or a tint changed with no value under it.
+    func repaintRows(_ rowIDs: some Sequence<RowID>) {
+        guard let mountedView else { return }
+        let indexes = order.displayIndexes(of: rowIDs, in: rows)
+        guard !indexes.isEmpty else { return }
+        mountedView.apply(.rowsUpdated(indexes, columns: nil))
+    }
+
+    // A column's summary rule moved with no value under it, so only the selection summary is computed again.
+    func summaryRulesDidChange() {
+        mountedView?.summaryRulesDidChange()
+    }
+
+    func repaintAllRows() {
+        guard let mountedView, rowCount > 0 else { return }
+        mountedView.apply(.rowsUpdated(IndexSet(integersIn: 0..<rowCount), columns: nil))
+    }
+
+    func anchor(for column: DataGridColumn) -> (view: NSView, rect: NSRect)? {
+        guard let position = columns.displayPosition(of: column.id) else { return nil }
+        return mountedView?.anchor(forColumn: position)
+    }
+
+    func reveal(rowID: RowID, columnID: DataGridColumnID? = nil) {
+        guard let row = displayIndex(of: rowID) else { return }
+        mountedView?.reveal(row: row, displayColumn: columnID.flatMap { columns.displayPosition(of: $0) })
+    }
+
+    @discardableResult
+    func focus() -> Bool {
+        mountedView?.focus() ?? false
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/DataGridOwnerProtocols.swift b/apple/TablePro/Core/DataGrid/DataGridOwnerProtocols.swift
new file mode 100644
index 0000000000..7844ea8b62
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/DataGridOwnerProtocols.swift
@@ -0,0 +1,178 @@
+import AppKit
+import TableProPluginKit
+
+enum DataGridCommand: Hashable, CaseIterable {
+    case addRow
+    case duplicateRows
+    case deleteRows
+    case undoDelete
+    case pasteRows
+    case moveRows
+    case filterWithColumn
+    case hideColumns
+    case showRowsAsJSON
+    case exportResults
+    case clearResults
+    case searchAllRows
+    case navigateForeignKey
+    case highlightValues
+    case displayAs
+    case freezeColumns
+    case valueFilter
+    case copyAsSQL
+    case loadUnloadedValues
+}
+
+enum DataGridLayoutScope: Equatable {
+    case table(ColumnLayoutTableKey)
+    case ephemeral
+}
+
+struct DataGridEngineTraits: Equatable {
+    var databaseType: DatabaseType?
+    var immutableColumns: Set<String> = []
+    var usesTrueFalseBooleans = false
+    var stringLiteralPrefix: String = ""
+    var cellWriterSupport: CellWriterSupport = .none
+    var supportsFieldRemoval = false
+    // The database the rows came from, for the editors that read it (FK picker and preview, escaping).
+    var connectionScope: DatabaseScope?
+    // The Structure and Create Table type pickers list the connection's own types.
+    var looksUpUserDefinedTypes = false
+
+    static let none = DataGridEngineTraits()
+}
+
+@MainActor
+protocol DataGridDataSource: AnyObject {
+    var gridRows: TableRows { get }
+    var gridChangeState: AnyChangeManager { get }
+    var gridRowNumberOffset: Int { get }
+    var gridHighlightRules: [HighlightRule] { get }
+    // The rows are one page of more, so Find counts what this page holds.
+    var gridHasUnloadedRows: Bool { get }
+
+    func gridVisualState(for rowID: RowID) -> RowVisualState?
+    func gridTextTone(for rowID: RowID, column: DataGridColumn) -> NSColor?
+    func gridAccessibilityText(for rowID: RowID, column: DataGridColumn) -> String?
+    func gridCheckboxState(for rowID: RowID, column: DataGridColumn) -> Bool?
+    func gridMenuOptions(for rowID: RowID, column: DataGridColumn) -> [GridMenuOption]?
+    func gridSummaryColumnPolicy() -> SelectionSummaryColumnPolicy?
+}
+
+extension DataGridDataSource {
+    var gridRowNumberOffset: Int { 0 }
+    var gridHighlightRules: [HighlightRule] { [] }
+    var gridHasUnloadedRows: Bool { false }
+    func gridVisualState(for rowID: RowID) -> RowVisualState? { nil }
+    func gridTextTone(for rowID: RowID, column: DataGridColumn) -> NSColor? { nil }
+    func gridAccessibilityText(for rowID: RowID, column: DataGridColumn) -> String? { nil }
+    func gridCheckboxState(for rowID: RowID, column: DataGridColumn) -> Bool? { nil }
+    func gridMenuOptions(for rowID: RowID, column: DataGridColumn) -> [GridMenuOption]? { nil }
+    func gridSummaryColumnPolicy() -> SelectionSummaryColumnPolicy? { nil }
+}
+
+@MainActor
+protocol DataGridActions: AnyObject {
+    // The owner records one undoable step, updates its rows and reports back through model.apply(_:).
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool
+    func gridDeleteRows(_ rowIDs: [RowID])
+    // True when the owner wrote the pasteboard itself (a format only it knows); false lets the grid copy.
+    func gridCopyRows(_ rowIDs: [RowID]) -> Bool
+    // True when the owner ran its own Set Cells to Value over these cells (beyond the loaded page).
+    func gridSetCellsToValue(_ cells: [(rowID: RowID, column: DataGridColumn)]) -> Bool
+    func gridUndoDelete(_ rowIDs: [RowID])
+    func gridAddRow()
+    func gridDuplicateRows(_ rowIDs: [RowID])
+    func gridCanPasteRows() -> Bool
+    func gridPasteRows()
+    func gridMoveRow(from source: RowID, toDisplayIndex destination: Int)
+    func gridSortDidChange(_ sort: SortState)
+    func gridConfirmDisplayOrderChange(then apply: @escaping @MainActor () -> Void)
+    func gridFilterWithColumn(_ column: DataGridColumn)
+    func gridHideColumn(_ column: DataGridColumn)
+    func gridShowAllColumns()
+    func gridNavigateForeignKey(value: String, info: ForeignKeyInfo, intent: ReferenceOpenIntent)
+    func gridShowRowsAsJSON(_ rowIDs: [RowID])
+    func gridExportResults()
+    func gridClearResults()
+    func gridSearchAllRows(term: String)
+    func gridSetCheckbox(_ isOn: Bool, rowIDs: [RowID], column: DataGridColumn)
+    func gridLoadUnloadedValues(rowIDs: [RowID], columns: IndexSet?, completion: @escaping @MainActor (Bool) -> Void)
+    var gridSQLExporter: (any DataGridSQLExporting)? { get }
+
+    func gridColumnMenuItems(for column: DataGridColumn) -> [NSMenuItem]
+    // `rowIDs` are the rows the menu acts on; `clickedRow` is the one right-clicked, inside them or alone.
+    func gridRowMenuItems(for rowIDs: [RowID], clickedRow: RowID) -> [NSMenuItem]
+    func gridCellMenuItems(for rowID: RowID, column: DataGridColumn) -> [NSMenuItem]
+    func gridEmptySpaceMenu() -> NSMenu?
+    func gridHighlightValuesMenuItem(for column: DataGridColumn) -> NSMenuItem?
+}
+
+extension DataGridActions {
+    func gridDeleteRows(_ rowIDs: [RowID]) {}
+    func gridCopyRows(_ rowIDs: [RowID]) -> Bool { false }
+    func gridSetCellsToValue(_ cells: [(rowID: RowID, column: DataGridColumn)]) -> Bool { false }
+    func gridUndoDelete(_ rowIDs: [RowID]) {}
+    func gridAddRow() {}
+    func gridDuplicateRows(_ rowIDs: [RowID]) {}
+    func gridCanPasteRows() -> Bool { false }
+    func gridPasteRows() {}
+    func gridMoveRow(from source: RowID, toDisplayIndex destination: Int) {}
+    func gridSortDidChange(_ sort: SortState) {}
+    func gridConfirmDisplayOrderChange(then apply: @escaping @MainActor () -> Void) { apply() }
+    func gridFilterWithColumn(_ column: DataGridColumn) {}
+    func gridHideColumn(_ column: DataGridColumn) {}
+    func gridShowAllColumns() {}
+    func gridNavigateForeignKey(value: String, info: ForeignKeyInfo, intent: ReferenceOpenIntent) {}
+    func gridShowRowsAsJSON(_ rowIDs: [RowID]) {}
+    func gridExportResults() {}
+    func gridClearResults() {}
+    func gridSearchAllRows(term: String) {}
+    func gridSetCheckbox(_ isOn: Bool, rowIDs: [RowID], column: DataGridColumn) {}
+    func gridLoadUnloadedValues(rowIDs: [RowID], columns: IndexSet?, completion: @escaping @MainActor (Bool) -> Void) {
+        completion(false)
+    }
+    var gridSQLExporter: (any DataGridSQLExporting)? { nil }
+    func gridColumnMenuItems(for column: DataGridColumn) -> [NSMenuItem] { [] }
+    func gridRowMenuItems(for rowIDs: [RowID], clickedRow: RowID) -> [NSMenuItem] { [] }
+    func gridCellMenuItems(for rowID: RowID, column: DataGridColumn) -> [NSMenuItem] { [] }
+    func gridEmptySpaceMenu() -> NSMenu? { nil }
+    func gridHighlightValuesMenuItem(for column: DataGridColumn) -> NSMenuItem? { nil }
+}
+
+@MainActor
+protocol DataGridSQLExporting: AnyObject {
+    func canCopyAsInsert(_ rows: TableRows) -> Bool
+    func canCopyAsUpdate(_ rows: TableRows) -> Bool
+    func insertStatements(for rowIDs: [RowID], columns: [DataGridColumn], in rows: TableRows) -> String?
+    func updateStatements(for rowIDs: [RowID], columns: [DataGridColumn], in rows: TableRows) -> String?
+    func inClause(values: [PluginCellValue], column: DataGridColumn) -> String?
+}
+
+@MainActor
+protocol DataGridStateStore: AnyObject {
+    var sortState: SortState { get set }
+    var valueFilter: GridValueFilterState { get set }
+    var columnLayout: ColumnLayoutState { get set }
+    var displayFormats: [ValueDisplayFormat?] { get set }
+    var selectionSnapshot: GridSelectionSnapshot { get set }
+    var viewportAnchor: GridViewportPlacement? { get set }
+    var layoutScope: DataGridLayoutScope { get }
+}
+
+@MainActor
+final class InMemoryDataGridStateStore: DataGridStateStore {
+    var sortState = SortState()
+    var valueFilter = GridValueFilterState()
+    var columnLayout = ColumnLayoutState()
+    var displayFormats: [ValueDisplayFormat?] = []
+    var selectionSnapshot = GridSelectionSnapshot.empty
+    var viewportAnchor: GridViewportPlacement?
+    let layoutScope: DataGridLayoutScope = .ephemeral
+
+    init(columnLayout: ColumnLayoutState = ColumnLayoutState(), sortState: SortState = SortState()) {
+        self.columnLayout = columnLayout
+        self.sortState = sortState
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/DataGridCellEdit.swift b/apple/TablePro/Core/DataGrid/Engine/DataGridCellEdit.swift
new file mode 100644
index 0000000000..40cfb86e13
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/DataGridCellEdit.swift
@@ -0,0 +1,25 @@
+import Foundation
+import TableProPluginKit
+
+enum DataGridEditValue: Equatable {
+    case enteredText(String?)
+    case value(PluginCellValue, isExpression: Bool)
+    case removeField
+}
+
+struct DataGridCellEdit: Equatable {
+    let rowID: RowID
+    let columnID: DataGridColumnID
+    let value: DataGridEditValue
+}
+
+struct DataGridResolvedEdit: Equatable {
+    let rowID: RowID
+    let dataIndex: Int
+    let columnName: String
+    let oldValue: PluginCellValue
+    let newValue: PluginCellValue
+    let originalRow: [PluginCellValue]
+    let absence: FieldAbsence
+    let isExpression: Bool
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/DataGridChange.swift b/apple/TablePro/Core/DataGrid/Engine/DataGridChange.swift
new file mode 100644
index 0000000000..6b02a404af
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/DataGridChange.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+enum DataGridChange: Equatable {
+    case reload
+    case columnsChanged
+    case rowsInserted(IndexSet)
+    case rowsRemoved(IndexSet)
+    case rowsUpdated(IndexSet, columns: IndexSet?)
+
+    static let none = DataGridChange.rowsUpdated([], columns: [])
+
+    var isNone: Bool { self == .none }
+
+    // Every row from the first inserted or removed index to the end now sits at a new index.
+    func movedRows(rowCount: Int) -> IndexSet {
+        switch self {
+        case .rowsInserted(let indexes), .rowsRemoved(let indexes):
+            guard let first = indexes.first, first < rowCount else { return [] }
+            return IndexSet(integersIn: first..<rowCount)
+        case .reload, .columnsChanged, .rowsUpdated:
+            return []
+        }
+    }
+
+    // Under a value filter an insert or removal reshapes the order itself, so it reloads.
+    static func from(
+        _ delta: Delta,
+        order: DataGridRowOrder,
+        rows: TableRows,
+        columns: DataGridColumnSet
+    ) -> DataGridChange {
+        switch delta {
+        case .fullReplace:
+            return .reload
+        case .columnsReplaced:
+            return .columnsChanged
+        case .rowsInserted(let storage):
+            guard !order.isFiltered else { return .reload }
+            return .rowsInserted(storage)
+        case .rowsRemoved(let storage):
+            guard !order.isFiltered else { return .reload }
+            return .rowsRemoved(storage)
+        case .cellChanged(let row, let column):
+            return cells([CellPosition(row: row, column: column)], order: order, rows: rows, columns: columns)
+        case .cellsChanged(let positions):
+            return cells(positions, order: order, rows: rows, columns: columns)
+        }
+    }
+
+    private static func cells(
+        _ positions: some Collection<CellPosition>,
+        order: DataGridRowOrder,
+        rows: TableRows,
+        columns: DataGridColumnSet
+    ) -> DataGridChange {
+        guard !positions.isEmpty else { return .none }
+        var displayRows = IndexSet()
+        var displayColumns = IndexSet()
+        for position in positions {
+            guard let displayRow = order.displayIndex(ofStorageIndex: position.row, in: rows) else { continue }
+            displayRows.insert(displayRow)
+            if let displayColumn = columns.displayPosition(ofDataIndex: position.column) {
+                displayColumns.insert(displayColumn)
+            }
+        }
+        guard !displayRows.isEmpty else { return .none }
+        return .rowsUpdated(displayRows, columns: displayColumns)
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/DataGridColumnSet.swift b/apple/TablePro/Core/DataGrid/Engine/DataGridColumnSet.swift
new file mode 100644
index 0000000000..0615572490
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/DataGridColumnSet.swift
@@ -0,0 +1,135 @@
+import Foundation
+import TableProPluginKit
+
+struct DataGridColumnID: Hashable, Sendable {
+    let name: String
+    let occurrence: Int
+
+    // The occurrence leads, so a column named "a#1" never takes the second "a" column's key.
+    var stringValue: String {
+        "\(occurrence)#\(name)"
+    }
+}
+
+struct DataGridColumn: Equatable {
+    let id: DataGridColumnID
+    let dataIndex: Int
+    let type: ColumnType?
+    let comment: String?
+
+    var name: String { id.name }
+}
+
+struct DataGridColumnSet: Equatable {
+    private(set) var columns: [DataGridColumn]
+    private(set) var frozenCount: Int
+
+    private var positionByDataIndex: [Int: Int]
+    private var positionByID: [DataGridColumnID: Int]
+
+    static let empty = DataGridColumnSet(columns: [], frozenCount: 0)
+
+    init(columns: [DataGridColumn], frozenCount: Int) {
+        self.columns = columns
+        self.frozenCount = max(0, min(frozenCount, columns.count))
+        var byData: [Int: Int] = [:]
+        var byID: [DataGridColumnID: Int] = [:]
+        byData.reserveCapacity(columns.count)
+        byID.reserveCapacity(columns.count)
+        for (position, column) in columns.enumerated() {
+            byData[column.dataIndex] = position
+            byID[column.id] = position
+        }
+        self.positionByDataIndex = byData
+        self.positionByID = byID
+    }
+
+    init(tableRows: TableRows, layout: ColumnLayoutState) {
+        let ids = Self.columnIDs(for: tableRows.columns)
+        var all: [DataGridColumn] = []
+        all.reserveCapacity(ids.count)
+        for (dataIndex, id) in ids.enumerated() where !layout.hiddenColumns.contains(id.name) {
+            all.append(DataGridColumn(
+                id: id,
+                dataIndex: dataIndex,
+                type: dataIndex < tableRows.columnTypes.count ? tableRows.columnTypes[dataIndex] : nil,
+                comment: tableRows.columnComments[id.name]
+            ))
+        }
+        let ordered = Self.applyingOrder(layout.columnOrder, to: all)
+        self.init(columns: ordered, frozenCount: layout.frozenColumnCount)
+    }
+
+    static func columnIDs(for names: [String]) -> [DataGridColumnID] {
+        var seen: [String: Int] = [:]
+        return names.map { name in
+            let occurrence = seen[name, default: 0]
+            seen[name] = occurrence + 1
+            return DataGridColumnID(name: name, occurrence: occurrence)
+        }
+    }
+
+    private static func applyingOrder(_ order: [String]?, to columns: [DataGridColumn]) -> [DataGridColumn] {
+        guard let order, !order.isEmpty else { return columns }
+        var buckets: [String: [DataGridColumn]] = [:]
+        for column in columns {
+            buckets[column.name, default: []].append(column)
+        }
+        var result: [DataGridColumn] = []
+        result.reserveCapacity(columns.count)
+        for name in order {
+            guard var bucket = buckets[name], !bucket.isEmpty else { continue }
+            result.append(bucket.removeFirst())
+            buckets[name] = bucket
+        }
+        let placed = Set(result.map(\.id))
+        result.append(contentsOf: columns.filter { !placed.contains($0.id) })
+        return result
+    }
+
+    var count: Int { columns.count }
+    var isEmpty: Bool { columns.isEmpty }
+
+    var frozenColumns: ArraySlice<DataGridColumn> { columns.prefix(frozenCount) }
+
+    func column(at displayPosition: Int) -> DataGridColumn? {
+        guard displayPosition >= 0, displayPosition < columns.count else { return nil }
+        return columns[displayPosition]
+    }
+
+    func column(id: DataGridColumnID) -> DataGridColumn? {
+        positionByID[id].map { columns[$0] }
+    }
+
+    func displayPosition(ofDataIndex dataIndex: Int) -> Int? {
+        positionByDataIndex[dataIndex]
+    }
+
+    func displayPosition(of id: DataGridColumnID) -> Int? {
+        positionByID[id]
+    }
+
+    func dataIndex(atDisplayPosition displayPosition: Int) -> Int? {
+        column(at: displayPosition)?.dataIndex
+    }
+
+    func isFrozen(displayPosition: Int) -> Bool {
+        displayPosition >= 0 && displayPosition < frozenCount
+    }
+
+    var orderedNames: [String] { columns.map(\.name) }
+
+    func withFrozenCount(_ count: Int) -> DataGridColumnSet {
+        DataGridColumnSet(columns: columns, frozenCount: count)
+    }
+
+    func moving(from source: Int, to destination: Int) -> DataGridColumnSet {
+        guard source != destination, columns.indices.contains(source), columns.indices.contains(destination) else {
+            return self
+        }
+        var reordered = columns
+        let moved = reordered.remove(at: source)
+        reordered.insert(moved, at: destination)
+        return DataGridColumnSet(columns: reordered, frozenCount: frozenCount)
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/DataGridRowOrder.swift b/apple/TablePro/Core/DataGrid/Engine/DataGridRowOrder.swift
new file mode 100644
index 0000000000..a1caa7c2c0
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/DataGridRowOrder.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+struct DataGridRowOrder: Equatable {
+    private(set) var filteredIDs: [RowID]?
+    private var displayIndexByID: [RowID: Int]?
+    private(set) var revision: Int
+
+    static let unfiltered = DataGridRowOrder(filteredIDs: nil, revision: 0)
+
+    init(filteredIDs: [RowID]?, revision: Int) {
+        self.filteredIDs = filteredIDs
+        self.revision = revision
+        if let filteredIDs {
+            var index: [RowID: Int] = [:]
+            index.reserveCapacity(filteredIDs.count)
+            for (position, id) in filteredIDs.enumerated() {
+                index[id] = position
+            }
+            displayIndexByID = index
+        } else {
+            displayIndexByID = nil
+        }
+    }
+
+    var isFiltered: Bool { filteredIDs != nil }
+
+    func count(in tableRows: TableRows) -> Int {
+        filteredIDs?.count ?? tableRows.rows.count
+    }
+
+    func rowID(at displayIndex: Int, in tableRows: TableRows) -> RowID? {
+        if let filteredIDs {
+            guard displayIndex >= 0, displayIndex < filteredIDs.count else { return nil }
+            return filteredIDs[displayIndex]
+        }
+        guard displayIndex >= 0, displayIndex < tableRows.rows.count else { return nil }
+        return tableRows.rows[displayIndex].id
+    }
+
+    func storageIndex(at displayIndex: Int, in tableRows: TableRows) -> Int? {
+        guard let id = rowID(at: displayIndex, in: tableRows) else { return nil }
+        return tableRows.index(of: id)
+    }
+
+    func row(at displayIndex: Int, in tableRows: TableRows) -> Row? {
+        storageIndex(at: displayIndex, in: tableRows).map { tableRows.rows[$0] }
+    }
+
+    func displayIndex(of id: RowID, in tableRows: TableRows) -> Int? {
+        if let displayIndexByID {
+            return displayIndexByID[id]
+        }
+        return tableRows.index(of: id)
+    }
+
+    func displayIndex(ofStorageIndex storageIndex: Int, in tableRows: TableRows) -> Int? {
+        guard storageIndex >= 0, storageIndex < tableRows.rows.count else { return nil }
+        guard isFiltered else { return storageIndex }
+        return displayIndex(of: tableRows.rows[storageIndex].id, in: tableRows)
+    }
+
+    func rowIDs(atDisplayIndexes indexes: IndexSet, in tableRows: TableRows) -> [RowID] {
+        indexes.compactMap { rowID(at: $0, in: tableRows) }
+    }
+
+    func displayIndexes(of ids: some Sequence<RowID>, in tableRows: TableRows) -> IndexSet {
+        IndexSet(ids.compactMap { displayIndex(of: $0, in: tableRows) })
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/DataGridValueTypes.swift b/apple/TablePro/Core/DataGrid/Engine/DataGridValueTypes.swift
new file mode 100644
index 0000000000..83e62ab17f
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/DataGridValueTypes.swift
@@ -0,0 +1,82 @@
+import Foundation
+
+struct CellPosition: Hashable {
+    let row: Int
+    let column: Int
+}
+
+enum DataGridChangeVocabulary: Equatable {
+    case pendingEdit
+    case comparison
+    case resultComparison
+}
+
+struct RowVisualState: Equatable {
+    let isDeleted: Bool
+    let isInserted: Bool
+    let modifiedColumns: Set<Int>
+    let struckColumns: Set<Int>
+    // Pending cells staged as SQL, which draw like a pending DEFAULT.
+    let expressionColumns: Set<Int>
+    let vocabulary: DataGridChangeVocabulary
+    let highlight: RowHighlight
+
+    init(
+        isDeleted: Bool,
+        isInserted: Bool,
+        modifiedColumns: Set<Int>,
+        struckColumns: Set<Int> = [],
+        expressionColumns: Set<Int> = [],
+        vocabulary: DataGridChangeVocabulary = .pendingEdit,
+        highlight: RowHighlight = .none
+    ) {
+        self.isDeleted = isDeleted
+        self.isInserted = isInserted
+        self.modifiedColumns = modifiedColumns
+        self.struckColumns = struckColumns
+        self.expressionColumns = expressionColumns
+        self.vocabulary = vocabulary
+        self.highlight = highlight
+    }
+
+    func isModified(columnIndex: Int) -> Bool {
+        modifiedColumns.contains(columnIndex)
+    }
+
+    func isStruck(columnIndex: Int) -> Bool {
+        struckColumns.contains(columnIndex)
+    }
+
+    func isExpression(columnIndex: Int) -> Bool {
+        expressionColumns.contains(columnIndex)
+    }
+
+    func highlighted(_ highlight: RowHighlight) -> RowVisualState {
+        RowVisualState(
+            isDeleted: isDeleted,
+            isInserted: isInserted,
+            modifiedColumns: modifiedColumns,
+            struckColumns: struckColumns,
+            expressionColumns: expressionColumns,
+            vocabulary: vocabulary,
+            highlight: highlight
+        )
+    }
+
+    static let empty = RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [])
+}
+
+extension RowVisualState {
+    func cellHighlightColor(forColumn column: Int) -> HighlightColor? {
+        guard !isDeleted, !isInserted else { return nil }
+        return highlight.cellRule(forColumn: column)?.color
+    }
+
+    func drawnHighlightRule(forColumn column: Int) -> HighlightRule? {
+        guard !isDeleted, !isInserted else { return nil }
+        if !isModified(columnIndex: column), let cellRule = highlight.cellRule(forColumn: column) {
+            return cellRule
+        }
+        return highlight.rowRule
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/DisplayFormatArray.swift b/apple/TablePro/Core/DataGrid/Engine/DisplayFormatArray.swift
new file mode 100644
index 0000000000..35452e62b1
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/DisplayFormatArray.swift
@@ -0,0 +1,18 @@
+import Foundation
+
+enum DisplayFormatArray {
+    // Readers index the array by column, so it always covers every column of the result.
+    static func setting(
+        _ format: ValueDisplayFormat?,
+        at columnIndex: Int,
+        in existing: [ValueDisplayFormat?],
+        columnCount: Int
+    ) -> [ValueDisplayFormat?] {
+        var formats = existing
+        while formats.count < max(columnCount, columnIndex + 1) {
+            formats.append(nil)
+        }
+        formats[columnIndex] = format
+        return formats
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/GridFindEngine.swift b/apple/TablePro/Core/DataGrid/Engine/GridFindEngine.swift
new file mode 100644
index 0000000000..b9fbfbed40
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/GridFindEngine.swift
@@ -0,0 +1,355 @@
+import Foundation
+import TableProPluginKit
+
+struct GridFindMatcher {
+    struct InvalidPattern: Error {}
+
+    private enum Strategy {
+        case literal(needle: String, options: String.CompareOptions)
+        case expression(NSRegularExpression)
+    }
+
+    private let strategy: Strategy
+    private let expandsTemplates: Bool
+
+    // Nil when the term finds nothing. A literal term is trimmed; a regular expression is taken as typed.
+    static func make(term: String, options: GridFindState.Options) throws -> GridFindMatcher? {
+        if options.usesRegularExpression {
+            guard !term.isEmpty else { return nil }
+            return try compiled(pattern: term, options: options, expandsTemplates: true)
+        }
+        let needle = term.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !needle.isEmpty else { return nil }
+        if options.matchesWholeWord {
+            return try compiled(
+                pattern: NSRegularExpression.escapedPattern(for: needle),
+                options: options,
+                expandsTemplates: false
+            )
+        }
+        let compare: String.CompareOptions = options.matchesCase ? [] : [.caseInsensitive, .diacriticInsensitive]
+        return GridFindMatcher(strategy: .literal(needle: needle, options: compare), expandsTemplates: false)
+    }
+
+    private static func compiled(
+        pattern: String,
+        options: GridFindState.Options,
+        expandsTemplates: Bool
+    ) throws -> GridFindMatcher {
+        let wrapped = options.matchesWholeWord ? "\\b(?:\(pattern))\\b" : pattern
+        let expression: NSRegularExpression
+        do {
+            expression = try NSRegularExpression(pattern: wrapped, options: options.matchesCase ? [] : [.caseInsensitive])
+        } catch {
+            throw InvalidPattern()
+        }
+        return GridFindMatcher(strategy: .expression(expression), expandsTemplates: expandsTemplates)
+    }
+
+    func matches(_ text: String) -> Bool {
+        switch strategy {
+        case .literal(let needle, let options):
+            return text.range(of: needle, options: options) != nil
+        case .expression(let expression):
+            return !Self.nonEmptyMatches(of: expression, in: text, limit: 1).isEmpty
+        }
+    }
+
+    func replacing(in text: String, with template: String) -> (text: String, replacements: Int) {
+        switch strategy {
+        case .literal(let needle, let options):
+            return Self.replacingLiteral(needle, options: options, in: text, with: template)
+        case .expression(let expression):
+            let found = Self.nonEmptyMatches(of: expression, in: text, limit: nil)
+            guard !found.isEmpty else { return (text, 0) }
+            let effectiveTemplate = expandsTemplates ? template : NSRegularExpression.escapedTemplate(for: template)
+            let result = NSMutableString(string: text)
+            var offset = 0
+            for match in found {
+                // Capture groups are read from the original text, where the match's ranges still point.
+                let replacement = expression.replacementString(for: match, in: text, offset: 0, template: effectiveTemplate)
+                result.replaceCharacters(
+                    in: NSRange(location: match.range.location + offset, length: match.range.length),
+                    with: replacement
+                )
+                offset += (replacement as NSString).length - match.range.length
+            }
+            return (result as String, found.count)
+        }
+    }
+
+    private static func replacingLiteral(
+        _ needle: String,
+        options: String.CompareOptions,
+        in text: String,
+        with template: String
+    ) -> (text: String, replacements: Int) {
+        var result = ""
+        var count = 0
+        var cursor = text.startIndex
+        while cursor < text.endIndex,
+              let range = text.range(of: needle, options: options, range: cursor..<text.endIndex),
+              !range.isEmpty {
+            result.append(contentsOf: text[cursor..<range.lowerBound])
+            result.append(template)
+            count += 1
+            cursor = range.upperBound
+        }
+        guard count > 0 else { return (text, 0) }
+        result.append(contentsOf: text[cursor...])
+        return (result, count)
+    }
+
+    // A pattern like `x*` matches the empty string in every cell, which highlights nothing.
+    private static func nonEmptyMatches(
+        of expression: NSRegularExpression,
+        in text: String,
+        limit: Int?
+    ) -> [NSTextCheckingResult] {
+        var found: [NSTextCheckingResult] = []
+        expression.enumerateMatches(in: text, range: NSRange(text.startIndex..., in: text)) { match, _, stop in
+            guard let match, match.range.length > 0 else { return }
+            found.append(match)
+            if let limit, found.count >= limit {
+                stop.pointee = true
+            }
+        }
+        return found
+    }
+}
+
+@MainActor
+enum GridFindEngine {
+    struct Source {
+        let rows: TableRows
+        let order: DataGridRowOrder
+        let columns: DataGridColumnSet
+        var displayFormats: [ValueDisplayFormat?] = []
+        var databaseType: DatabaseType?
+        var revealsInvisibleCharacters = false
+    }
+
+    struct Result: Equatable {
+        var matches: [GridFindState.Match] = []
+        var problem: String?
+    }
+
+    struct Replacement: Equatable {
+        var edits: [DataGridCellEdit] = []
+        var replacements = 0
+
+        var cells: Int { edits.count }
+    }
+
+    static var invalidPatternProblem: String {
+        String(localized: "Invalid regular expression")
+    }
+
+    static func problem(term: String, options: GridFindState.Options) -> String? {
+        do {
+            _ = try GridFindMatcher.make(term: term, options: options)
+            return nil
+        } catch {
+            return invalidPatternProblem
+        }
+    }
+
+    static func search(_ term: String, options: GridFindState.Options, in source: Source) -> Result {
+        let matcher: GridFindMatcher?
+        do {
+            matcher = try GridFindMatcher.make(term: term, options: options)
+        } catch {
+            return Result(problem: invalidPatternProblem)
+        }
+        guard let matcher else { return Result() }
+        let searched = searchedColumns(options: options, in: source)
+        guard !searched.isEmpty else { return Result() }
+
+        var found: [GridFindState.Match] = []
+        let rowCount = source.order.count(in: source.rows)
+        for displayRow in 0..<rowCount {
+            guard let row = source.order.row(at: displayRow, in: source.rows) else { continue }
+            for column in searched {
+                guard let text = searchableText(in: row, column: column, source: source),
+                      matcher.matches(text) else { continue }
+                found.append(GridFindState.Match(rowID: row.id, columnID: column.id))
+            }
+        }
+        return Result(matches: found)
+    }
+
+    // A scope naming a column that is no longer presented searches every presented column.
+    static func searchedColumns(options: GridFindState.Options, in source: Source) -> [DataGridColumn] {
+        let candidates: [DataGridColumn]
+        if let scope = options.columnScope, let scoped = source.columns.column(id: scope) {
+            candidates = [scoped]
+        } else {
+            candidates = source.columns.columns
+        }
+        return candidates.filter { column in
+            FindMatcher.isSearchable(column.type, displayFormat: displayFormat(for: column, in: source))
+        }
+    }
+
+    // Nil for NULL, an empty cell, and bytes the column's format could not decode, which show as hex.
+    static func searchableText(in row: Row, column: DataGridColumn, source: Source) -> String? {
+        let dataIndex = column.dataIndex
+        guard dataIndex < row.values.count else { return nil }
+        let rawValue = row.values[dataIndex]
+        let format = displayFormat(for: column, in: source)
+        switch rawValue {
+        case .null:
+            return nil
+        case .text:
+            break
+        case .bytes(let data):
+            guard let format,
+                  format.isApplicable(to: column.type, databaseType: source.databaseType),
+                  ValueDisplayFormatter.apply(data, format: format, columnType: column.type) != nil else { return nil }
+        }
+        let shown = GridDisplayOrderResolver.displayValue(
+            rawValue,
+            columnType: column.type,
+            displayFormat: format,
+            databaseType: source.databaseType
+        )
+        guard !shown.isEmpty else { return nil }
+        return source.revealsInvisibleCharacters ? shown : shown.shownWithoutMarks
+    }
+
+    // Replaces in the stored text, not the shown one: a cell shows a capped, single-line copy of its value.
+    static func replacements(
+        for matches: [GridFindState.Match],
+        term: String,
+        options: GridFindState.Options,
+        template: String,
+        in source: Source,
+        isWritable: (DataGridColumn) -> Bool
+    ) -> Replacement {
+        guard let matcher = try? GridFindMatcher.make(term: term, options: options) else { return Replacement() }
+        var result = Replacement()
+        for match in matches {
+            guard let column = source.columns.column(id: match.columnID),
+                  isWritable(column),
+                  let row = source.rows.row(withID: match.rowID),
+                  column.dataIndex < row.values.count,
+                  case .text(let original) = row.values[column.dataIndex] else { continue }
+            let replaced = matcher.replacing(in: original, with: template)
+            guard replaced.replacements > 0, replaced.text != original else { continue }
+            result.edits.append(DataGridCellEdit(
+                rowID: match.rowID,
+                columnID: match.columnID,
+                value: .enteredText(replaced.text)
+            ))
+            result.replacements += replaced.replacements
+        }
+        return result
+    }
+
+    static func position(of match: GridFindState.Match, in source: Source) -> GridCoord? {
+        guard let row = source.order.displayIndex(of: match.rowID, in: source.rows),
+              let column = source.columns.displayPosition(of: match.columnID) else { return nil }
+        return GridCoord(row: row, displayColumn: column)
+    }
+
+    static func positions(of matches: [GridFindState.Match], in source: Source) -> [GridCoord?] {
+        matches.map { position(of: $0, in: source) }
+    }
+
+    // MARK: - Stepping
+
+    static func index(atOrAfter cell: GridCoord?, in positions: [GridCoord?]) -> Int? {
+        guard !positions.isEmpty else { return nil }
+        guard let cell else { return 0 }
+        return positions.firstIndex { candidate in
+            candidate.map { !precedes($0, cell) } ?? false
+        } ?? 0
+    }
+
+    static func index(after cell: GridCoord, in positions: [GridCoord?]) -> Int? {
+        guard !positions.isEmpty else { return nil }
+        return positions.firstIndex { candidate in
+            candidate.map { precedes(cell, $0) } ?? false
+        } ?? 0
+    }
+
+    static func index(before cell: GridCoord, in positions: [GridCoord?]) -> Int? {
+        guard !positions.isEmpty else { return nil }
+        return positions.lastIndex { candidate in
+            candidate.map { precedes($0, cell) } ?? false
+        } ?? positions.count - 1
+    }
+
+    // Steps from the current match, or from the cursor once the user has moved it off that match.
+    static func step(
+        from current: Int?,
+        active: GridCoord?,
+        positions: [GridCoord?],
+        forward: Bool
+    ) -> Int? {
+        guard !positions.isEmpty else { return nil }
+        let currentPosition = current.flatMap { positions.indices.contains($0) ? positions[$0] : nil }
+        if let active, currentPosition != active {
+            return forward ? index(after: active, in: positions) : index(before: active, in: positions)
+        }
+        guard let current, positions.indices.contains(current) else {
+            return forward ? 0 : positions.count - 1
+        }
+        let count = positions.count
+        return forward ? (current + 1) % count : (current - 1 + count) % count
+    }
+
+    // MARK: - Stepping through an owner's dataset
+
+    // A dataset's matches arrive in display order; bisection keeps a step to a few position lookups.
+    static func sortedIndex(atOrAfter cell: GridCoord, count: Int, position: (Int) -> GridCoord?) -> Int? {
+        guard count > 0 else { return nil }
+        let index = partition(count: count) { candidate in position(candidate).map { precedes($0, cell) } ?? true }
+        return index < count ? index : 0
+    }
+
+    static func sortedIndex(after cell: GridCoord, count: Int, position: (Int) -> GridCoord?) -> Int? {
+        guard count > 0 else { return nil }
+        let index = partition(count: count) { candidate in position(candidate).map { !precedes(cell, $0) } ?? true }
+        return index < count ? index : 0
+    }
+
+    static func sortedIndex(before cell: GridCoord, count: Int, position: (Int) -> GridCoord?) -> Int? {
+        guard count > 0 else { return nil }
+        let index = partition(count: count) { candidate in position(candidate).map { precedes($0, cell) } ?? true }
+        return index > 0 ? index - 1 : count - 1
+    }
+
+    private static func partition(count: Int, isBelow: (Int) -> Bool) -> Int {
+        var low = 0
+        var high = count
+        while low < high {
+            let middle = low + (high - low) / 2
+            if isBelow(middle) {
+                low = middle + 1
+            } else {
+                high = middle
+            }
+        }
+        return low
+    }
+
+    nonisolated static func replacementMessage(replacements: Int, cells: Int) -> String {
+        guard cells > 0 else { return String(localized: "No matches to replace.") }
+        let matchPhrase = replacements == 1
+            ? String(localized: "1 match")
+            : String(format: String(localized: "%@ matches"), replacements.formatted())
+        let cellPhrase = cells == 1
+            ? String(localized: "1 cell")
+            : String(format: String(localized: "%@ cells"), cells.formatted())
+        return String(format: String(localized: "Replaced %1$@ in %2$@."), matchPhrase, cellPhrase)
+    }
+
+    private static func displayFormat(for column: DataGridColumn, in source: Source) -> ValueDisplayFormat? {
+        column.dataIndex < source.displayFormats.count ? source.displayFormats[column.dataIndex] : nil
+    }
+
+    private static func precedes(_ lhs: GridCoord, _ rhs: GridCoord) -> Bool {
+        lhs.row < rhs.row || (lhs.row == rhs.row && lhs.displayColumn < rhs.displayColumn)
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/GridSelectionReducer.swift b/apple/TablePro/Core/DataGrid/Engine/GridSelectionReducer.swift
new file mode 100644
index 0000000000..06ef7c2957
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/GridSelectionReducer.swift
@@ -0,0 +1,474 @@
+import Foundation
+
+struct GridSelectionContext: Equatable {
+    let rowCount: Int
+    let columnCount: Int
+
+    var isEmpty: Bool { rowCount <= 0 || columnCount <= 0 }
+
+    fileprivate var allRows: ClosedRange<Int> { 0...max(rowCount - 1, 0) }
+    fileprivate var allColumns: ClosedRange<Int> { 0...max(columnCount - 1, 0) }
+
+    fileprivate func clamp(_ cell: GridCoord) -> GridCoord {
+        GridCoord(
+            row: min(max(cell.row, 0), max(rowCount - 1, 0)),
+            displayColumn: min(max(cell.displayColumn, 0), max(columnCount - 1, 0))
+        )
+    }
+
+    fileprivate func fit(_ selection: GridSelection) -> GridSelection {
+        selection.clamped(rowLimit: rowCount, columnLimit: columnCount)
+    }
+}
+
+enum GridMoveDirection: Equatable {
+    case up
+    case down
+    case left
+    case right
+}
+
+struct GridPointerModifiers: OptionSet {
+    let rawValue: Int
+
+    static let shift = GridPointerModifiers(rawValue: 1 << 0)
+    static let command = GridPointerModifiers(rawValue: 1 << 1)
+}
+
+struct GridSelectionDrag: Equatable {
+    enum Mode: Equatable {
+        case replace
+        case additive
+        case rows
+    }
+
+    let origin: GridCoord
+    let base: GridSelection
+    let mode: Mode
+}
+
+enum GridSelectionReducer {
+    static func single(_ cell: GridCoord) -> GridSelection {
+        GridSelection(rectangles: [GridRect(cell: cell)], activeCell: cell, anchor: cell)
+    }
+
+    // A cell click selects its row natively and puts the cursor on the cell; a range forms only by drag or Shift.
+    static func cursor(_ cell: GridCoord, in c: GridSelectionContext) -> GridSelection {
+        guard !c.isEmpty else { return .empty }
+        let target = c.clamp(cell)
+        return GridSelection(
+            rectangles: [GridRect(rows: target.row...target.row, columns: c.allColumns)],
+            activeCell: target,
+            anchor: target,
+            mode: .cursor
+        )
+    }
+
+    // MARK: - Pointer
+
+    static func press(
+        _ s: GridSelection,
+        at cell: GridCoord,
+        modifiers: GridPointerModifiers,
+        in c: GridSelectionContext
+    ) -> (GridSelection, GridSelectionDrag) {
+        guard !c.isEmpty else {
+            return (.empty, GridSelectionDrag(origin: cell, base: .empty, mode: .replace))
+        }
+        let target = c.clamp(cell)
+        let current = c.fit(s)
+        switch Gesture(modifiers) {
+        case .toggle:
+            let base = cellBase(of: current, in: c)
+            let drag = GridSelectionDrag(origin: target, base: base, mode: .additive)
+            return (c.fit(toggling(target, in: base)), drag)
+        case .extend:
+            let anchor = current.anchor ?? current.activeCell ?? target
+            let drag = GridSelectionDrag(origin: anchor, base: .empty, mode: .replace)
+            guard anchor != target else { return (cursor(target, in: c), drag) }
+            return (c.fit(range(from: anchor, to: target)), drag)
+        case .replace:
+            return (cursor(target, in: c), GridSelectionDrag(origin: target, base: .empty, mode: .replace))
+        }
+    }
+
+    // A drag back onto its origin gives the press's own result, so a Command-press that never moves stays a toggle.
+    static func drag(_ d: GridSelectionDrag, to cell: GridCoord, in c: GridSelectionContext) -> GridSelection {
+        guard !c.isEmpty else { return .empty }
+        let target = c.clamp(cell)
+        let origin = c.clamp(d.origin)
+        let base = c.fit(d.base)
+        switch d.mode {
+        case .replace:
+            guard target != origin else { return cursor(origin, in: c) }
+            return c.fit(range(from: origin, to: target))
+        case .additive:
+            guard target != origin else { return c.fit(toggling(origin, in: base)) }
+            return c.fit(GridSelection(
+                rectangles: base.rectangles + [GridRect.between(origin, target)],
+                activeCell: target,
+                anchor: origin,
+                columns: base.columns
+            ))
+        case .rows:
+            guard target.row != origin.row else {
+                return picking(c.fit(togglingRow(origin.row, in: base, activeColumn: origin.displayColumn, c)))
+            }
+            return picking(c.fit(addingRows(
+                min(origin.row, target.row)...max(origin.row, target.row),
+                to: base,
+                active: GridCoord(row: target.row, displayColumn: origin.displayColumn),
+                anchor: origin,
+                c
+            )))
+        }
+    }
+
+    static func rowHeaderPress(
+        _ s: GridSelection,
+        row: Int,
+        modifiers: GridPointerModifiers,
+        in c: GridSelectionContext
+    ) -> (GridSelection, GridSelectionDrag) {
+        guard !c.isEmpty else {
+            return (.empty, GridSelectionDrag(origin: GridCoord(row: row, displayColumn: 0), base: .empty, mode: .rows))
+        }
+        let current = c.fit(s)
+        let column = activeColumn(of: current, in: c)
+        let target = c.clamp(GridCoord(row: row, displayColumn: column))
+        switch Gesture(modifiers) {
+        case .toggle:
+            let drag = GridSelectionDrag(origin: target, base: current, mode: .rows)
+            return (picking(c.fit(togglingRow(target.row, in: current, activeColumn: column, c))), drag)
+        case .extend:
+            let anchor = GridCoord(row: current.anchor?.row ?? current.activeCell?.row ?? target.row, displayColumn: column)
+            let drag = GridSelectionDrag(origin: anchor, base: .empty, mode: .rows)
+            let rows = min(anchor.row, target.row)...max(anchor.row, target.row)
+            return (picking(c.fit(addingRows(rows, to: .empty, active: target, anchor: anchor, c))), drag)
+        case .replace:
+            let drag = GridSelectionDrag(origin: target, base: .empty, mode: .rows)
+            return (picking(c.fit(addingRows(target.row...target.row, to: .empty, active: target, anchor: target, c))), drag)
+        }
+    }
+
+    // A plain row number press AppKit tracks for a drag. A reorder moves one row, so there the pressed row is picked alone.
+    static func rowNumberDragPress(
+        _ s: GridSelection,
+        row: Int,
+        keepsPickedRows: Bool,
+        in c: GridSelectionContext
+    ) -> GridSelection {
+        let current = c.fit(s)
+        if keepsPickedRows, current.picksRows, current.affectedRows.contains(row) {
+            return current
+        }
+        return rowHeaderPress(current, row: row, modifiers: [], in: c).0
+    }
+
+    static func columnHeaderCommandClick(
+        _ s: GridSelection,
+        column: Int,
+        modifiers: GridPointerModifiers,
+        in c: GridSelectionContext
+    ) -> GridSelection {
+        let current = c.fit(s)
+        guard !c.isEmpty, column >= 0, column < c.columnCount else { return current }
+        let base = cellBase(of: current, in: c)
+        if modifiers.contains(.shift),
+           let from = base.anchor?.displayColumn ?? base.activeCell?.displayColumn,
+           from != column {
+            return c.fit(addingColumns(from: from, to: column, in: base, c))
+        }
+        if base.columns.contains(column) {
+            return c.fit(removingColumn(column, from: base, c))
+        }
+        let addition = GridSelection.column(column, totalRows: c.rowCount)
+        return c.fit(base.isEmpty ? addition : base.union(addition))
+    }
+
+    // MARK: - Keyboard
+
+    static func move(
+        _ s: GridSelection,
+        _ direction: GridMoveDirection,
+        extending: Bool,
+        toEdge: Bool,
+        in c: GridSelectionContext
+    ) -> GridSelection {
+        guard !c.isEmpty else { return .empty }
+        let current = c.fit(s)
+        guard let active = cursor(of: current, in: c) else {
+            return cursor(GridCoord(row: 0, displayColumn: 0), in: c)
+        }
+        let next = step(from: active, direction, toEdge: toEdge, in: c)
+        guard extending else {
+            // Left and Right over picked rows move the cursor and keep the rows, as the cursor did before.
+            if current.isRows, next.row == active.row, current.affectedRows.contains(next.row) {
+                return GridSelection(rectangles: current.rectangles, activeCell: next, anchor: next, mode: .cursor)
+            }
+            return cursor(next, in: c)
+        }
+        let anchor = current.anchor ?? active
+        guard anchor != next else { return cursor(next, in: c) }
+        return c.fit(range(from: anchor, to: next))
+    }
+
+    static func moveToColumnEdge(
+        _ s: GridSelection,
+        last: Bool,
+        extending: Bool,
+        in c: GridSelectionContext
+    ) -> GridSelection {
+        move(s, last ? .right : .left, extending: extending, toEdge: true, in: c)
+    }
+
+    // With no cell to start from the selection comes back unchanged, which tells the view to leave the grid.
+    static func tab(_ s: GridSelection, forward: Bool, in c: GridSelectionContext) -> GridSelection {
+        guard !c.isEmpty else { return .empty }
+        let current = c.fit(s)
+        guard let active = cursor(of: current, in: c) else { return current }
+        let next: GridCoord
+        if forward {
+            if active.displayColumn + 1 < c.columnCount {
+                next = GridCoord(row: active.row, displayColumn: active.displayColumn + 1)
+            } else if active.row + 1 < c.rowCount {
+                next = GridCoord(row: active.row + 1, displayColumn: 0)
+            } else {
+                next = active
+            }
+        } else {
+            if active.displayColumn > 0 {
+                next = GridCoord(row: active.row, displayColumn: active.displayColumn - 1)
+            } else if active.row > 0 {
+                next = GridCoord(row: active.row - 1, displayColumn: c.columnCount - 1)
+            } else {
+                next = active
+            }
+        }
+        return cursor(next, in: c)
+    }
+
+    // Select All picks every row and leaves no cursor, as NSTableView's own selectAll does.
+    static func selectAll(_ s: GridSelection, in c: GridSelectionContext) -> GridSelection {
+        guard !c.isEmpty else { return .empty }
+        return GridSelection(
+            rectangles: [GridRect(rows: c.allRows, columns: c.allColumns)],
+            activeCell: nil,
+            anchor: nil,
+            mode: .rows
+        )
+    }
+
+    static func widenToRows(_ s: GridSelection, in c: GridSelectionContext) -> GridSelection {
+        guard !c.isEmpty else { return .empty }
+        let current = c.fit(s)
+        let rows = current.affectedRows
+        guard let firstRow = rows.first else { return current }
+        let cursorCell = cursor(of: current, in: c) ?? GridCoord(row: firstRow, displayColumn: 0)
+        let active = rows.contains(cursorCell.row)
+            ? cursorCell
+            : GridCoord(row: firstRow, displayColumn: cursorCell.displayColumn)
+        let anchor = current.anchor.flatMap { rows.contains($0.row) ? $0 : nil } ?? active
+        return picking(c.fit(GridSelection(rectangles: rowRectangles(rows, c), activeCell: active, anchor: anchor)))
+    }
+
+    // Without a context, whole rows are guessed from the shape: every rectangle spans column 0 to one shared last column.
+    // Escape drops a cell range back to its cursor's row, then the rows to nothing.
+    static func cancel(_ s: GridSelection, in c: GridSelectionContext) -> GridSelection {
+        guard !s.isEmpty, !s.isRows else { return .empty }
+        guard let active = s.activeCell ?? s.anchor ?? s.rectangles.first.map(topLeft) else { return .empty }
+        return cursor(active, in: c)
+    }
+
+    static func rowsSelectedNatively(
+        _ rows: IndexSet,
+        previous: GridSelection,
+        in c: GridSelectionContext
+    ) -> GridSelection {
+        guard !c.isEmpty else { return .empty }
+        let valid = rows.filteredIndexSet { $0 >= 0 && $0 < c.rowCount }
+        guard let firstRow = valid.first, let lastRow = valid.last else { return .empty }
+        let column = activeColumn(of: previous, in: c)
+        let previousRows = previous.affectedRows
+        let row: Int
+        if let added = valid.subtracting(previousRows).last {
+            row = added
+        } else if let lost = previousRows.subtracting(valid).last {
+            row = lost > lastRow ? lastRow : firstRow
+        } else if let kept = previous.activeCell?.row, valid.contains(kept) {
+            row = kept
+        } else {
+            row = firstRow
+        }
+        let active = GridCoord(row: row, displayColumn: column)
+        let anchor = previous.anchor.flatMap { valid.contains($0.row) ? GridCoord(row: $0.row, displayColumn: column) : nil }
+        return GridSelection(
+            rectangles: rowRectangles(valid, c),
+            activeCell: previous.activeCell == nil && previous.picksRows ? nil : active,
+            anchor: anchor ?? active,
+            mode: previous.picksRows ? .rows : .cursor
+        )
+    }
+
+    // NSTableView answers -1 for a point past either end, so the point decides which end.
+    static func dragIndex(hit: Int, coordinate: CGFloat, first: Int, last: Int, lastMaxEdge: CGFloat) -> Int? {
+        guard first >= 0, last >= first else { return nil }
+        guard hit < 0 else { return min(max(hit, first), last) }
+        return coordinate >= lastMaxEdge ? last : first
+    }
+}
+
+// MARK: - Helpers
+
+private enum Gesture {
+    case replace
+    case extend
+    case toggle
+
+    init(_ modifiers: GridPointerModifiers) {
+        switch (modifiers.contains(.shift), modifiers.contains(.command)) {
+        case (false, true): self = .toggle
+        case (true, false): self = .extend
+        default: self = .replace
+        }
+    }
+}
+
+private extension GridSelectionReducer {
+    static func picking(_ s: GridSelection) -> GridSelection {
+        var picked = s
+        picked.mode = s.isEmpty ? .cells : .rows
+        return picked
+    }
+
+    // A Command-click on a cell or a header adds to the cells already chosen; a clicked row lends only its cursor cell.
+    static func cellBase(of s: GridSelection, in c: GridSelectionContext) -> GridSelection {
+        switch s.mode {
+        case .cells:
+            return s
+        case .cursor:
+            return s.activeCell.map(single) ?? .empty
+        case .rows:
+            return .empty
+        }
+    }
+
+    static func range(from anchor: GridCoord, to active: GridCoord) -> GridSelection {
+        GridSelection(rectangles: [GridRect.between(anchor, active)], activeCell: active, anchor: anchor)
+    }
+
+    static func topLeft(_ rect: GridRect) -> GridCoord {
+        GridCoord(row: rect.rows.lowerBound, displayColumn: rect.columns.lowerBound)
+    }
+
+    static func cursor(of s: GridSelection, in c: GridSelectionContext) -> GridCoord? {
+        guard let cell = s.activeCell ?? s.anchor ?? s.rectangles.first.map(topLeft) else { return nil }
+        return c.clamp(cell)
+    }
+
+    static func activeColumn(of s: GridSelection, in c: GridSelectionContext) -> Int {
+        let column = s.activeCell?.displayColumn ?? s.anchor?.displayColumn ?? 0
+        return min(max(column, 0), max(c.columnCount - 1, 0))
+    }
+
+    static func step(
+        from cell: GridCoord,
+        _ direction: GridMoveDirection,
+        toEdge: Bool,
+        in c: GridSelectionContext
+    ) -> GridCoord {
+        switch direction {
+        case .up:
+            return GridCoord(row: toEdge ? 0 : max(0, cell.row - 1), displayColumn: cell.displayColumn)
+        case .down:
+            return GridCoord(row: toEdge ? c.rowCount - 1 : min(c.rowCount - 1, cell.row + 1), displayColumn: cell.displayColumn)
+        case .left:
+            return GridCoord(row: cell.row, displayColumn: toEdge ? 0 : max(0, cell.displayColumn - 1))
+        case .right:
+            return GridCoord(
+                row: cell.row,
+                displayColumn: toEdge ? c.columnCount - 1 : min(c.columnCount - 1, cell.displayColumn + 1)
+            )
+        }
+    }
+
+    static func toggling(_ cell: GridCoord, in base: GridSelection) -> GridSelection {
+        if base.contains(cell) {
+            return base.removing(cell: cell)
+        }
+        return GridSelection(
+            rectangles: base.rectangles + [GridRect(cell: cell)],
+            activeCell: cell,
+            anchor: cell,
+            columns: base.columns
+        )
+    }
+
+    static func rowRectangles(_ rows: IndexSet, _ c: GridSelectionContext) -> [GridRect] {
+        rows.rangeView.map { GridRect(rows: $0.lowerBound...($0.upperBound - 1), columns: c.allColumns) }
+    }
+
+    static func addingRows(
+        _ rows: ClosedRange<Int>,
+        to base: GridSelection,
+        active: GridCoord,
+        anchor: GridCoord,
+        _ c: GridSelectionContext
+    ) -> GridSelection {
+        GridSelection(
+            rectangles: base.rectangles + [GridRect(rows: rows, columns: c.allColumns)],
+            activeCell: active,
+            anchor: anchor,
+            columns: base.columns
+        )
+    }
+
+    static func togglingRow(_ row: Int, in base: GridSelection, activeColumn: Int, _ c: GridSelectionContext) -> GridSelection {
+        let cell = GridCoord(row: row, displayColumn: activeColumn)
+        guard base.columns(in: row).contains(integersIn: 0..<c.columnCount) else {
+            return addingRows(row...row, to: base, active: cell, anchor: cell, c)
+        }
+        var kept: [GridRect] = []
+        for rect in base.rectangles {
+            guard rect.rows.contains(row) else {
+                kept.append(rect)
+                continue
+            }
+            if rect.rows.lowerBound < row {
+                kept.append(GridRect(rows: rect.rows.lowerBound...(row - 1), columns: rect.columns))
+            }
+            if row < rect.rows.upperBound {
+                kept.append(GridRect(rows: (row + 1)...rect.rows.upperBound, columns: rect.columns))
+            }
+        }
+        guard let last = kept.last else { return .empty }
+        func inside(_ coord: GridCoord?) -> GridCoord? {
+            guard let coord, kept.contains(where: { $0.contains(coord) }) else { return nil }
+            return coord
+        }
+        let active = inside(base.activeCell) ?? topLeft(last)
+        // A picked column lost a row, so it no longer spans the grid.
+        return GridSelection(rectangles: kept, activeCell: active, anchor: inside(base.anchor) ?? active)
+    }
+
+    static func addingColumns(from: Int, to column: Int, in base: GridSelection, _ c: GridSelectionContext) -> GridSelection {
+        let span = min(from, column)...max(from, column)
+        let added = span.filter { !base.columns.contains($0) }
+        return GridSelection(
+            rectangles: base.rectangles + added.map { GridRect(rows: c.allRows, columns: $0...$0) },
+            activeCell: GridCoord(row: 0, displayColumn: column),
+            anchor: GridCoord(row: 0, displayColumn: from),
+            columns: base.columns.union(IndexSet(integersIn: span))
+        )
+    }
+
+    static func removingColumn(_ column: Int, from base: GridSelection, _ c: GridSelectionContext) -> GridSelection {
+        let dropped = GridRect(rows: c.allRows, columns: column...column)
+        let kept = base.rectangles.filter { $0 != dropped }
+        guard let last = kept.last else { return .empty }
+        var markers = base.columns
+        markers.remove(column)
+        let active = topLeft(last)
+        return GridSelection(rectangles: kept, activeCell: active, anchor: active, columns: markers)
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/Engine/GridSelectionSnapshot.swift b/apple/TablePro/Core/DataGrid/Engine/GridSelectionSnapshot.swift
new file mode 100644
index 0000000000..14e8eb047c
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/Engine/GridSelectionSnapshot.swift
@@ -0,0 +1,101 @@
+import Foundation
+
+// GridSelection names display positions; this survives reloads, filters, reorders and remounts.
+struct GridSelectionSnapshot: Equatable {
+    struct Cell: Hashable {
+        let rowID: RowID
+        let columnID: DataGridColumnID
+    }
+
+    var rowIDs: [RowID]
+    var rectangles: [Rectangle]
+    var activeCell: Cell?
+    var anchor: Cell?
+    var pickedColumnIDs: [DataGridColumnID] = []
+    var mode: GridSelection.Mode = .cells
+
+    struct Rectangle: Hashable {
+        let rowIDs: [RowID]
+        let columnIDs: [DataGridColumnID]
+    }
+
+    static let empty = GridSelectionSnapshot(rowIDs: [], rectangles: [], activeCell: nil, anchor: nil)
+
+    var isEmpty: Bool { rowIDs.isEmpty && activeCell == nil }
+
+    // Rows named without rectangles are whole rows.
+    init(rowIDs: [RowID], rectangles: [Rectangle], activeCell: Cell?, anchor: Cell?) {
+        self.rowIDs = rowIDs
+        self.rectangles = rectangles
+        self.activeCell = activeCell
+        self.anchor = anchor
+        self.mode = rectangles.isEmpty && !rowIDs.isEmpty ? .rows : .cells
+    }
+
+    init(
+        _ selection: GridSelection,
+        order: DataGridRowOrder,
+        rows: TableRows,
+        columns: DataGridColumnSet
+    ) {
+        func cell(_ coord: GridCoord?) -> Cell? {
+            guard let coord,
+                  let rowID = order.rowID(at: coord.row, in: rows),
+                  let column = columns.column(at: coord.displayColumn) else { return nil }
+            return Cell(rowID: rowID, columnID: column.id)
+        }
+        self.rowIDs = order.rowIDs(atDisplayIndexes: selection.affectedRows, in: rows)
+        self.rectangles = selection.rectangles.map { rect in
+            Rectangle(
+                rowIDs: rect.rows.compactMap { order.rowID(at: $0, in: rows) },
+                columnIDs: rect.columns.compactMap { columns.column(at: $0)?.id }
+            )
+        }
+        self.activeCell = cell(selection.activeCell)
+        self.anchor = cell(selection.anchor)
+        self.pickedColumnIDs = selection.columns.compactMap { columns.column(at: $0)?.id }
+        self.mode = selection.mode
+    }
+
+    func resolved(order: DataGridRowOrder, rows: TableRows, columns: DataGridColumnSet) -> GridSelection {
+        func coord(_ cell: Cell?) -> GridCoord? {
+            guard let cell,
+                  let row = order.displayIndex(of: cell.rowID, in: rows),
+                  let column = columns.displayPosition(of: cell.columnID) else { return nil }
+            return GridCoord(row: row, displayColumn: column)
+        }
+        var resolvedRects: [GridRect] = []
+        // Rows span every column the grid presents later too, a column added or shown included.
+        if mode != .cells {
+            if !columns.isEmpty {
+                let all = 0...(columns.count - 1)
+                for range in order.displayIndexes(of: rowIDs, in: rows).rangeView {
+                    resolvedRects.append(GridRect(rows: range.lowerBound...(range.upperBound - 1), columns: all))
+                }
+            }
+        } else {
+            // Rows and columns that are no longer next to each other split the block, so no cell joins it.
+            for rectangle in rectangles {
+                let displayRows = order.displayIndexes(of: rectangle.rowIDs, in: rows)
+                let displayColumns = IndexSet(rectangle.columnIDs.compactMap { columns.displayPosition(of: $0) })
+                for rowRun in displayRows.rangeView {
+                    for columnRun in displayColumns.rangeView {
+                        resolvedRects.append(GridRect(
+                            rows: rowRun.lowerBound...(rowRun.upperBound - 1),
+                            columns: columnRun.lowerBound...(columnRun.upperBound - 1)
+                        ))
+                    }
+                }
+            }
+        }
+        let active = coord(activeCell)
+            ?? resolvedRects.first.map { GridCoord(row: $0.rows.lowerBound, displayColumn: $0.columns.lowerBound) }
+        return GridSelection(
+            rectangles: resolvedRects,
+            activeCell: active,
+            anchor: coord(anchor) ?? active,
+            columns: IndexSet(pickedColumnIDs.compactMap { columns.displayPosition(of: $0) }),
+            mode: mode
+        )
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/GridFindState.swift b/apple/TablePro/Core/DataGrid/GridFindState.swift
new file mode 100644
index 0000000000..955e70e629
--- /dev/null
+++ b/apple/TablePro/Core/DataGrid/GridFindState.swift
@@ -0,0 +1,129 @@
+import Combine
+import Foundation
+
+@MainActor
+final class GridFindState: ObservableObject {
+    struct Options: Equatable {
+        var matchesCase = false
+        var matchesWholeWord = false
+        var usesRegularExpression = false
+        var columnScope: DataGridColumnID?
+    }
+
+    struct Match: Hashable {
+        let rowID: RowID
+        let columnID: DataGridColumnID
+    }
+
+    @Published var isVisible = false
+    @Published var showsReplace = false
+    @Published var term = ""
+    @Published var replacement = ""
+    @Published var options = Options()
+    @Published private(set) var matches: [Match] = []
+    @Published private(set) var currentIndex: Int?
+    @Published private(set) var problem: String?
+    @Published private(set) var isSearching = false
+    // The user stopped a whole-dataset search before it finished.
+    @Published private(set) var searchStopped = false
+
+    weak var datasetFinder: (any DataGridDatasetFinding)?
+    private(set) var datasetQuery: GridDatasetFindQuery?
+    private(set) var datasetSearch: Task<Void, Never>?
+    private var datasetGeneration = 0
+
+    var currentMatch: Match? {
+        guard let currentIndex, matches.indices.contains(currentIndex) else { return nil }
+        return matches[currentIndex]
+    }
+
+    func setResults(_ matches: [Match], current: Int?, problem: String?) {
+        self.matches = matches
+        self.currentIndex = current.flatMap { matches.indices.contains($0) ? $0 : nil }
+        self.problem = problem
+    }
+
+    func setCurrentIndex(_ index: Int?) {
+        currentIndex = index.flatMap { matches.indices.contains($0) ? $0 : nil }
+    }
+
+    // The next match takes the removed one's place, wrapping to the first.
+    func removeMatch(at index: Int) {
+        guard matches.indices.contains(index) else { return }
+        matches.remove(at: index)
+        currentIndex = matches.isEmpty ? nil : (index < matches.count ? index : 0)
+    }
+
+    func reset() {
+        cancelDatasetSearch()
+        datasetQuery = nil
+        searchStopped = false
+        term = ""
+        replacement = ""
+        matches = []
+        currentIndex = nil
+        problem = nil
+    }
+
+    // MARK: - Whole-dataset search
+
+    // The search hands this generation back when it finishes; any later start or cancel makes it stale.
+    func beginDatasetSearch(_ query: GridDatasetFindQuery?, clearsResults: Bool) -> Int {
+        cancelDatasetSearch()
+        datasetQuery = query
+        searchStopped = false
+        problem = nil
+        if clearsResults {
+            matches = []
+            currentIndex = nil
+        }
+        return datasetGeneration
+    }
+
+    func attachDatasetSearch(_ task: Task<Void, Never>, generation: Int) {
+        guard generation == datasetGeneration else {
+            task.cancel()
+            return
+        }
+        datasetSearch = task
+        isSearching = true
+    }
+
+    // A change the owner reports waits for the owner to finish it; a later change replaces the wait.
+    func deferDatasetSearch(_ task: Task<Void, Never>) {
+        datasetSearch?.cancel()
+        datasetGeneration &+= 1
+        datasetSearch = task
+    }
+
+    func isCurrentDatasetSearch(_ generation: Int) -> Bool {
+        generation == datasetGeneration
+    }
+
+    func finishDatasetSearch(_ found: [Match], current: Int?, generation: Int) {
+        guard generation == datasetGeneration else { return }
+        datasetSearch = nil
+        isSearching = false
+        setResults(found, current: current, problem: nil)
+    }
+
+    func abandonDatasetSearch(generation: Int) {
+        guard generation == datasetGeneration else { return }
+        datasetSearch = nil
+        isSearching = false
+        searchStopped = true
+    }
+
+    func stopDatasetSearch() {
+        guard datasetSearch != nil else { return }
+        cancelDatasetSearch()
+        searchStopped = true
+    }
+
+    func cancelDatasetSearch() {
+        datasetSearch?.cancel()
+        datasetSearch = nil
+        datasetGeneration &+= 1
+        isSearching = false
+    }
+}
diff --git a/apple/TablePro/Core/DataGrid/GridViewportResolver.swift b/apple/TablePro/Core/DataGrid/GridViewportResolver.swift
index f148d718b2..91dd9d2d77 100644
--- a/apple/TablePro/Core/DataGrid/GridViewportResolver.swift
+++ b/apple/TablePro/Core/DataGrid/GridViewportResolver.swift
@@ -15,7 +15,7 @@ internal struct GridViewportSnapshot: Equatable {
 
     static let top = GridViewportSnapshot(firstVisiblePosition: 0, firstVisibleOffset: 0, firstVisibleKey: nil)
 
-    /// The selection alone, for a re-read that starts at the first row but keeps what is selected.
+    // For a re-read that starts at the first row but keeps what is selected.
     var selectionOnly: GridViewportSnapshot {
         GridViewportSnapshot(firstVisiblePosition: 0, firstVisibleOffset: 0, firstVisibleKey: nil, selectedKeys: selectedKeys)
     }
@@ -65,8 +65,9 @@ internal enum GridViewportResolver {
         isCellModified: (RowID, Int) -> Bool = { _, _ in false }
     ) -> GridViewportSnapshot {
         let isKeyed = !keyColumns.isEmpty && tableRows.count <= keyedRowLimit
+        let order = DataGridRowOrder(filteredIDs: displayIDs, revision: 0)
         func key(_ displayRow: Int) -> [String: String]? {
-            DisplayRowMapping.row(forDisplay: displayRow, displayIDs: displayIDs, in: tableRows)
+            order.row(at: displayRow, in: tableRows)
                 .flatMap { savedKey(of: $0, in: tableRows, keyColumns: keyColumns, isCellModified: isCellModified) }
         }
         return GridViewportSnapshot(
@@ -139,7 +140,7 @@ internal enum GridViewportResolver {
             )
         }
 
-        /// The snapshot counted display positions, which a value filter makes differ from storage.
+        // The snapshot counted display positions, which a value filter makes differ from storage.
         let shown = displayIDs ?? incoming.rows.map(\.id)
         guard !shown.isEmpty else { return .firstRow }
         let position = min(snapshot.firstVisiblePosition, shown.count - 1)
@@ -151,8 +152,7 @@ internal enum GridViewportResolver {
         )
     }
 
-    /// One pass over the incoming rows, so restoring a large selection does not rescan them per row.
-    /// A key that repeats matches nothing, as in `uniqueRow(matching:in:)`.
+    // One pass, so a large selection does not rescan per row; a repeated key matches nothing, as in uniqueRow(matching:in:).
     private static func rows(
         matching keys: [[String: String]],
         in incoming: TableRows,
diff --git a/apple/TablePro/Core/Menu/EditMenuBuilder.swift b/apple/TablePro/Core/Menu/EditMenuBuilder.swift
index 92defe5812..f2b61bf80c 100644
--- a/apple/TablePro/Core/Menu/EditMenuBuilder.swift
+++ b/apple/TablePro/Core/Menu/EditMenuBuilder.swift
@@ -5,14 +5,13 @@
 
 import AppKit
 
-/// Start Dictation and Emoji & Symbols are omitted on purpose: the system appends
-/// them to the Edit menu itself.
+// Start Dictation and Emoji & Symbols are omitted on purpose: the system appends them to the Edit menu itself.
 @MainActor
 enum EditMenuBuilder {
-    /// Retained for the menu's lifetime, which is the app's: `NSMenu.delegate` is unowned.
+    // Retained for the app's lifetime: `NSMenu.delegate` is unowned.
     private static let delegate = EditMenuDelegate()
 
-    /// A key of its own: French names this menu "Édition" but an Edit button "Modifier".
+    // A key of its own: French names this menu "Édition" but an Edit button "Modifier".
     static var title: String {
         String(localized: "menu.edit", defaultValue: "Edit", comment: "The Edit menu in the menu bar")
     }
@@ -95,10 +94,7 @@ enum EditMenuBuilder {
                 action: #selector(MainSplitViewController.insertDocument(_:))
             ),
             MenuItemFactory.separator,
-            /// Not Undo, and deliberately not next to it. Undo takes back an edit the user has not
-            /// saved yet and costs nothing; this one writes to the database, needs review and can
-            /// be refused. The HIG scopes Undo to the current document's content, and every Apple
-            /// reversal of something already committed is a separate, named command.
+            // Not Undo, and not next to it: this writes to the database and can be refused; the HIG scopes Undo to uncommitted content.
             MenuItemFactory.item(
                 String(localized: "Restore Previous Values…"),
                 action: #selector(MainSplitViewController.restorePreviousValues(_:)),
@@ -132,19 +128,19 @@ enum EditMenuBuilder {
             MenuItemFactory.separator,
             MenuItemFactory.item(
                 String(localized: "Copy Rows"),
-                action: #selector(MainSplitViewController.copySelectedRows(_:)),
+                action: #selector(GridRowCopyCommandResponding.copySelectedRows(_:)),
                 shortcut: .copyRowsExplicit,
                 keyboard: keyboard
             ),
             MenuItemFactory.item(
                 String(localized: "Copy with Headers"),
-                action: #selector(MainSplitViewController.copyRowsWithHeaders(_:)),
+                action: #selector(GridRowCopyCommandResponding.copyRowsWithHeaders(_:)),
                 shortcut: .copyWithHeaders,
                 keyboard: keyboard
             ),
             MenuItemFactory.item(
                 String(localized: "Copy as JSON"),
-                action: #selector(MainSplitViewController.copyRowsAsJson(_:)),
+                action: #selector(GridRowCopyCommandResponding.copyRowsAsJson(_:)),
                 shortcut: .copyAsJson,
                 keyboard: keyboard
             ),
diff --git a/apple/TablePro/Core/Menu/GridCopyCommandResponding.swift b/apple/TablePro/Core/Menu/GridCopyCommandResponding.swift
index 817306eb56..e293cc1eb9 100644
--- a/apple/TablePro/Core/Menu/GridCopyCommandResponding.swift
+++ b/apple/TablePro/Core/Menu/GridCopyCommandResponding.swift
@@ -16,3 +16,11 @@ import AppKit
     func copyRowsAsInsertStatements(_ sender: Any?)
     func copyRowsAsUpdateStatements(_ sender: Any?)
 }
+
+// Copy Rows, Copy with Headers and Copy as JSON. A focused grid answers for its own selection in any window.
+@MainActor
+@objc protocol GridRowCopyCommandResponding {
+    func copySelectedRows(_ sender: Any?)
+    func copyRowsWithHeaders(_ sender: Any?)
+    func copyRowsAsJson(_ sender: Any?)
+}
diff --git a/apple/TablePro/Core/Scripting/ScriptingSnapshot.swift b/apple/TablePro/Core/Scripting/ScriptingSnapshot.swift
index 4adc66e8e4..fb798aa997 100644
--- a/apple/TablePro/Core/Scripting/ScriptingSnapshot.swift
+++ b/apple/TablePro/Core/Scripting/ScriptingSnapshot.swift
@@ -6,14 +6,7 @@
 import AppKit
 import Foundation
 
-/// Reads live app state into the value objects a script sees.
-///
-/// The scriptable objects stay dumb on purpose: they hold strings and codes, and every question that
-/// needs the running app is answered here. That keeps one place to check when asking what a script
-/// can see, which for a database client is the question that matters.
-///
-/// A connection whose **External Clients** level is Blocked is not listed at all, so a script cannot
-/// discover its name, host or database. `ExternalConnectionDirectory` drops it, the same list MCP reads.
+// The one place a script's view of the app is decided. A Blocked External Clients connection is dropped, the same list MCP reads.
 @MainActor
 internal enum ScriptingSnapshot {
     // MARK: - Connections
@@ -26,14 +19,7 @@ internal enum ScriptingSnapshot {
         connections().first { $0.connectionId == id }
     }
 
-    /// Whether a script may see this connection at all.
-    ///
-    /// Asked again on every path that can reach a connection without having resolved it through
-    /// `connections()` first. `current tab` is the one that can: it starts from the front window,
-    /// not from the element list, so without this a Blocked connection on screen would hand a script
-    /// its tab and, through the tab, its rows.
-    /// Read from storage rather than from the session, because nothing reconciles the level onto a
-    /// live session, and a connection deleted while its session is still up is not visible at all.
+    // Rechecked on paths that skip `connections()` (current tab). Read from storage: nothing syncs the level onto a live session.
     internal static func isVisibleToScripts(connectionId: UUID) -> Bool {
         guard let stored = ConnectionStorage.shared.loadConnections().first(where: { $0.id == connectionId })
         else {
@@ -42,8 +28,6 @@ internal enum ScriptingSnapshot {
         return stored.externalAccess != .blocked
     }
 
-    /// The connection the frontmost window is showing, which is what an unqualified script means by
-    /// "the one I am looking at".
     internal static func currentConnection() -> ScriptConnection? {
         guard let id = frontmostCoordinator()?.connectionId else { return nil }
         return connection(withId: id)
@@ -76,12 +60,7 @@ internal enum ScriptingSnapshot {
         )
     }
 
-    /// Waits for a table tab to appear after asking for it to be opened.
-    ///
-    /// Opening a tab runs through window creation and a connect, neither of which the router waits
-    /// on, so a command that returned immediately would hand the script a reference to nothing. The
-    /// deadline is what turns a connection that never opens into an error the script can catch
-    /// rather than a wait that only ends at AppleScript's own two-minute timeout.
+    // The router doesn't wait on window creation or connect; the deadline beats AppleScript's two-minute timeout with a catchable error.
     internal static func awaitTab(
         connectionId: UUID,
         tableName: String,
@@ -103,10 +82,7 @@ internal enum ScriptingSnapshot {
         return nil
     }
 
-    /// The table name alone is not an identity. Another database or schema on the same connection
-    /// can have a table of the same name already open, and returning that one hands the script a
-    /// reference to rows it did not ask for. A database or schema the script left out means the one
-    /// being browsed, which is where the open put the tab, not any of them.
+    // Name alone isn't identity: a same-named table in another database or schema may be open. Omitted parts mean the browsed one.
     private static func matches(
         _ tab: ScriptTab,
         tableName: String,
@@ -148,10 +124,7 @@ internal enum ScriptingSnapshot {
 
     // MARK: - Results
 
-    /// The rows a tab is showing, or only the ones selected in its grid.
-    ///
-    /// Selection indices are display positions, not indices into the row buffer, so they are
-    /// resolved through `DisplayedResultReader` rather than used to subscript anything.
+    // Selection indices are display positions, so they resolve through `DisplayedResultReader` and never subscript the buffer.
     internal static func result(
         ofTab tabId: UUID,
         connectionId: UUID,
@@ -164,24 +137,15 @@ internal enum ScriptingSnapshot {
             return ScriptResultEncoder.empty()
         }
 
-        /// The live grid only answers for the tab it is mounted in, and only while a data grid owns
-        /// its selection: in Structure or Chart mode those indices belong to the schema grid or are
-        /// left over from the last data grid, and applying them to the row buffer returns unrelated
-        /// rows. Every other tab's selection is the one persisted on the tab itself.
+        // Each data tab's model keeps its own selection, mounted or not, so every tab answers for itself.
         let isSelectedTab = coordinator.tabManager.selectedTabId == tabId
-        let ownsLiveSelection = isSelectedTab && GridSelectionOwner.resolve(
-            tabType: tab.tabType,
-            resultsViewMode: tab.display.resultsViewMode
-        ) == .dataGrid
-        let selected = selectedOnly
-            ? (ownsLiveSelection ? coordinator.selectionState.indices : tab.selectedDisplayRows)
-            : []
+        let selection = coordinator.existingGridModel(forTab: tabId)?.selection.affectedRows ?? IndexSet()
+        let selected = selectedOnly ? Set(selection) : []
         if selectedOnly, selected.isEmpty {
             return ScriptResultEncoder.empty()
         }
 
-        /// A row marked for deletion is still in the buffer and is deliberately not in the result the
-        /// grid is showing, so it is not in what a script reads either.
+        // A row marked for deletion stays in the buffer but not in the grid's result, so a script doesn't read it either.
         let deleted = isSelectedTab
             ? coordinator.changeManager.deletedRowIDs
             : tab.pendingChanges.deletedRowIDs
@@ -223,10 +187,7 @@ internal enum ScriptingSnapshot {
         }
     }
 
-    /// One window hosts several connections, so every one of their coordinators reports the same
-    /// `contentWindow` and picking the first match returns an arbitrary one. `coordinator(forWindow:)`
-    /// asks the window which workspace it is showing, which is the only thing "the one I am looking
-    /// at" can mean.
+    // One window hosts several connections that share `contentWindow`; `coordinator(forWindow:)` asks which workspace it shows.
     private static func frontmostCoordinator() -> MainContentCoordinator? {
         for window in [NSApp.keyWindow, NSApp.mainWindow].compactMap({ $0 }) {
             if let match = MainContentCoordinator.coordinator(forWindow: window) {
diff --git a/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+EditMenuActions.swift b/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+EditMenuActions.swift
index 5c18c5f4ba..a44b67e21c 100644
--- a/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+EditMenuActions.swift
+++ b/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+EditMenuActions.swift
@@ -5,15 +5,10 @@
 
 import AppKit
 
-/// `undo:`, `redo:`, `copy:`, `paste:` and `delete:` are declared here only as the fallback a
-/// window reaches when no more specific responder claimed them. The SQL editor's
-/// text view and the data grid implement the same selectors and sit closer to the
-/// first responder, so AppKit stops there first.
-///
-/// `paste:` has to be one of them. AppKit disables a menu item that no responder in the chain
-/// implements, and a disabled item still owns its key equivalent, so with focus anywhere that
-/// does not paste (the sidebar, the workspace rail, a toolbar control) Command+V was swallowed
-/// for the whole window with nothing to explain it.
+// The main window answers Copy Rows, Copy with Headers and Copy as JSON for a grid that does not have focus.
+extension MainSplitViewController: GridRowCopyCommandResponding {}
+
+// Fallback responders; paste: must be here, or AppKit disables Paste and the disabled item swallows Cmd+V window-wide.
 extension MainSplitViewController {
     @objc func undo(_ sender: Any?) {
         commandActions?.undoChange()
@@ -57,12 +52,7 @@ extension MainSplitViewController {
         NSApp.sendAction(#selector(NSResponder.cancelOperation(_:)), to: nil, from: nil)
     }
 
-    /// One Find command, and the responder chain decides what finding means. A focused editor declares
-    /// the same selectors on its own `TextViewController`, closer to the first responder, so it searches
-    /// its own text without this class knowing which editor is focused. Reaching here means no editor
-    /// holds focus: an active table result grid filters its rows, and every other view hands the find
-    /// to the editor the window is built around, so Cmd+F still reaches the query text while the grid
-    /// or sidebar has focus.
+    // Reached when no editor or grid has focus: a table tab's grid finds, else the window's editor, so sidebar Cmd+F works.
     @objc func performFind(_ sender: Any?) {
         guard commandActions?.canUseTableResultCommands == true else {
             EditorEventRouter.shared.showFindPanelForKeyWindow()
@@ -71,14 +61,21 @@ extension MainSplitViewController {
         commandActions?.showFindBar()
     }
 
-    /// Find and Replace and Use Selection for Find are the editor's alone: the result grid's find bar
-    /// has no replacement field, and a selected cell is a value rather than a search term.
+    // The grid's find bar has a replacement field and reads a selected cell as a term, so both follow Find.
     @objc func performFindAndReplace(_ sender: Any?) {
-        EditorEventRouter.shared.showFindAndReplacePanelForKeyWindow()
+        guard commandActions?.canUseTableResultCommands == true else {
+            EditorEventRouter.shared.showFindAndReplacePanelForKeyWindow()
+            return
+        }
+        commandActions?.showFindBar(replace: true)
     }
 
     @objc func useSelectionForFind(_ sender: Any?) {
-        EditorEventRouter.shared.useSelectionForFindInKeyWindow()
+        guard menuValidationContext.usesGridSelectionForFind else {
+            EditorEventRouter.shared.useSelectionForFindInKeyWindow()
+            return
+        }
+        commandActions?.useGridSelectionForFind()
     }
 
     @objc func findNext(_ sender: Any?) {
diff --git a/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+MenuValidation.swift b/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+MenuValidation.swift
index 98e7d2f74d..94cef339a1 100644
--- a/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+MenuValidation.swift
+++ b/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+MenuValidation.swift
@@ -5,120 +5,85 @@
 
 import AppKit
 
-/// Everything the menu bar needs to decide whether a command applies, captured once
-/// per validation pass. Keeping it a plain value keeps `isEnabled` pure and testable,
-/// the same split `ToolbarContextResolver` uses for the toolbar.
+// A plain value keeps `isEnabled` pure and testable, the same split `ToolbarContextResolver` uses for the toolbar.
 struct MenuValidationContext: Equatable {
-    /// Comes from the window's own `ConnectionWindowPhase`, never from the presence of a
-    /// coordinator: the coordinator deliberately outlives a lost session so a reconnect keeps
-    /// the user's tabs, which made every connection-scoped command stay lit while dialing.
-    /// True whenever the window is showing a connection, connected or not, so a pane that
-    /// failed to dial can still be dismissed.
+    // True for any connection on screen, connected or not, so a pane that failed to dial can still be dismissed.
     var hasSelectedWorkspace = false
+    // From `ConnectionWindowPhase`, not the coordinator, which outlives a lost session and kept commands lit while dialing.
     var isConnected = false
-    /// Whether the connection on screen is showing its agent rather than its objects. The session
-    /// commands are the rail's, and the rail is only there in Agent mode.
+    // Session commands belong to the rail, which only Agent mode shows.
     var isAgentMode = false
-    /// The session a session command acts on: the one its menu item names, or the one the rail has
-    /// highlighted. Nil when there is none, which is what dims Open, Close and Delete Session.
+    // The session the menu item names, else the rail's highlighted one; nil dims Open, Close and Delete Session.
     var agentSessionTarget: AgentSessionStatus?
-    /// Whether the connection on screen has an assistant conversation for its three commands to act
-    /// on. False until something opens the assistant, and false with the AI feature off, which is
-    /// what the pane's own menu already says by dimming the same three.
+    // False until the assistant is opened, and with AI off, matching how the pane's own menu dims the same three.
     var hasAssistantConversation = false
-    /// Whether any conversation has been stored, which is what Conversation History lists and what
-    /// Clear Recents throws away. Separate from the one above: a conversation started and never sent
-    /// in has a model and nothing to switch to.
+    // Separate from `hasAssistantConversation`: a conversation started and never sent has a model and nothing to switch to.
     var hasStoredConversations = false
     var isReadOnly = false
     var canUseTableResultCommands = false
     var canUseGridFindCommands = false
-    /// Jump to Column reads the mounted data grid, so it needs one on screen with columns to list.
     var canJumpToColumn = false
-    /// Each Focus command names a pane, so each needs that pane to exist and to hold a view that can
-    /// take the keyboard. A command that focuses nothing is a command that should be dimmed.
     var canFocusObjectList = false
     var canFocusEditor = false
     var canFocusResults = false
     var canFocusInspector = false
     var canFocusAssistant = false
     var canPresentHighlightRules = false
-    /// Save As writes the selected tab's SQL, so it needs a query tab and not merely a connection.
     var isQueryTab = false
-    /// Export Results exports the selected tab's rows, so an empty grid has nothing to offer.
     var hasResultRows = false
     var canExportDataDictionary = false
     var isCurrentTabEditable = false
-    /// Add Row and Duplicate Row stage `DEFAULT` for every column the server fills in, which only
-    /// the table's own schema names. Until it lands, the result set's own metadata reports far less,
-    /// and an identity column would be staged as NULL that the server refuses.
+    // Add and Duplicate Row stage DEFAULT from the table schema; result metadata alone stages NULL the server refuses for identity.
     var isCurrentTabSchemaResolved = false
     var canRestorePreviousValues = false
-    /// Insert Document writes a whole document, which only an engine that stores documents offers,
-    /// on a collection tab with no staged grid edits.
     var canInsertDocument = false
-    /// Edit Document also needs exactly one selected row that the driver can find its document by.
     var canEditDocument = false
     var isQueryExecuting = false
-    /// Whether Stop still has something to act on. A batch whose `COMMIT` is on the wire is
-    /// executing and unstoppable at the same time, and `Cmd+.` must dim rather than fire into it.
+    // A batch whose COMMIT is on the wire is executing yet unstoppable, and Cmd+. must dim rather than fire into it.
     var isQueryStoppable = false
     var hasQueryText = false
     var canRunAIQueryActions = false
     var canClearQuery = false
     var canClearResults = false
     var hasPendingChanges = false
+    // Save commits an edit still open in the grid before it looks for changes.
+    var hasOpenGridEdit = false
     var hasDataPendingChanges = false
     var hasRowSelection = false
-    /// Copy with headers and copy as JSON read the result grid's columns, so they need the data
-    /// grid's selection specifically, not the structure grid's.
+    // Copy with headers and Copy as JSON read the data grid's columns, so the structure grid's selection does not count.
     var hasDataGridRowSelection = false
     var hasTableSelection = false
-    /// Whether every selected object is one the engine can truncate. Separate from
-    /// `hasTableSelection` because a view is a perfectly good selection and a hopeless truncate.
+    // Separate from `hasTableSelection`: a view is a valid selection but cannot be truncated.
     var canTruncateSelectedTables = false
-    /// Whether every selected object is one the engine has a drop statement for. An engine with
-    /// no DDL for it must not be offered Delete, or the app invents SQL it cannot run.
+    // An engine with no drop DDL for the object must not offer Delete, or the app invents SQL it cannot run.
     var canDropSelectedTables = false
-    /// An editable tab only answers Delete when a row is selected. Without the row check the item
-    /// stayed enabled over a grid with no selection, fell through to the sidebar's drop path and
-    /// did nothing there.
+    // Without the row check Delete stayed lit with no selection and fell through to the sidebar's drop path, doing nothing.
     var canDeleteSelectedRows: Bool { isCurrentTabEditable && hasRowSelection }
-    /// Whether the window-level `paste:` fallback would actually paste. AppKit hands a disabled
-    /// item its key equivalent regardless, so an item enabled over a handler that returns at its
-    /// first guard swallows Command+V with no feedback.
+    // AppKit sends the key equivalent anyway, so enabling over a handler that bails at its first guard swallows Cmd+V silently.
     var canPasteRows = false
     var canCloseOtherTabs = false
     var canCloseTabsForOtherDatabases = false
     var canCloseAllTabs = false
     var canPinEditorTab = false
     var canMoveTabToConnection = false
-    /// How many editor tabs the connection on screen has open.
     var editorTabCount = 0
-    /// The tab a Select Tab item names, read off the item being validated. Nil when the item is not
-    /// one of them.
+    // Read off the Select Tab item being validated; nil for any other item.
     var requestedTabNumber: Int?
-    /// Whether the connections this window can show hold two tabs between them, which is the least
-    /// Control-Tab needs to switch anywhere.
+    // Two tabs across the connections this window can show, the least Control-Tab needs to switch anywhere.
     var hasRecentTabToSwitchTo = false
-    /// Whether the window sits in a window tab group, where Control-Tab falls back to switching the
-    /// window's tabs when there is no editor tab to switch to.
+    // Control-Tab falls back to switching the window's tabs when there is no editor tab to switch to.
     var hasOtherWindowTabs = false
     var canPinResultTab = false
     var canCompareResult = false
-    /// The selected tab's browse history. Separate flags rather than one, because Back and Forward
-    /// run out independently and an item that is disabled has to say which one it is.
+    // Separate flags: Back and Forward run out independently and a disabled item has to say which one it is.
     var canNavigateBack = false
     var canNavigateForward = false
-    /// First, Previous, Next and Last Page, which an engine that cannot skip rows never offers.
+    // An engine that cannot skip rows never offers the page commands.
     var canNavigatePages = false
     var canSaveAsFavorite = false
     var canSwitchSidebarLayout = false
     var canToggleWorkspaceRail = false
-    /// Whether the connection's driver is holding an operating-system resource it can hand back
-    /// without ending the session. Only the embedded engines that lock their database file answer
-    /// yes, so the command is absent for every server-backed connection rather than present and
-    /// disabled: a command that can never apply to a connection is not a command it is missing.
+    // Only embedded engines that lock their database file answer yes, so server connections never show the command at all.
     var canReleaseFileLock = false
     var canShowTableStructure = false
     var canEditViewDefinition = false
@@ -150,10 +115,9 @@ struct MenuValidationContext: Equatable {
     var supportsServerDashboard = false
     var supportsUserManagement = false
     var supportsSchemaSwitching = false
-    /// Whether the engine declares an EXPLAIN variant. Read through the same rule the editor bar
-    /// uses, so the menu item cannot run a statement the bar's button refuses to.
+    // Same rule as the editor bar, so the menu cannot run a statement the bar's button refuses.
     var supportsExplain = false
-    /// Whether the engine's query language has a formatter, the rule the editor bar's Format button uses.
+    // Same rule as the editor bar's Format button.
     var supportsFormatting = false
     var hasSessionContexts = false
     var canFilterDatabases = false
@@ -161,26 +125,15 @@ struct MenuValidationContext: Equatable {
     var hasDatabaseFilter = false
     var canFilterSchemas = false
     var hasSchemaFilter = false
+
+    // The validation and the window's handler both read it, so a lit Use Selection for Find never lands on an editor with no selection.
+    var usesGridSelectionForFind: Bool {
+        !hasSelectionForFind && isConnected && canUseGridFindCommands && hasDataGridRowSelection
+    }
 }
 
 extension MainSplitViewController: NSMenuItemValidation {
-    /// A command that reaches the database carries `isConnected` even when it already has a
-    /// selection or tab condition of its own. Those conditions are not a substitute for it: a
-    /// window that is not connected shows the connecting or unavailable pane with its sidebar and
-    /// inspector collapsed, while the coordinator keeps the last tab and selection it saw so a
-    /// reconnect can restore them. Without it, Truncate Table and Delete stay lit over an error
-    /// screen, pointed at a session that is gone.
-    ///
-    /// This runs only when the window's content view controller is the responder that claimed the
-    /// selector, so a command a nearer responder implements is answered by that responder instead and
-    /// never reaches here. The Find commands rely on that: a focused editor claims and validates them
-    /// itself, so `hasEditorForFind` only ever decides the unfocused fallback.
-    /// What this window has to say about a command, or nil when the command is not its to decide.
-    ///
-    /// Nil is the whole point. A menu item whose selector this controller implements and that has no
-    /// arm here is a command that stays enabled over a window that cannot run it, and the suite is
-    /// green either way: that shipped as Clear Selection, lit on a window with nothing selected and
-    /// nothing to clear. `MenuValidationCoverageTests` reads the nil to say so.
+    // Nil: not this window's call. An unhandled selector stays lit (Clear Selection did); MenuValidationCoverageTests catches it.
     static func resolvedEnablement(_ selector: Selector, context: MenuValidationContext) -> Bool? {
         if context.isAgentMode, browseContentSelectors.contains(selector) { return false }
         if let find = isFindCommandEnabled(selector, context: context) { return find }
@@ -197,14 +150,14 @@ extension MainSplitViewController: NSMenuItemValidation {
              #selector(showNextResult(_:)),
              #selector(closeResultTab(_:)),
              #selector(focusSidebarFilter(_:)),
-             #selector(showERDiagram(_:)),
-             #selector(previewFKReference(_:)):
+             #selector(showERDiagram(_:)):
             return context.isConnected
 
-        /// Each of these moves the selection of a strip, so each needs one on screen, which Agent mode
-        /// does not show, with a tab for the command to reach. Left on `isConnected` alone they
-        /// changed the selected tab behind the conversation, and did nothing at all with one tab or
-        /// for a number past the last tab.
+        // The focused data grid answers and validates this itself; reaching the window means no grid has focus.
+        case #selector(previewFKReference(_:)):
+            return false
+
+        // Agent mode hides the tab strip; on `isConnected` alone these switched tabs behind the conversation or did nothing.
         case #selector(selectNumberedTab(_:)):
             guard context.isConnected, !context.isAgentMode, context.editorTabCount > 1 else { return false }
             guard let number = context.requestedTabNumber else { return true }
@@ -217,7 +170,7 @@ extension MainSplitViewController: NSMenuItemValidation {
             return context.isConnected && context.canNavigatePages
 
         case #selector(saveDocument(_:)):
-            return context.isConnected && !context.isReadOnly && context.hasPendingChanges
+            return context.isConnected && !context.isReadOnly && (context.hasPendingChanges || context.hasOpenGridEdit)
         case #selector(saveDocumentAs(_:)):
             return context.isConnected && context.isQueryTab
         case #selector(exportQueryResults(_:)):
@@ -226,17 +179,12 @@ extension MainSplitViewController: NSMenuItemValidation {
         case #selector(exportDataDictionary(_:)):
             return context.isConnected && context.canExportDataDictionary
 
-        /// AppKit validated New Tab for free while it was its own selector.
-        /// `NSWindow.validateUserInterfaceItem` only speaks to the native ones, so this is
-        /// ours to enable and disable now. Close went back to `performClose:`, which every
-        /// window validates for itself.
+        // `NSWindow.validateUserInterfaceItem` only validates native selectors, so New Tab is ours to enable.
         case #selector(newEditorTab(_:)):
             return context.isConnected
         case #selector(closeConnection(_:)):
             return context.hasSelectedWorkspace
-        /// Not `isConnected`, unlike the rest of the Database menu. The switcher lists the app's
-        /// open connections and the user's saved ones, needs nothing from the session, and is the
-        /// command that leaves a connection that has stopped working.
+        // Not `isConnected`: the switcher needs nothing from the session and is how the user leaves a connection that stopped working.
         case #selector(switchConnection(_:)):
             return context.hasSelectedWorkspace
         case #selector(selectNextEditorTab(_:)), #selector(selectPreviousEditorTab(_:)):
@@ -261,18 +209,13 @@ extension MainSplitViewController: NSMenuItemValidation {
         case #selector(restoreDatabase(_:)):
             return context.isConnected && context.supportsRestore && !context.isReadOnly
 
-        /// Reachable while the connection is still dialling: agent mode draws the prompt the user
-        /// typed, which is exactly what they are waiting with, so gating on `isConnected` would make
-        /// the command dead in the one state it is most wanted.
+        // Not `isConnected`: Agent mode shows the typed prompt while dialling, the state this command is most wanted in.
         case #selector(setContentModeFromMenu(_:)),
              #selector(toggleContentModeFromMenu(_:)):
             return context.hasSelectedWorkspace && AppSettingsManager.shared.ai.enabled
         case #selector(previewSQL(_:)):
             return context.isConnected && context.hasDataPendingChanges
-        /// The results pane belongs to the query editor. The shipped rule was `isConnected` alone,
-        /// so the command was lit on the seven kinds that have no results pane and `toggleResults`
-        /// then wrote a collapse flag with no tab-kind guard behind it. This is the rule the
-        /// toolbar's own item answers by.
+        // Only query tabs have a results pane; `isConnected` alone lit it on seven kinds and wrote an unguarded collapse flag.
         case #selector(toggleResults(_:)):
             return context.isConnected && context.isQueryTab
 
@@ -356,12 +299,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// What the window is pointed at inside the connection: which database, which schema, which
-    /// session context, and which databases the tree shows at all. Each is a chooser the driver may
-    /// not offer, so each follows its own capability rather than the session alone.
-    ///
-    /// Answered before the main switch rather than inside it, because that switch is at its length
-    /// limit and this is a domain of its own.
+    // Outside the main switch, which is at its length limit; each chooser follows its own driver capability.
     private static func isContainerCommandEnabled(
         _ selector: Selector,
         context: MenuValidationContext
@@ -388,8 +326,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// The Database menu's creation commands, which the sidebar's add button also sends through the
-    /// responder chain. New Folder records local state only, so read-only does not dim it.
+    // The sidebar's add button sends these too. New Folder records local state only, so read-only does not dim it.
     private static func isCreationCommandEnabled(
         _ selector: Selector,
         context: MenuValidationContext
@@ -412,12 +349,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// The commands the window answers for itself rather than on behalf of the connection it shows.
-    ///
-    /// Each Focus command follows the pane it names, so one that would focus nothing is dimmed
-    /// rather than silently doing nothing: `makeFirstResponder` accepts a view that cannot take the
-    /// keyboard and reports success. Agent mode's session commands are the window's own too, and are
-    /// answered by the helper below rather than inline, because this switch is at its length limit.
+    // A Focus command that would focus nothing is dimmed: `makeFirstResponder` accepts a view that cannot take the keyboard.
     private static func isWindowCommandEnabled(_ selector: Selector, context: MenuValidationContext) -> Bool? {
         switch selector {
         case #selector(toggleWorkspaceRail(_:)),
@@ -431,21 +363,17 @@ extension MainSplitViewController: NSMenuItemValidation {
         case #selector(focusInspector(_:)): return context.canFocusInspector
         case #selector(focusAssistant(_:)): return context.canFocusAssistant
 
-        /// Not `isConnected`: the SQL text is what moves, so a source that lost its connection can
-        /// still hand it over.
+        // Not `isConnected`: the SQL text is what moves, so a source that lost its connection can still hand it over.
         case #selector(moveTabToConnection(_:)): return context.canMoveTabToConnection
 
-        /// Escape clears the selection wherever one is, so the command needs a window showing a
-        /// connection and something that can hold a selection, not merely a window.
+        // Needs a connection on screen, which is what can hold a selection, not merely a window.
         case #selector(clearSelection(_:)): return context.isConnected
 
         default: return isAgentSessionCommandEnabled(selector, context: context)
         }
     }
 
-    /// Agent mode's session commands, which need the rail on screen and, New Session apart, a session
-    /// to act on. None of them needs a live connection: the rail stands in every phase, a session
-    /// outlives the connection's, and a conversation is worth reading with the database down.
+    // No live connection needed: the rail stands in every phase and a session outlives its connection.
     private static func isAgentSessionCommandEnabled(
         _ selector: Selector,
         context: MenuValidationContext
@@ -462,13 +390,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// The assistant's three conversation commands, which answer in both modes: the conversation is
-    /// one thing shown two ways, in the trailing pane while browsing and in the content column in
-    /// Agent mode, so a command that acts on it applies wherever it is drawn.
-    ///
-    /// Each needs the assistant to have been opened, because that is what creates the model they
-    /// write to. Switching and clearing need a stored conversation on top of that, which is the same
-    /// pair of conditions the pane header's own menu is dimmed by.
+    // Answers in both modes (one conversation, two surfaces), dimmed on the same conditions as the pane header's menu.
     private static func isConversationCommandEnabled(
         _ selector: Selector,
         context: MenuValidationContext
@@ -483,24 +405,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// The commands that act on the browse content, which Agent mode does not mount.
-    ///
-    /// Every one of them but the two document commands and Move Tab to Connection has a toolbar twin
-    /// whose `ToolbarContextResolver` arm answers no in Agent mode, and the menu bar is where most of them
-    /// now live, so leaving them lit here would be the same defect one surface deeper: Refresh over a
-    /// grid that is not there, Save over a commit gate frozen at the moment the mode changed, Command Y
-    /// flipping a persisted flag for a drawer that is not mounted, and New Tab opening a tab behind
-    /// the conversation. The document commands live on the Edit menu and on the grid's row menu, and
-    /// the row menu goes away with the grid, so the Edit menu is their only route in Agent mode, where
-    /// the coordinator still holds the row the user last selected.
-    ///
-    /// A set rather than an arm each, because the rule is one rule. `MenuContentModeParityTests`
-    /// holds the two surfaces' answers together and derives this list back out of the toolbar, so a
-    /// browse-only item added there without an entry here fails rather than ships enabled.
-    ///
-    /// What is deliberately not here: Switch Connection, Close Connection, Safe Mode, the two mode
-    /// commands, the session commands and the conversation commands. Each of those acts on the
-    /// window or on the session, both of which Agent mode still has.
+    // Agent mode does not mount browse content. MenuContentModeParityTests derives this set from the toolbar.
     private static let browseContentSelectors: Set<Selector> = [
         #selector(refreshDatabase(_:)),
         #selector(saveDocument(_:)),
@@ -515,9 +420,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         #selector(openQuickSwitcher(_:)),
         #selector(exportTables(_:)),
         #selector(exportDataDictionary(_:)),
-        /// Both spellings of one command: the leaf that takes the driver's first format, and the
-        /// row of the list that names another. One without the other would leave the list live over
-        /// a leaf that is dim.
+        // Both spellings of one command; one without the other leaves the format list live over a dim leaf.
         #selector(importData(_:)),
         #selector(importDataFormat(_:)),
         #selector(showServerDashboard(_:)),
@@ -528,31 +431,25 @@ extension MainSplitViewController: NSMenuItemValidation {
         #selector(buildJoinQuery(_:)),
     ]
 
-    /// What AppKit is told. A command this window does not own is left enabled, which is what keeps
-    /// `performClose:` and the rest of the system's own items working.
+    // A command this window does not own stays enabled, which keeps `performClose:` and the system's own items working.
     static func isEnabled(_ selector: Selector, context: MenuValidationContext) -> Bool {
         resolvedEnablement(selector, context: context) ?? true
     }
 
-    /// The Edit menu's Find commands, which are the window's last-resort answer. A focused editor claims and
-    /// validates them itself, so what these decide is only what happens when nothing nearer took the selector:
-    /// Find falls back to the result grid's find bar, and the two editor-only commands dim.
+    // Fallback only: a focused editor or grid claims and validates Find itself, so this decides the result grid's find bar.
     private static func isFindCommandEnabled(_ selector: Selector, context: MenuValidationContext) -> Bool? {
         switch selector {
-        case #selector(performFind(_:)):
+        case #selector(performFind(_:)), #selector(performFindAndReplace(_:)):
             return context.hasEditorForFind || (context.isConnected && context.canUseGridFindCommands)
         case #selector(findNext(_:)), #selector(findPrevious(_:)):
             return context.hasEditorForFind || context.hasActiveGridFind
-        case #selector(performFindAndReplace(_:)):
-            return context.hasEditorForFind
         case #selector(useSelectionForFind(_:)):
-            return context.hasSelectionForFind
+            return context.hasSelectionForFind || context.usesGridSelectionForFind
         default:
             return nil
         }
     }
 
-    /// The commands that act on the selected tab's editor and the statements in it.
     private static func isQueryCommandEnabled(_ selector: Selector, context: MenuValidationContext) -> Bool? {
         switch selector {
         case #selector(executeQuery(_:)),
@@ -593,9 +490,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// The commands that act on the object selected in the sidebar. They answer on the same facts
-    /// the sidebar's own contextual menu reads, so a command the sidebar omits is dimmed here rather
-    /// than enabled over an object it cannot act on.
+    // Same facts as the sidebar's contextual menu, so a command the sidebar omits is dimmed here too.
     private static func objectCommandIsEnabled(_ selector: Selector, context: MenuValidationContext) -> Bool {
         guard context.isConnected else { return false }
         switch selector {
@@ -618,13 +513,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// The workspace-rail facts come from the window in both branches. They are true of the window,
-    /// not of the connection it happens to be showing, and reading them off a connection that has
-    /// no coordinator left disabled the only menu route to the window's other connections.
-    ///
-    /// Focus Assistant is the window's too. A window opened straight into Agent mode draws the
-    /// conversation in its content column and never mounts the browse content that sets up the
-    /// command actions, so read from them, the one command that reaches its composer was dimmed.
+    // Rail facts and Focus Assistant come from the window: off the connection they dimmed with no coordinator or in Agent mode.
     var menuValidationContext: MenuValidationContext {
         let conversations = assistantConversationModel
         guard let actions = commandActions else {
@@ -672,6 +561,7 @@ extension MainSplitViewController: NSMenuItemValidation {
             canClearQuery: actions.canClearQuery,
             canClearResults: actions.canClearResults,
             hasPendingChanges: actions.hasPendingChanges,
+            hasOpenGridEdit: actions.hasOpenGridEdit,
             hasDataPendingChanges: actions.hasDataPendingChanges,
             hasRowSelection: actions.hasRowSelection,
             hasDataGridRowSelection: actions.hasDataGridRowSelection,
@@ -740,10 +630,7 @@ extension MainSplitViewController: NSMenuItemValidation {
     func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
         applyDynamicTitle(to: menuItem)
         guard let action = menuItem.action else { return false }
-        /// AppKit asks this method for the View menu and `validateUserInterfaceItem` for everything
-        /// else, so a rule that lives in only one of them holds for only half the routes to the
-        /// command. The sidebar is the window's and stands in every phase; the two trailing
-        /// surfaces need a session to open and none to close.
+        // AppKit asks this for the View menu and `validateUserInterfaceItem` for the rest, so a rule must live in both.
         if action == #selector(toggleSidebar(_:)) { return true }
         if action == #selector(toggleInspector(_:)) { return canToggleTrailingPane }
         if action == #selector(toggleAssistant(_:)) { return canToggleAssistant }
@@ -757,14 +644,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         return Self.isEnabled(action, context: menuValidationContext(naming: menuItem))
     }
 
-    /// The window's context, with the session a session command acts on taken from the item rather
-    /// than from the rail: a menu that lists a connection's sessions names one in each of its items,
-    /// and every other route acts on the one the rail has highlighted.
-    ///
-    /// Keyed on the action rather than on the type in `representedObject`. A conversation row carries
-    /// a `UUID` too, and reading that one as a session id resolved a session that does not exist and
-    /// wrote its absence over the rail's own highlight, so a conversation row in an open menu decided
-    /// what the session commands beside it reported.
+    // Keyed on the action, not the `representedObject` type: a conversation row's UUID was read as a session id.
     private func menuValidationContext(naming menuItem: NSMenuItem) -> MenuValidationContext {
         var context = menuValidationContext
         guard let action = menuItem.action else { return context }
@@ -776,8 +656,7 @@ extension MainSplitViewController: NSMenuItemValidation {
         return context
     }
 
-    /// The commands whose subject is a session, and the only ones that may read a session id out of
-    /// a menu item.
+    // The only selectors that may read a session id out of a menu item.
     private static let agentSessionSelectors: Set<Selector> = [
         #selector(openAgentSession(_:)),
         #selector(closeAgentSession(_:)),
@@ -790,17 +669,13 @@ extension MainSplitViewController: NSMenuItemValidation {
         return contentMode == mode
     }
 
-    /// Assigning a title or state that has not changed still posts an item-changed notification,
-    /// which makes an open menu re-lay-out and cancel tracking. Validation runs on every menu
-    /// update, so the writes have to be conditional or the menu bar flickers and a click on an
-    /// item dismisses the menu instead of firing it.
+    // Write only on change: any title or state write re-lays out an open menu and cancels tracking, so a click dismissed it.
     private func applyDynamicTitle(to menuItem: NSMenuItem) {
         guard let action = menuItem.action else { return }
         switch action {
         case #selector(toggleSidebar(_:)):
             setTitle(isSidebarCollapsed ? "Show Sidebar" : "Hide Sidebar", on: menuItem)
-        /// Both read the surface the pane is drawing, so in Agent mode the pane toggle names the
-        /// result column it opens and closes instead of offering to hide an inspector nobody sees.
+        // In Agent mode the pane toggle names the result column instead of an inspector nobody sees.
         case #selector(toggleInspector(_:)):
             setResolvedTitle(TrailingPaneCommandResolver.paneToggleTitle(trailingPaneCommandContext), on: menuItem)
         case #selector(toggleAssistant(_:)):
@@ -838,9 +713,7 @@ extension MainSplitViewController: NSMenuItemValidation {
                 commandActions?.openContainerSwitcherTitle ?? String(localized: "Open Database…"),
                 on: menuItem
             )
-        /// The driver names this one, because what it gives back differs: DuckDB's file lock is
-        /// not a server's connection slot. The fallback is what the disabled item reads as for
-        /// every connection that holds nothing.
+        // Driver-named because what it releases differs (DuckDB's file lock is not a server slot).
         case #selector(releaseFileLock(_:)):
             setResolvedTitle(
                 ConnectionFileLockAction.commandTitle(connectionId: workspaces.selectedConnectionId)
@@ -864,17 +737,14 @@ extension MainSplitViewController: NSMenuItemValidation {
         }
     }
 
-    /// The item carries its mode in `representedObject`, so enablement has to see the item rather
-    /// than the selector the shared table keys on.
+    // The mode is in `representedObject`, so enablement needs the item, not the selector the shared table keys on.
     private func canShowResultView(_ menuItem: NSMenuItem) -> Bool {
         guard let raw = menuItem.representedObject as? String,
               let mode = ResultsViewMode(rawValue: raw) else { return false }
         return commandActions?.availableResultsViewModes.contains(mode) ?? false
     }
 
-    /// Read through the same status the list is built from, so an entry the floor rules out cannot
-    /// validate as a choice. The connection's own floor is blind to Agent mode, and asking it enabled
-    /// a weaker level the write would then hold at Alert.
+    // Uses the status the list is built from: the connection's own floor is blind to Agent mode and enabled a level held at Alert.
     private func canChooseSafeModeLevel(_ menuItem: NSMenuItem) -> Bool {
         guard isConnected,
               let raw = menuItem.representedObject as? String,
diff --git a/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+QueryMenuActions.swift b/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+QueryMenuActions.swift
index c622b24fec..fa38a3ed6b 100644
--- a/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+QueryMenuActions.swift
+++ b/apple/TablePro/Core/Services/Infrastructure/MainSplitViewController+QueryMenuActions.swift
@@ -74,9 +74,8 @@ extension MainSplitViewController {
         commandActions?.clearResults()
     }
 
-    @objc func previewFKReference(_ sender: Any?) {
-        commandActions?.previewFKReference()
-    }
+    // Declared for the menu item; the focused data grid implements the same selector closer to the first responder.
+    @objc func previewFKReference(_ sender: Any?) {}
 
     @objc func goToFirstPage(_ sender: Any?) {
         commandActions?.goToFirstPage()
diff --git a/apple/TablePro/Core/Services/Query/RowOperationsManager.swift b/apple/TablePro/Core/Services/Query/RowOperationsManager.swift
index f062f9c749..2d6592b141 100644
--- a/apple/TablePro/Core/Services/Query/RowOperationsManager.swift
+++ b/apple/TablePro/Core/Services/Query/RowOperationsManager.swift
@@ -13,7 +13,7 @@ final class RowOperationsManager {
         let rowID: RowID
         let values: [PluginCellValue]
         let delta: Delta
-        /// Key columns given a fresh UUID, which the caret skips.
+        // Key columns given a fresh UUID, which the caret skips.
         var prefilledColumns: Set<Int> = []
     }
 
@@ -35,7 +35,7 @@ final class RowOperationsManager {
     }
 
     struct UndoApplicationResult {
-        let adjustedSelection: Set<Int>?
+        let clearsSelection: Bool
         let delta: Delta
     }
 
@@ -45,12 +45,7 @@ final class RowOperationsManager {
         self.changeManager = changeManager
     }
 
-    /// A new row holds DEFAULT where the server assigns the value and NULL elsewhere. On an engine
-    /// that tells a missing field from NULL those other fields start missing instead, so a document
-    /// saved as it was added holds only what the user typed.
-    ///
-    /// `uuidKeyForms` are the UUID keys the server does not fill, by column. Each gets a fresh UUID, since NULL
-    /// there is a key the INSERT is refused for.
+    // On engines that tell missing from NULL, non-default fields start missing; unfilled UUID keys get a fresh UUID, not NULL.
     func addNewRow(tableRows: inout TableRows, uuidKeyForms: [Int: UUIDCellForm] = [:]) -> AddNewRowResult? {
         var newRowValues: [PluginCellValue] = []
         var absentColumns: Set<Int> = []
@@ -71,7 +66,7 @@ final class RowOperationsManager {
         )
     }
 
-    /// A pending source row keeps the SQL staged in it, so a copy of `now()` is `now()` again, not the text.
+    // A pending source row keeps its staged SQL, so a copy of now() is now() again, not the text.
     func duplicateRow(
         sourceRowIndex: Int,
         tableRows: inout TableRows,
@@ -85,8 +80,7 @@ final class RowOperationsManager {
         var expressionColumns = changeManager.expressionColumns(forRow: source.id).filter { $0 < newValues.count }
         var prefilled: Set<Int> = []
 
-        /// An identity column is not always the primary key, and copying its value verbatim is
-        /// what the server rejects.
+        // An identity column isn't always the primary key, and the server rejects a copied identity value.
         let resetColumns = changeManager.primaryKeyColumns
             + Array(tableRows.generatedColumns)
             + Array(tableRows.columnIdentity.keys)
@@ -130,24 +124,23 @@ final class RowOperationsManager {
         return AddNewRowResult(rowID: rowID, values: values, delta: delta, prefilledColumns: prefilledColumns)
     }
 
-    func deleteSelectedRows(
-        selectedIndices: Set<Int>,
-        displayIDs: [RowID]? = nil,
+    // `selectedDisplayIndices` and `displayCount` only place the row selected afterwards.
+    func deleteRows(
+        _ rowIDs: [RowID],
+        selectedDisplayIndices: Set<Int>,
+        displayCount displayCountBefore: Int,
         tableRows: inout TableRows
     ) -> DeleteRowsResult {
-        guard !selectedIndices.isEmpty else {
+        guard !rowIDs.isEmpty else {
             return DeleteRowsResult(nextRowToSelect: -1, physicallyRemovedIndices: [], delta: .none)
         }
 
-        let displayCountBefore = displayIDs?.count ?? tableRows.count
         var insertedRowsToRemove: [InsertedRowLocation] = []
         var existingRowsToDelete: [(rowID: RowID, originalRow: [PluginCellValue])] = []
         var deletedAbsentColumns: [RowID: Set<Int>] = [:]
 
-        for displayIndex in selectedIndices.sorted(by: >) {
-            guard let storageIndex = DisplayRowMapping.rowIndex(
-                forDisplay: displayIndex, displayIDs: displayIDs, in: tableRows
-            ) else { continue }
+        let storageIndices = Set(rowIDs.compactMap { tableRows.index(of: $0) })
+        for storageIndex in storageIndices.sorted(by: >) {
             let row = tableRows.rows[storageIndex]
             if row.id.isInserted {
                 insertedRowsToRemove.append(InsertedRowLocation(rowID: row.id, storageIndex: storageIndex))
@@ -171,7 +164,7 @@ final class RowOperationsManager {
 
         return DeleteRowsResult(
             nextRowToSelect: Self.nextRowToSelect(
-                afterDeleting: selectedIndices,
+                afterDeleting: selectedDisplayIndices,
                 removedCount: insertedRowsToRemove.count,
                 displayCountAfter: displayCountBefore - insertedRowsToRemove.count
             ),
@@ -201,20 +194,20 @@ final class RowOperationsManager {
         switch result.action {
         case .cellEdit(let rowID, let columnIndex, _, let previousValue, _, _, let absence, _):
             guard let storageRow = tableRows.index(of: rowID) else {
-                return UndoApplicationResult(adjustedSelection: nil, delta: .none)
+                return UndoApplicationResult(clearsSelection: false, delta: .none)
             }
             let delta = tableRows.edit(
                 row: storageRow, column: columnIndex, value: previousValue, isAbsent: absence.wasAbsent
             )
-            return UndoApplicationResult(adjustedSelection: nil, delta: delta)
+            return UndoApplicationResult(clearsSelection: false, delta: delta)
 
         case .rowInsertion(let rowID, _):
             if result.needsRowRemoval {
                 let delta = tableRows.remove(rowIDs: [rowID])
                 guard delta != .none else {
-                    return UndoApplicationResult(adjustedSelection: nil, delta: .none)
+                    return UndoApplicationResult(clearsSelection: false, delta: .none)
                 }
-                return UndoApplicationResult(adjustedSelection: Set<Int>(), delta: delta)
+                return UndoApplicationResult(clearsSelection: true, delta: delta)
             }
             if result.needsRowRestore {
                 let values = result.restoreRow
@@ -222,27 +215,27 @@ final class RowOperationsManager {
                 let delta = tableRows.appendInsertedRow(
                     id: rowID, values: values, absentColumns: result.restoreAbsentColumns
                 )
-                return UndoApplicationResult(adjustedSelection: nil, delta: delta)
+                return UndoApplicationResult(clearsSelection: false, delta: delta)
             }
-            return UndoApplicationResult(adjustedSelection: nil, delta: .none)
+            return UndoApplicationResult(clearsSelection: false, delta: .none)
 
         case .rowDeletion, .batchRowDeletion:
-            return UndoApplicationResult(adjustedSelection: nil, delta: result.delta)
+            return UndoApplicationResult(clearsSelection: false, delta: result.delta)
 
         case .batchRowInsertion(let rows, let rowValues, let rowAbsentColumns, _):
             if result.needsRowRemoval {
                 let delta = tableRows.remove(rowIDs: Set(rows.map(\.rowID)))
-                return UndoApplicationResult(adjustedSelection: nil, delta: delta)
+                return UndoApplicationResult(clearsSelection: false, delta: delta)
             }
             if result.needsRowRestore {
                 return UndoApplicationResult(
-                    adjustedSelection: nil,
+                    clearsSelection: false,
                     delta: restoreInsertedRows(
                         rows, values: rowValues, absentColumns: rowAbsentColumns, into: &tableRows
                     )
                 )
             }
-            return UndoApplicationResult(adjustedSelection: nil, delta: .none)
+            return UndoApplicationResult(clearsSelection: false, delta: .none)
         }
     }
 
@@ -268,17 +261,16 @@ final class RowOperationsManager {
         return insertedIndices.isEmpty ? .none : .rowsInserted(insertedIndices)
     }
 
-    func copySelectedRowsToClipboard(
-        selectedIndices: Set<Int>,
+    // `rowIDs` come in the order the grid shows them.
+    func copyRowsToClipboard(
+        _ rowIDs: [RowID],
         tableRows: TableRows,
-        displayIDs: [RowID]? = nil,
         includeHeaders: Bool = false,
         visibleColumnIndices: [Int]? = nil
     ) {
-        guard !selectedIndices.isEmpty else { return }
+        guard !rowIDs.isEmpty else { return }
 
-        let sortedIndices = selectedIndices.sorted()
-        let totalSelected = sortedIndices.count
+        let totalSelected = rowIDs.count
         let isTruncated = totalSelected > Self.maxClipboardRows
 
         if isTruncated {
@@ -287,15 +279,15 @@ final class RowOperationsManager {
             )
         }
 
-        let indicesToCopy = isTruncated ? Array(sortedIndices.prefix(Self.maxClipboardRows)) : sortedIndices
+        let idsToCopy = isTruncated ? Array(rowIDs.prefix(Self.maxClipboardRows)) : rowIDs
 
         let projection = VisibleColumnProjection(indices: visibleColumnIndices)
         let columns = projection.columns(tableRows.columns)
         let estimatedRowLength = max(columns.count, 1) * 12
         var result = ""
-        result.reserveCapacity(indicesToCopy.count * estimatedRowLength)
+        result.reserveCapacity(idsToCopy.count * estimatedRowLength)
         var copiedRows: [Row] = []
-        copiedRows.reserveCapacity(indicesToCopy.count)
+        copiedRows.reserveCapacity(idsToCopy.count)
 
         if includeHeaders, !columns.isEmpty {
             for (colIdx, col) in columns.enumerated() {
@@ -304,9 +296,8 @@ final class RowOperationsManager {
             }
         }
 
-        for displayIndex in indicesToCopy {
-            guard let row = DisplayRowMapping.row(forDisplay: displayIndex, displayIDs: displayIDs, in: tableRows)
-            else { continue }
+        for rowID in idsToCopy {
+            guard let row = tableRows.row(withID: rowID) else { continue }
             if !result.isEmpty { result.append("\n") }
             copiedRows.append(row)
             for (colIdx, cell) in projection.values(Array(row.values)).enumerated() {
@@ -387,8 +378,7 @@ final class RowOperationsManager {
         }
     }
 
-    /// Copied rows keep the fields they did not have, and a column the copy did not carry is a
-    /// field the pasted row does not have either, on an engine that tells that apart from NULL.
+    // On engines that tell missing from NULL, a column the copy didn't carry is a field the pasted row lacks too.
     private static func reconcileStructuredRows(
         _ payload: GridRowsClipboardPayload,
         schema: TableSchema,
@@ -428,9 +418,7 @@ final class RowOperationsManager {
         }
     }
 
-    /// Cells the grid copied, as wide as the table, become rows field by field, so a value holding a
-    /// tab or a line break stays one value and a NULL stays NULL. An empty field is read for its
-    /// column, as a typed one is, and a field the copy marked as SQL stays SQL.
+    // Field by field, so a value holding a tab or line break stays one value, NULL stays NULL and SQL stays SQL.
     private static func rows(
         fromCopiedCells cells: GridCellsClipboardPayload,
         schema: TableSchema,
@@ -455,8 +443,7 @@ final class RowOperationsManager {
         }
     }
 
-    /// Text says nothing about which fields a row lacks, so on an engine that tells a missing field
-    /// from NULL a pasted NULL leaves the field out, which is what a new row does with it too.
+    // Text can't say which fields a row lacks, so a pasted NULL leaves the field out, as a new row does.
     private static func nullsAsMissingFields(_ row: ParsedRow) -> ParsedRow {
         var missing = row
         missing.absentColumns = Set(row.values.indices.filter { row.values[$0].isNull })
@@ -493,8 +480,7 @@ final class RowOperationsManager {
         return containsComma ? CSVRowParser() : TSVRowParser()
     }
 
-    /// Every paste path resets the key to `__DEFAULT__` before it gets here. A UUID key the server does not
-    /// fill takes a fresh UUID in its place, one per row.
+    // Every paste path resets the key to __DEFAULT__ first; an unfilled UUID key then takes a fresh UUID per row.
     private func insertParsedRows(
         _ parsedRows: [ParsedRow],
         uuidKeyForms: [Int: UUIDCellForm],
@@ -503,9 +489,7 @@ final class RowOperationsManager {
         var pastedRowInfo: [PastedRowInfo] = []
         var insertedIndices = IndexSet()
 
-        /// A pasted row arrives whole, so it carries values for columns the server owns too. They
-        /// never reach the cell-edit boundary that refuses them, and the statement generator drops
-        /// them silently, so the grid showed a pasted identity value the row was never saved with.
+        // Pasted server-owned values skip the cell-edit check and the generator drops them, so the grid showed unsaved values.
         let serverOwned = tableRows.columns.enumerated().filter { _, name in
             tableRows.generatedColumns.contains(name) || tableRows.columnIdentity[name] != nil
         }.map(\.offset)
diff --git a/apple/TablePro/Core/Services/Query/SelectionSummaryCalculator.swift b/apple/TablePro/Core/Services/Query/SelectionSummaryCalculator.swift
index 688d76967c..7470c95bb8 100644
--- a/apple/TablePro/Core/Services/Query/SelectionSummaryCalculator.swift
+++ b/apple/TablePro/Core/Services/Query/SelectionSummaryCalculator.swift
@@ -18,7 +18,8 @@ actor SelectionSummaryCalculator {
 
     func summarize(_ input: SelectionSummaryInput) throws(CancellationError) -> SelectionSummary {
         var tally = Tally(input: input)
-        let displayRowCount = input.displayIDs?.count ?? input.tableRows.count
+        let order = DataGridRowOrder(filteredIDs: input.displayIDs, revision: 0)
+        let displayRowCount = order.count(in: input.tableRows)
         var budget = 0
         for band in Self.rowBands(of: input.selection, rowLimit: displayRowCount) {
             let columns = input.selection.columns(in: band.lowerBound).compactMap { position -> BandColumn? in
@@ -33,12 +34,7 @@ actor SelectionSummaryCalculator {
                     budget = Self.cancellationInterval
                 }
                 budget -= columns.count
-                guard let storageIndex = DisplayRowMapping.rowIndex(
-                    forDisplay: displayRow,
-                    displayIDs: input.displayIDs,
-                    in: input.tableRows
-                ) else { continue }
-                let row = input.tableRows.rows[storageIndex]
+                guard let row = order.row(at: displayRow, in: input.tableRows) else { continue }
                 guard !input.deletedRowIDs.contains(row.id) else { continue }
                 for column in columns {
                     tally.add(row[column.dataIndex], column: column.dataIndex, rule: column.rule, rowID: row.id)
@@ -48,8 +44,7 @@ actor SelectionSummaryCalculator {
         return tally.summary(coversWholeColumn: !input.selection.columns.isEmpty)
     }
 
-    /// Every rectangle's row bounds are breakpoints, so the rectangles covering a band are the same
-    /// on each of its rows: one column union per band counts an overlapped cell once.
+    // Rectangle row bounds are breakpoints, so one column union per band counts an overlapped cell once.
     static func rowBands(of selection: GridSelection, rowLimit: Int) -> [Range<Int>] {
         guard rowLimit > 0 else { return [] }
         var bounds = Set<Int>()
@@ -106,16 +101,14 @@ private struct Tally {
         }
     }
 
-    /// The accumulator trims only ASCII blanks. Column Statistics also takes a number padded with
-    /// other Unicode spaces, and the two must agree on the same cells.
+    // The accumulator trims only ASCII blanks; Column Statistics takes other Unicode spaces too, and both must agree.
     private mutating func addNumber(_ text: String) -> Bool {
         if numbers.add(text) { return true }
         guard !text.utf8.allSatisfy({ $0 < 0x80 }) else { return false }
         return numbers.add(text.trimmingCharacters(in: .whitespaces))
     }
 
-    /// The default marker is the grid's own placeholder only where an edit put it; anywhere else
-    /// it is text the table holds.
+    // The default marker is the grid's placeholder only where an edit put it; elsewhere it is text the table holds.
     private func isEmpty(_ text: String, column: Int, rowID: RowID) -> Bool {
         if text.isEmpty { return emptyTextIsEmpty }
         guard text.utf8.count == Self.defaultMarkerLength, text == PluginCellValue.defaultMarkerText else {
diff --git a/apple/TablePro/Core/Utilities/SQL/DisplayedResultReader.swift b/apple/TablePro/Core/Utilities/SQL/DisplayedResultReader.swift
index fb178a7eaf..869817eb65 100644
--- a/apple/TablePro/Core/Utilities/SQL/DisplayedResultReader.swift
+++ b/apple/TablePro/Core/Utilities/SQL/DisplayedResultReader.swift
@@ -6,26 +6,16 @@
 import Foundation
 import TableProPluginKit
 
-/// The rows a result tab is showing, in the order it is showing them.
-///
-/// Anything that reads a result outside the grid itself has to answer the same three questions, and
-/// get all three right: display positions are not storage indices once a value filter is on, hidden
-/// and reordered columns are the reader's business too, and a row marked for deletion is in the
-/// buffer but not in the result. `ResultJsonSerializer` answered them for JSON; AppleScript needs
-/// the same answers as values, so they live here and JSON is one encoding of the output.
+// Filtered display order, hidden and moved columns, no deleted rows: JSON and AppleScript read results through here.
 internal enum DisplayedResultReader {
     internal struct Output {
         internal let columns: [String]
         internal let columnTypes: [ColumnType]
         internal let rows: [[PluginCellValue]]
-        /// How many rows were left out because they are marked for deletion.
         internal let skippedDeletedCount: Int
     }
 
-    /// - Parameter selectedDisplayIndices: display positions to narrow to. Empty means every
-    ///   displayed row, which is what an untouched result set shows.
-    /// - Parameter deletedRowIDs: rows marked for deletion but not yet saved.
-    ///   Empty, the default, reads every row.
+    // Empty selectedDisplayIndices means every displayed row.
     internal static func read(
         tableRows: TableRows,
         displayIDs: [RowID]?,
@@ -40,11 +30,10 @@ internal enum DisplayedResultReader {
             positions = selectedDisplayIndices.sorted()
         }
 
+        let order = DataGridRowOrder(filteredIDs: displayIDs, revision: 0)
         var skippedDeleted = 0
         let rows: [[PluginCellValue]] = positions.compactMap { displayIndex in
-            guard let row = DisplayRowMapping.row(
-                forDisplay: displayIndex, displayIDs: displayIDs, in: tableRows
-            ) else { return nil }
+            guard let row = order.row(at: displayIndex, in: tableRows) else { return nil }
             guard !deletedRowIDs.contains(row.id) else {
                 skippedDeleted += 1
                 return nil
diff --git a/apple/TablePro/Models/Query/QueryResultPresentation.swift b/apple/TablePro/Models/Query/QueryResultPresentation.swift
index 45b5c5f522..d960d8b15d 100644
--- a/apple/TablePro/Models/Query/QueryResultPresentation.swift
+++ b/apple/TablePro/Models/Query/QueryResultPresentation.swift
@@ -6,18 +6,10 @@
 import Foundation
 import TableProPluginKit
 
-/// What the results pane draws.
-///
-/// One value rather than a nest of conditionals. `MainEditorContentView.resultsSection` used to
-/// decide this inside its own body: a switch over `ResultsViewMode` whose five arms each repeated
-/// the result-set chrome, wrapped around a five-way `if/else if/else` that chose between the
-/// success view, an empty `Spacer`, the no-rows view and the grid. Three of those arms tested
-/// `lastExecutedAt != nil && !isExecuting` with slightly different companions, so the states were
-/// only accidentally exclusive and none of them could be checked without mounting SwiftUI.
+// One value instead of conditionals in the view body, so the states stay exclusive and testable without mounting SwiftUI.
 enum QueryResultContent: Equatable {
-    /// Nothing has run and there is nothing to show.
     case idle
-    /// A fetch is in flight with no loaded buffer to draw under it.
+    // In flight with no loaded buffer to draw under it.
     case executing
     case structure(tableName: String)
     case queryPlan
@@ -25,26 +17,22 @@ enum QueryResultContent: Equatable {
     case map
     case json
     case grid
-    /// Columns came back and no rows did, which is a result rather than an absence.
+    // Columns but no rows: a result, not an absence.
     case noRows(executionTime: TimeInterval?)
-    /// A statement that reports work done rather than rows: INSERT, UPDATE, DDL, and whatever it printed on the
-    /// server, which for a PL/SQL block is usually the point of running it.
+    // INSERT, UPDATE, DDL. The server output is usually the point of running a PL/SQL block.
     case statementSucceeded(
         rowsAffected: Int,
         executionTime: TimeInterval?,
         statusMessage: String?,
         serverOutput: PluginServerOutput
     )
-    /// What a statement that returned rows printed on the server, on its own in Output mode.
+    // What a statement that returned rows printed on the server, shown alone in Output mode.
     case serverOutput(PluginServerOutput)
-    /// The mode draws the loaded buffer and the buffer is empty, so the mode cannot draw.
+    // The mode draws the loaded buffer, and the buffer is empty.
     case unavailable(mode: ResultsViewMode)
 }
 
-/// Everything the results pane needs in order to decide what it is, gathered before any view exists.
-///
-/// A plain struct rather than a `QueryTab`, so the whole state matrix is reachable from a test
-/// without a tab manager, a coordinator or a session registry behind it.
+// A plain struct, not a `QueryTab`, so tests reach every state without a tab manager, coordinator or session registry.
 struct QueryResultInputs: Equatable {
     var tabType: TabType = .query
     var viewMode: ResultsViewMode = .data
@@ -54,14 +42,13 @@ struct QueryResultInputs: Equatable {
     var isExplainResult = false
     var hasActiveResultSet = false
     var resultSetCount = 0
-    /// The active result reported columns. A result with none is a statement that did work.
+    // A result with no columns is a statement that did work.
     var activeResultHasColumns = false
     var activeResultRowsAffected = 0
     var activeResultExecutionTime: TimeInterval?
     var activeResultStatusMessage: String?
     var activeResultServerOutput: PluginServerOutput = .none
-    /// A failed result carries its own message, which outlives the tab's. Pin a failure, run
-    /// something that works, and `executionErrorMessage` is cleared while this one is not.
+    // Outlives the tab's message: pin a failure, run something that works, and only `executionErrorMessage` is cleared.
     var activeResultErrorMessage: String?
     var loadedColumnCount = 0
     var loadedRowCount = 0
@@ -71,25 +58,14 @@ struct QueryResultInputs: Equatable {
     var executionStatusMessage: String?
     var hasAppliedFilters = false
     var isFilterPanelVisible = false
-    var isFindBarVisible = false
 }
 
-/// The whole results pane, resolved from tab state before any view exists.
-///
-/// Pure by design, the way `ResultStatusModel` and `ResultSetPolicy` already are: every branch
-/// the pane can take is decidable from `QueryResultInputs` alone.
+// Pure: every branch is decidable from `QueryResultInputs` alone, like `ResultStatusModel` and `ResultSetPolicy`.
 struct QueryResultPresentation: Equatable {
     let content: QueryResultContent
-    /// The result-set chooser in the status bar. One result needs no chooser, and the structure
-    /// editor is not a result at all.
     let showsResultSetSelector: Bool
     let showsFilterChrome: Bool
-    let showsFindBar: Bool
-    /// Always. A plan used to give the bar up, which was harmless while the deleted strip carried
-    /// the result chooser above it, and would now leave a plan with no way to be switched away from
-    /// or pinned. The plan pane's own chrome is a header, so the bar under it is a footer rather
-    /// than a second header; what the bar gives up for a plan is its row readout, decided in
-    /// `ResultStatusModel` from `StatusBarSnapshot.isQueryPlan`.
+    // Always: a plan without the bar can't be switched away from or pinned. Its row readout hides via `StatusBarSnapshot.isQueryPlan`.
     let showsStatusBar: Bool
     let showsErrorBanner: Bool
 
@@ -97,16 +73,11 @@ struct QueryResultPresentation: Equatable {
         content = Self.resolveContent(inputs)
         showsResultSetSelector = Self.resolvesResultSetSelector(inputs)
         showsFilterChrome = Self.resolvesFilterChrome(inputs)
-        showsFindBar = inputs.isFindBarVisible
-            && inputs.tabType == .table
-            && inputs.viewMode.showsFindBar
         showsStatusBar = true
         showsErrorBanner = Self.resolvedError(inputs) != nil
     }
 
-    /// The error the pane is actually showing. The active result's own message wins, because it
-    /// describes the result on screen; the tab's is the fallback for a failure that produced no
-    /// result set at all.
+    // The active result's message wins since it describes the result on screen; the tab's covers a failure with no result set.
     static func resolvedError(_ inputs: QueryResultInputs) -> String? {
         inputs.activeResultErrorMessage ?? inputs.executionErrorMessage
     }
@@ -119,9 +90,7 @@ struct QueryResultPresentation: Equatable {
 
         if inputs.isExplainResult { return .queryPlan }
 
-        /// A table's grid is its own placeholder, so it stays mounted while the first page loads. A
-        /// retarget empties the buffer before the fetch claims the tab, and dropping the grid there
-        /// blanked the pane for the whole fetch and took the grid's first responder with it.
+        // A table's grid stays mounted while its first page loads: dropping it on a retarget blanked the pane and took first responder.
         if inputs.isExecuting, inputs.loadedColumnCount == 0, !Self.keepsGridWhileLoading(inputs) {
             return .executing
         }
@@ -130,16 +99,12 @@ struct QueryResultPresentation: Equatable {
             return .serverOutput(inputs.activeResultServerOutput)
         }
 
-        /// Ahead of the idle rule below, because these two modes say why they are empty rather
-        /// than going blank: a reader who switched to Chart before running anything is told to run
-        /// something, which is the one thing a blank pane cannot say.
+        // Before the idle rule: Chart and Map say why they are empty, so a reader who switched before running is told to run something.
         if inputs.viewMode == .chart || inputs.viewMode == .map {
             guard inputs.hasActiveResultSet else { return .unavailable(mode: inputs.viewMode) }
         }
 
-        /// A query tab that has never run anything has no result to draw. A table tab does: it
-        /// describes a table whether or not its rows have arrived, which is why the gate names the
-        /// tab type rather than the buffer.
+        // Gated on tab type, not the buffer: a table tab describes its table whether or not its rows have arrived.
         if inputs.tabType == .query,
            !inputs.hasExecuted,
            inputs.loadedColumnCount == 0,
@@ -165,9 +130,7 @@ struct QueryResultPresentation: Equatable {
         }
     }
 
-    /// The three outcomes a finished execution can have that are not a grid of rows. Answered in one
-    /// place so they stay mutually exclusive, which they only were by accident while each arm of the
-    /// old switch retested `hasExecuted && !isExecuting` beside a different companion condition.
+    // One place for the three non-grid outcomes, so they stay mutually exclusive.
     private static func resolveSettledResult(_ inputs: QueryResultInputs) -> QueryResultContent? {
         guard inputs.hasExecuted, !inputs.isExecuting else { return nil }
 
@@ -182,8 +145,7 @@ struct QueryResultPresentation: Equatable {
 
         guard inputs.loadedColumnCount == 0 else { return resolveEmptyRows(inputs) }
         guard resolvedError(inputs) == nil else { return nil }
-        /// A failed table load leaves no result set, and dismissing its banner removes the error, so
-        /// this state is a table that has not loaded rather than a statement that ran.
+        // A failed table load leaves no result set and dismissing its banner clears the error, so this is an unloaded table.
         guard inputs.resultSetCount > 0 else { return inputs.tabType == .table ? nil : .idle }
 
         return .statementSucceeded(
@@ -198,22 +160,14 @@ struct QueryResultPresentation: Equatable {
         inputs.tabType == .table && inputs.viewMode == .data
     }
 
-    /// Columns without rows. A filtered table that filtered everything away keeps the grid, because
-    /// the filter chrome is what the reader needs in order to get their rows back.
+    // A filtered table that filtered everything away keeps the grid: the filter chrome is how the reader gets rows back.
     private static func resolveEmptyRows(_ inputs: QueryResultInputs) -> QueryResultContent? {
         guard inputs.tabType == .query else { return nil }
         guard inputs.loadedRowCount == 0, !inputs.hasAppliedFilters else { return nil }
         return .noRows(executionTime: inputs.activeResultExecutionTime ?? inputs.executionTime)
     }
 
-    /// The same condition the deleted strip used, deliberately.
-    ///
-    /// It would be tempting to hide the chooser at a single result, since its title then says
-    /// nothing the pane does not. But Pin, Unpin and Close live in its menu, and pinning a result
-    /// before re-running is exactly the workflow that matters when there is one result on screen.
-    /// Hiding it there would leave the View menu as the only route to pinning, which is the
-    /// capability the strip existed to offer. The chooser costs no height to keep: it is a control
-    /// inside a bar that is already on screen, which is the whole difference from a 32pt band.
+    // Shown even for one result: Pin, Unpin and Close live in its menu, and it costs no height inside the status bar.
     private static func resolvesResultSetSelector(_ inputs: QueryResultInputs) -> Bool {
         guard inputs.tabType == .query else { return false }
         guard inputs.viewMode != .structure else { return false }
diff --git a/apple/TablePro/Models/Query/QueryTab.swift b/apple/TablePro/Models/Query/QueryTab.swift
index d15a8e9dce..bdcbb9fc3d 100644
--- a/apple/TablePro/Models/Query/QueryTab.swift
+++ b/apple/TablePro/Models/Query/QueryTab.swift
@@ -3,23 +3,17 @@ import Observation
 import os
 import TableProPluginKit
 
-/// `CaseIterable` so the View menu builds its Result View submenu from the case list rather than
-/// from a hand copy of it. Availability per tab is a different question and stays with
-/// `ResultsModeAvailability`, which `CaseIterable` cannot answer.
+// CaseIterable feeds the View menu's Result View submenu; per-tab availability stays with ResultsModeAvailability.
 enum ResultsViewMode: String, CaseIterable, Equatable {
     case data
     case structure
     case json
     case chart
     case map
-    /// What the statement printed on the server, such as Oracle's `DBMS_OUTPUT`. Offered only for a result that
-    /// printed something.
+    // Server output such as Oracle's DBMS_OUTPUT, offered only for a result that printed something.
     case output
 
-    /// How much of the loaded result the mode is showing, and how to load more. A chart draws the
-    /// same buffer the grid does, so it needs the same scope controls: a warning that the chart is
-    /// incomplete is only useful next to the control that completes it. A map draws that same
-    /// buffer, so the same argument puts it here. Output is not drawn from the buffer at all.
+    // Chart and map draw the grid's buffer, so they need its scope controls; Output is not drawn from the buffer.
     var showsResultScope: Bool {
         self != .structure && self != .output
     }
@@ -32,27 +26,17 @@ enum ResultsViewMode: String, CaseIterable, Equatable {
         self == .data || self == .json
     }
 
-    /// Map is deliberately out. A value filter set in Data mode still narrows the map, because the
-    /// map draws the display order rather than the whole buffer, but the filter chrome belongs
-    /// beside the grid it filters.
+    // Map is out on purpose: a Data-mode filter still narrows it, but the filter chrome belongs beside the grid.
     var showsRowFilters: Bool {
         self == .data || self == .json
     }
 
-    /// The find bar reads the data grid's cells through the grid's own coordinator, which exists
-    /// only while the grid is mounted, so it can find nothing in any other mode. JSON mode carries
-    /// its own search inside the tree view.
+    // The find bar searches the mounted grid; JSON mode carries its own search inside the tree view.
     var showsFindBar: Bool {
         self == .data
     }
 
-    /// Whether a row selection means anything in this mode, and so whether the status bar should
-    /// report one.
-    ///
-    /// Deliberately its own question rather than a reuse of `showsColumnControls`, which is about
-    /// column chrome. Map both reads the selection, to highlight the chosen shape, and writes it,
-    /// when a shape is clicked, so a count the bar refuses to print is a count the reader cannot
-    /// see anywhere.
+    // Not showsColumnControls: Map reads and writes the selection, so a count the bar hides is one the reader cannot see.
     var reportsRowSelection: Bool {
         self == .data || self == .json || self == .map
     }
@@ -71,35 +55,13 @@ struct QueryTab: Identifiable, Equatable {
     var display: TabDisplayState
 
     var pendingChanges: TabChangeSnapshot
-    var selectedRowIndices: Set<Int>
-    /// The cell rectangle the reader last had selected, kept for the same reason and in the same
-    /// place as `valueFilter` below.
-    ///
-    /// `selectedRowIndices` cannot stand in for it. `publishRowSelection` projects a rectangle down
-    /// to `affectedRows`, which keeps the rows and discards the columns, and that projection does
-    /// not invert: restoring from it would widen a three-column block into whole rows, and Copy
-    /// would then copy whole rows instead of the block. (#2667)
-    var cellSelection: GridSelection
-    /// The display rows this tab has selected, however the reader selected them.
-    ///
-    /// A cell drag pins `selectedRowIndices` to its anchor row, so the rectangle is the only one of
-    /// the two that knows the whole span. Everything that reinstates a tab's selection reads this
-    /// rather than picking between the two fields itself.
-    var selectedDisplayRows: Set<Int> {
-        cellSelection.isEmpty ? selectedRowIndices : Set(cellSelection.affectedRows)
-    }
+    // The grid's selection by row and column identity, carried when the tab moves to another window.
+    var selectionSnapshot: GridSelectionSnapshot
 
     var sortState: SortState
     var filterState: TabFilterState
-    var findState: TabFindState
     var columnLayout: ColumnLayoutState
-    /// The per-column value filter, which narrows the loaded rows without re-querying.
-    ///
-    /// It belongs to the tab rather than to the grid because it is the only thing that makes the
-    /// displayed order differ from storage order, and every reader of that order has to work while
-    /// the grid is unmounted: JSON mode, the row inspector, and the Edit menu's row commands all
-    /// run with no `DataGridView` in the view tree. Living on the grid's SwiftUI coordinator meant
-    /// switching result mode did not hide the order, it deleted it. (#2251)
+    // On the tab, not the grid: JSON mode, the inspector and the Edit menu's row commands read the order unmounted (#2251).
     var valueFilter: GridValueFilterState
     var sessionHighlightRules: [HighlightRule] = []
     var pagination: PaginationState
@@ -112,42 +74,28 @@ struct QueryTab: Identifiable, Equatable {
     var loadEpoch: Int = 0
 
     var pendingRestoredSort: [PersistedSortColumn]?
-    /// The source the saved sort was written with, held until the first load resolves the columns.
+    // Held until the first load resolves the columns.
     var restoredSortSource: SortSource = .unset
     var restoredPage: Int?
-    /// The page size `restoredPage` was measured in. A page index means nothing without it: the
-    /// offset is recomputed as `(page - 1) * pageSize`, so reading the index in a different size
-    /// lands the tab on rows it was never showing.
+    // A page index means nothing without its size: the offset is (page - 1) * pageSize.
     var restoredPageSize: Int?
     var restoredRowAnchor: [String: String]?
     var restoredCursorOffset: Int?
     var restoredCursorLength: Int?
 
-    /// A statement the reader has asked to be taken to, set when they select the result it produced.
-    ///
-    /// Deliberately not `restoredCursorOffset`. That pair means "the selection this tab was left with, to apply once
-    /// when its editor mounts": the editor refuses it after its services are installed, and the tab-switch capture
-    /// only records a caret while both are nil, so borrowing them would make the second jump do nothing and stop the
-    /// switch capture forever. This is an event on a mounted editor, and it is cleared the moment one consumes it.
-    ///
-    /// An anchor rather than a range, because it is resolved against the editor's own text, which the tab's binding
-    /// can lag behind.
+    // Not restoredCursorOffset, which the editor refuses once mounted; an anchor because the tab's binding can lag the editor.
     var pendingStatementJump: StatementAnchor?
 
-    /// The regions the reader has collapsed in this tab. The editor is a view onto this, not its owner.
+    // The editor is a view onto this, not its owner.
     var collapsedFoldRanges: [Range<Int>]?
 
-    /// A fold range that still fits the query it was recorded against, or `nil` when it does not.
-    ///
-    /// The bounds are checked before the range is formed. A persisted file can hold anything, and `30..<10` traps
-    /// rather than producing an empty range, so a saved pair that arrives inverted would bring the app down on load.
+    // Bounds checked first: a persisted file can hold an inverted pair, and 30..<10 traps instead of forming an empty range.
     private static func foldRange(lower: Int, upper: Int, limit: Int) -> Range<Int>? {
         guard lower >= 0, upper > lower, upper <= limit else { return nil }
         return lower..<upper
     }
 
-    /// Fold ranges survive a round trip as a flat list of bounds. A pair that no longer fits the query is dropped
-    /// rather than replayed onto text that changed while the tab was closed.
+    // A pair that no longer fits the query is dropped, not replayed onto text that changed while the tab was closed.
     private static func clampedFoldRanges(_ bounds: [Int]?, in query: String) -> [Range<Int>]? {
         guard let bounds, bounds.count >= 2 else { return nil }
         let limit = (query as NSString).length
@@ -195,11 +143,9 @@ struct QueryTab: Identifiable, Equatable {
         self.tableContext = TabTableContext(tableName: tableName, isEditable: tabType == .table)
         self.display = TabDisplayState()
         self.pendingChanges = TabChangeSnapshot()
-        self.selectedRowIndices = []
-        self.cellSelection = .empty
+        self.selectionSnapshot = .empty
         self.sortState = SortState()
         self.filterState = TabFilterState()
-        self.findState = TabFindState()
         self.columnLayout = ColumnLayoutState()
         self.valueFilter = GridValueFilterState()
         self.pagination = PaginationState()
@@ -246,16 +192,12 @@ struct QueryTab: Identifiable, Equatable {
             versionHistorySubject: persisted.versionHistorySubject
         )
         self.pendingChanges = TabChangeSnapshot()
-        self.selectedRowIndices = []
-        self.cellSelection = .empty
-        /// A saved sort with no columns is the user's Don't Sort, and it never reaches the pending
-        /// path because there is nothing there to resolve. Seeding the source here is what carries
-        /// it past `wantsDefaultSort` on the first load.
+        self.selectionSnapshot = .empty
+        // Seeding the source carries a saved empty sort (the user's Don't Sort) past wantsDefaultSort on the first load.
         self.sortState = (persisted.sortColumns?.isEmpty ?? true) && persisted.sortSource == .user
             ? SortState(columns: [], source: .user)
             : SortState()
         self.filterState = TabFilterState()
-        self.findState = TabFindState()
         self.columnLayout = ColumnLayoutState(
             columnWidths: persisted.columnWidths ?? [:],
             columnContentWidths: persisted.columnContentWidths
@@ -270,9 +212,7 @@ struct QueryTab: Identifiable, Equatable {
         self.paginationVersion = 0
         self.loadEpoch = 0
         self.pendingRestoredSort = persisted.sortColumns
-        /// A file written before `sortSource` existed carries no answer, so it decodes to the
-        /// behaviour it was written under: saved columns were always the user's, and no saved
-        /// columns meant nothing had decided.
+        // A file from before sortSource decodes to its old behaviour: saved columns were the user's, none meant undecided.
         self.restoredSortSource = persisted.sortSource
             ?? ((persisted.sortColumns?.isEmpty == false) ? .user : .unset)
         let clampedPageSize = persisted.restoredPageSize
@@ -292,12 +232,7 @@ struct QueryTab: Identifiable, Equatable {
         self.collapsedFoldRanges = Self.clampedFoldRanges(persisted.collapsedFoldRanges, in: persisted.query)
     }
 
-    /// A page number counts pages of the size it was taken in, so clamping the size without
-    /// rescaling the page moves the tab by the ratio between the two. A tab saved on page 2 of
-    /// 5,000,000 rows came back as page 2 of 100,000 and opened 4,900,000 rows short of the rows it
-    /// had been showing. Rescale to the page that still holds the first row the tab was on, which is
-    /// the same arithmetic `PaginationState.updatePageSize` does when the user changes the size by
-    /// hand.
+    // Rescale to the page holding the same first row, as PaginationState.updatePageSize does, or the tab lands rows short.
     private static func restoredPage(
         _ page: Int?,
         savedPageSize: Int?,
@@ -309,8 +244,7 @@ struct QueryTab: Identifiable, Equatable {
               savedPageSize != appliedPageSize,
               savedPageSize > 0, appliedPageSize > 0 else { return requested }
 
-        /// Both numbers come off disk, so their product is not trusted to fit. A position that
-        /// cannot be computed is not a position, and the start of the table is the honest answer.
+        // Both numbers come off disk, so an overflowing product falls back to the start of the table.
         let (offset, overflowed) = (requested - 1).multipliedReportingOverflow(by: savedPageSize)
         guard !overflowed else { return 1 }
         return offset / appliedPageSize + 1
@@ -332,8 +266,7 @@ struct QueryTab: Identifiable, Equatable {
             return pluginQuery
         }
 
-        /// Keyed by engine: Elasticsearch, Typesense and Weaviate also highlight as JavaScript and etcd as a
-        /// command line, and none of them runs these. Without their plugin they reach the dialect, which throws.
+        // Keyed by engine: Elasticsearch, Typesense, Weaviate and etcd reach the dialect without their plugin, which throws.
         switch databaseType {
         case .mongodb:
             return "\(MongoCollectionAccessor.expression(for: tableName)).find({}).limit(\(pageSize))"
@@ -368,14 +301,7 @@ struct QueryTab: Identifiable, Equatable {
     func toPersistedTab() -> PersistedTab {
         let persistedQuery = content.query
 
-        // A restored tab holds its saved sort and page in the pending fields until it is selected,
-        // because only the selected tab runs the first load that consumes them. Every save maps
-        // every tab through here, so re-emitting what has not been consumed yet is what keeps an
-        // unactivated tab's view state alive. `cursorOffset` and `columnWidths` already do this.
-        //
-        // The fallback holds only until the tab has actually run. After that the live state is the
-        // truth, and a pending value that outranked it would pin a page the user has since left
-        // with no way to correct it.
+        // Only the selected tab consumes the pending sort and page, so saves re-emit them until it has run; then live state wins.
         let carriesPendingState = tabType == .table && execution.lastExecutedAt == nil
 
         let persistedSort: [PersistedSortColumn]? = {
@@ -383,9 +309,7 @@ struct QueryTab: Identifiable, Equatable {
             guard resolved.isEmpty else { return resolved }
             return carriesPendingState ? pendingRestoredSort : nil
         }()
-        /// Written whatever the columns came to, because the source is the whole answer for an empty
-        /// sort: `.user` with no columns is the user's Don't Sort, and gating it the way the columns
-        /// are gated would drop that the moment the tab had run once.
+        // Written whatever the columns, since .user with no columns is the user's Don't Sort.
         let persistedSortSource: SortSource = {
             if sortState.source != .unset { return sortState.source }
             return carriesPendingState ? restoredSortSource : .unset
diff --git a/apple/TablePro/Models/Query/QueryTabManager.swift b/apple/TablePro/Models/Query/QueryTabManager.swift
index ea17731754..4202f2df36 100644
--- a/apple/TablePro/Models/Query/QueryTabManager.swift
+++ b/apple/TablePro/Models/Query/QueryTabManager.swift
@@ -8,7 +8,6 @@ import Foundation
 import os
 import TableProUtilities
 
-/// Manager for query tabs
 @MainActor
 final class QueryTabManager: ObservableObject {
     @Published var tabs: [QueryTab] = [] {
@@ -25,11 +24,7 @@ final class QueryTabManager: ObservableObject {
         }
     }
 
-    /// Every writer of the selection comes through here, which makes this the one place that sees
-    /// every tab the user switches to: a click in the strip, Command 1 to 9, a new tab, a table
-    /// opened from the sidebar, a reopened tab and the neighbour a close lands on alike. A view
-    /// modifier could not stand in for it, because a connection the window is not showing has its
-    /// views unparented.
+    // Every selection writer lands here; a view modifier can't, as a connection the window isn't showing has no views.
     @Published var selectedTabId: UUID? {
         didSet {
             guard selectedTabId != oldValue else { return }
@@ -39,30 +34,19 @@ final class QueryTabManager: ObservableObject {
         }
     }
 
-    /// What a tab's entry is decided by: the database on an engine that switches databases, the
-    /// schema on one that only switches schemas. Nil where the engine switches neither, and every
-    /// tab is in the connection's one entry.
+    // The database or schema, whichever the engine switches; nil when it switches neither and every tab shares one entry.
     let containerTarget: ContainerSwitchTarget?
 
-    /// The connections-strip entry this window shows: the strip lists only that container's tabs,
-    /// plus the ones that name no container. Nil shows every tab.
-    ///
-    /// A switch never closes a tab, it only changes which entry is in front; the tabs of the others
-    /// are kept and come back with their entry.
+    // The strip lists this container's tabs plus unbound ones (nil: all). Switching entries never closes a tab.
     @Published private(set) var visibleContainer: String?
 
-    /// Told when the selection carried the window into another entry, such as a tab picked from
-    /// the recent-tabs list or rebound to another database, so the connection can browse it too.
+    // Fired when a selection carried the window into another entry, so the connection browses it too.
     var onVisibleContainerReconciled: (() -> Void)?
 
     private(set) var containerTabHistory = ContainerTabHistory()
     private var _visibleTabs: [QueryTab]?
 
-    /// Whether the window shows this connection's tabs, in the key window. The window sets it, for
-    /// every connection it hosts at once. Only then is a selection a tab the user switched to: a
-    /// restore that finishes for a connection in the background selects a tab nobody has seen, and
-    /// recording it would send the next Control-Tab there. Coming to the front records the selected
-    /// tab, because the user is now looking at it.
+    // Only a frontmost selection is recorded: a background restore's tab would otherwise become the next Control-Tab target.
     var isFrontmost = false {
         didSet {
             guard isFrontmost != oldValue else { return }
@@ -74,9 +58,7 @@ final class QueryTabManager: ObservableObject {
 
     var pendingFocusTabId: UUID?
 
-    /// When each open tab was last the selected one, as a sequence number rather than a time, so
-    /// two selections in one run-loop turn still order. The sequence is shared by every tab manager
-    /// so a window hosting several connections can order all of their tabs together.
+    // A shared sequence, not a time: two selections in one turn still order, across every connection in the window.
     private(set) var activationSequence: [UUID: UInt64] = [:]
     private static var lastActivationSequence: UInt64 = 0
     private var activationRecordPending = false
@@ -99,9 +81,7 @@ final class QueryTabManager: ObservableObject {
         self.tabSessionRegistry = tabSessionRegistry
     }
 
-    /// Closing a tab used to mean closing its window, because a tab was a window. Selection
-    /// lands on the tab that took its place in the strip, so the pane never blanks while the entry
-    /// still has tabs. An entry left with none shows its empty state rather than another entry's tab.
+    // Selection lands on the tab that took its strip slot; an entry left empty shows its empty state, not another's tab.
     func closeTab(id: UUID) {
         guard let index = tabs.firstIndex(where: { $0.id == id }) else { return }
         let wasSelected = selectedTab?.id == id
@@ -116,15 +96,7 @@ final class QueryTabManager: ObservableObject {
         selectedTabId = remaining[stripIndex].id
     }
 
-    /// Reorders the strip. A pure permutation: the same tabs, a different order, and the selection
-    /// stays on whichever tab it was on rather than on the position that tab vacated.
-    ///
-    /// `destination` is a position in the strip, which lists one entry's tabs, so the move lands
-    /// beside the strip neighbour it was dropped next to wherever the other entries' tabs sit.
-    ///
-    /// The array is rebuilt and assigned once rather than mutated twice, because `tabs.didSet`
-    /// bumps `tabStructureVersion` and republishes the workspace anchors on every write, and the
-    /// state between a `remove` and an `insert` is a tab list the user never had.
+    // Built and assigned once: each tabs write bumps tabStructureVersion and republishes anchors for a list never shown.
     func moveTab(id: UUID, to destination: Int) {
         let strip = visibleTabs
         guard let source = strip.firstIndex(where: { $0.id == id }) else { return }
@@ -141,8 +113,6 @@ final class QueryTabManager: ObservableObject {
         tabs = reordered
     }
 
-    /// Whether `tab` can move one place in `offset`'s direction, so a menu item can dim instead of
-    /// being offered and doing nothing.
     func canMoveTab(id: UUID, by offset: Int) -> Bool {
         let strip = visibleTabs
         guard let index = strip.firstIndex(where: { $0.id == id }) else { return false }
@@ -160,22 +130,12 @@ final class QueryTabManager: ObservableObject {
         moveTab(id: id, to: index + offset)
     }
 
-    /// Keeps a preview tab, so the next table opened from the sidebar lands in a tab of its own
-    /// instead of replacing this one. The single mutator of `isPreview`: every promotion path,
-    /// the sidebar's, the editor's and the tab strip's, comes through here.
-    ///
-    /// Promotion never reorders. A tab that moves as it is kept would be a different feature,
-    /// which is what pinning is in the editors that offer both.
-    ///
-    /// One way, deliberately. Nothing turns a kept tab back into a preview, so a tab the user
-    /// asked to hold on to cannot be thrown away by a later click.
+    // Sole mutator of isPreview; one way on purpose, so a kept tab can't be thrown away by a later sidebar click.
     func promotePreviewTab(id: UUID) {
         guard let index = tabs.firstIndex(where: { $0.id == id }), tabs[index].isPreview else { return }
         mutate(at: index) { $0.isPreview = false }
     }
 
-    /// Whether keeping this tab would change anything, so a menu item can dim rather than be
-    /// offered and do nothing.
     func canPromotePreviewTab(id: UUID) -> Bool {
         tabs.first { $0.id == id }?.isPreview ?? false
     }
@@ -237,10 +197,7 @@ final class QueryTabManager: ObservableObject {
 
     // MARK: - Recency
 
-    /// The tab is recorded once the turn settles, not at each write. Opening a table into another
-    /// connection brings that connection forward and then selects the new tab in the same turn, so
-    /// the tab it was showing is never drawn; recorded as it passed through, it would be what the
-    /// next Control-Tab went back to.
+    // Recorded once the turn settles: opening into another connection selects twice in one turn, the first never drawn.
     private func scheduleActivationRecord() {
         guard isFrontmost, !activationRecordPending else { return }
         activationRecordPending = true
@@ -273,9 +230,7 @@ final class QueryTabManager: ObservableObject {
         }
     }
 
-    /// The workspace rail lists a container while a tab holds it open, so it reloads when
-    /// that set can have changed. Every other tab mutation, a keystroke above all, leaves
-    /// the anchors identical and publishes nothing.
+    // Publishes only when the set of held-open containers can change; a keystroke leaves the anchors identical.
     private func publishAnchorChange(oldTabs: [QueryTab], newTabs: [QueryTab]) {
         guard WorkspaceAnchoring.anchors(in: oldTabs) != WorkspaceAnchoring.anchors(in: newTabs) else {
             return
@@ -323,7 +278,6 @@ final class QueryTabManager: ObservableObject {
 
     // MARK: - Tab Naming
 
-    /// Next "Query N" title based on existing tabs across all windows.
     static func nextQueryTitle(existingTabs: [QueryTab]) -> String {
         let maxNumber = existingTabs
             .filter { $0.tabType == .query }
@@ -397,27 +351,13 @@ final class QueryTabManager: ObservableObject {
         }
     }
 
-    /// A file that is already open is shown, not reloaded over.
-    ///
-    /// Opening it again is a request to look at it, so the buffer is replaced only when there is
-    /// nothing of the user's in it. A tab with unsaved edits keeps them: `setText` on the editor
-    /// resets its storage, so the replacement was not undoable and nothing asked first. The one
-    /// path that does replace a dirty buffer is the file-changed-on-disk banner, which asks.
-    ///
-    /// The baseline moves with the buffer. Writing the text without it left the tab reading as
-    /// dirty against content it had just loaded, and armed the same banner for a change it had
-    /// already taken.
+    // Shown, not reloaded over: setText isn't undoable, so a dirty buffer is kept. The baseline moves with the text.
     private func adoptReopenedFile(at index: Int, content: String, stamp: FileStamp?, encoding: FileTextEncoding?) {
-        /// An unknown baseline is not a licence to replace what the tab holds. `isFileDirty` reads a
-        /// missing one as clean, so without this a tab that never learned what its file said would
-        /// be overwritten by the very check meant to protect it.
+        // isFileDirty reads a missing baseline as clean, so an unknown baseline must not license overwriting the tab.
         guard tabs[index].content.savedFileContent != nil, !tabs[index].content.isFileDirty else { return }
         FileTabBaseline.adopt(text: content, stamp: stamp, encoding: encoding, into: &tabs[index].content)
     }
 
-    /// Take an already-built tab, such as one rebuilt from the recently closed history, rather than
-    /// minting a fresh one. Selecting it drives the window title, toolbar, and persistence through
-    /// the usual `selectedTabId` observation.
     func adoptTab(_ tab: QueryTab, claimFocus: Bool = false) {
         var tab = tab
         bindToVisibleContainer(&tab)
@@ -437,16 +377,12 @@ final class QueryTabManager: ObservableObject {
         _ isPreview: Bool
     ) -> Void)?
 
-    /// Fired the instant a tab stops being about the table it was about. Whoever owns execution
-    /// listens here rather than at the navigation call sites, because a retarget that forgets to
-    /// invalidate is exactly how a finished query paints its rows into a tab showing something else.
+    // Execution owners listen here, not at call sites: a retarget that skipped invalidation painted stale rows into the tab.
     @Published var onTabRetargeted: ((UUID) -> Void)?
 
     @Published var onTableSchemaResolved: ((_ tableName: String, _ databaseName: String, _ schemaName: String) -> Void)?
 
-    /// `objectType` carries what the object is, where the caller knew it, alongside the `isView`
-    /// the callers that know only that much pass. Whoever records the open needs the kind: a
-    /// MariaDB sequence recorded as "not a table" came back as a view and was offered Drop View.
+    // The recorder needs the kind: a MariaDB sequence recorded as "not a table" came back as a view offering Drop View.
     private func notifyTableOpened(
         tableName: String, schemaName: String?, databaseName: String,
         isView: Bool, objectType: TableInfo.TableType?, isPreview: Bool
@@ -454,9 +390,7 @@ final class QueryTabManager: ObservableObject {
         onTableOpened?(tableName, schemaName, databaseName, isView, objectType, isPreview)
     }
 
-    /// A table tab opened before its schema was known was reported without one, so whoever recorded
-    /// that open learns the schema when the tab does. Otherwise the record keeps naming the table in
-    /// whichever schema is browsed when it is next used.
+    // The open was recorded before the schema was known; without this the record follows whichever schema is browsed.
     func adoptResolvedSchema(_ schemaName: String, at index: Int) {
         guard tabs.indices.contains(index) else { return }
         tabs[index].tableContext.schemaName = schemaName
@@ -464,10 +398,7 @@ final class QueryTabManager: ObservableObject {
         onTableSchemaResolved?(tableName, tabs[index].tableContext.databaseName, schemaName)
     }
 
-    /// The tab already showing this table, preferring the selected one.
-    ///
-    /// A table can legitimately hold more than one tab now, so plain array order would send a
-    /// sidebar click on the table you are already looking at to the other copy of it.
+    // Prefers the selected tab: a table can hold several tabs, and array order sent a sidebar click to the other copy.
     func tabShowingTable(
         named tableName: String, databaseName: String, schemaName: String?, isTemporary: Bool = false
     ) -> QueryTab? {
@@ -482,11 +413,7 @@ final class QueryTabManager: ObservableObject {
         return tabs.first(where: matches)
     }
 
-    /// - Parameter allowsDuplicate: `true` when the caller asked for a tab of its own, so a table
-    ///   that is already open gets a second one instead of the existing tab being reselected.
-    ///   "Open in New Tab" means what it says only if this reaches here.
-    /// - Returns: `true` when a tab was created, `false` when an existing one was reselected.
-    ///   Callers that carry per-tab payload state must not write it onto a tab they did not create.
+    // Returns false when an existing tab was reselected: callers must not write per-tab payload onto a tab they didn't create.
     @discardableResult
     func addTableTab(
         tableName: String,
@@ -560,8 +487,7 @@ final class QueryTabManager: ObservableObject {
         selectedTabId = newTab.id
     }
 
-    /// `schemaName` is the schema the diagram draws, which on an engine whose entries are schemas
-    /// is the entry the tab belongs to, whichever one is on screen when it opens.
+    // schemaName is the schema drawn; on engines whose entries are schemas it is also the tab's entry.
     func addERDiagramTab(schemaKey: String, databaseName: String = "", schemaName: String? = nil) {
         let tabTitle = String(localized: "ER Diagram")
         var newTab = QueryTab(title: tabTitle, tabType: .erDiagram)
@@ -601,8 +527,6 @@ final class QueryTabManager: ObservableObject {
         selectedTabId = newTab.id
     }
 
-    /// One tab per object, so opening the same routine twice returns to the tab already showing
-    /// it, the way opening the same table does.
     func addObjectSourceTab(objectRef: DatabaseObjectRef) {
         if let existing = tabs.first(where: {
             $0.tabType == .objectSource && $0.display.objectRef?.namesSameObject(as: objectRef) == true
@@ -635,8 +559,6 @@ final class QueryTabManager: ObservableObject {
         selectedTabId = newTab.id
     }
 
-    /// One listing per database and schema, so asking again for the same tables returns to the tab
-    /// already showing them, the way opening the same table does.
     @discardableResult
     func addTableListingTab(title: String, databaseName: String, schemaName: String?) -> UUID {
         let schemaName = schemaName.flatMap { $0.isEmpty ? nil : $0 }
@@ -658,8 +580,7 @@ final class QueryTabManager: ObservableObject {
         return newTab.id
     }
 
-    /// The sidebar section's own name for the kind, qualified by the schema on an engine that lists
-    /// tables per schema, where two listings in one database would otherwise share a label.
+    // Qualified by schema where tables are listed per schema, or two listings in one database would share a label.
     static func tableListingTitle(kindTitle: String, schemaName: String?) -> String {
         guard let schemaName, !schemaName.isEmpty else { return kindTitle }
         return String(format: String(localized: "%@: %@"), kindTitle, schemaName)
@@ -700,9 +621,7 @@ final class QueryTabManager: ObservableObject {
         selectedTabId = newTab.id
     }
 
-    /// Replace the currently selected tab's content with a new table.
-    /// - Returns: `true` if the replacement happened (caller should run the query),
-    ///   `false` if there is no selected tab.
+    // Returns false when no tab is selected; on true the caller runs the query.
     @discardableResult
     func replaceTabContent(
         tableName: String, databaseType: DatabaseType = .mysql,
@@ -732,8 +651,7 @@ final class QueryTabManager: ObservableObject {
         var tab = tabs[selectedIndex]
         tab.tabType = .table
         tab.title = Self.tabTitle(name: tableName, schema: schemaName, databaseType: databaseType)
-        /// Built whole rather than field by field: a field left over describes the previous table,
-        /// and its primary keys were what a keyless table's edits matched rows on.
+        // Built whole: a leftover field describes the previous table, and its primary keys matched a keyless table's edits.
         tab.tableContext = TabTableContext(
             tableName: tableName,
             databaseName: databaseName,
@@ -743,8 +661,7 @@ final class QueryTabManager: ObservableObject {
             objectType: objectType,
             isTemporary: isTemporary
         )
-        /// Fresh for the same reason. A query tab keeps the file it was opened from, and a table
-        /// carried that binding, so Save wrote the table's query into the file.
+        // Fresh too: a query tab keeps its file binding, so a retargeted table's Save wrote its query into that file.
         tab.content = TabQueryContent(query: query)
         tab.schemaVersion += 1
         tab.execution.executionTime = nil
@@ -756,17 +673,14 @@ final class QueryTabManager: ObservableObject {
         tab.display.activeResultSetId = nil
         tab.sortState = SortState()
         tab.restoredSortSource = .unset
-        tab.selectedRowIndices = []
-        tab.cellSelection = .empty
+        tab.selectionSnapshot = .empty
         tab.pendingChanges = TabChangeSnapshot()
         tab.hasUserInteraction = false
         tab.filterState = TabFilterState()
         tab.valueFilter = GridValueFilterState()
         tab.columnLayout = ColumnLayoutState()
         tab.pagination = PaginationState(pageSize: pageSize)
-        // Retargeting points the tab at a different table, so a restore that has not been consumed
-        // yet describes rows this tab no longer shows. Left behind, it is persisted against the new
-        // table and applied to it on the next launch.
+        // An unconsumed restore describes the old rows; kept, it persists and applies to the new table on the next launch.
         tab.pendingRestoredSort = nil
         tab.restoredPage = nil
         tab.restoredPageSize = nil
@@ -819,7 +733,6 @@ final class QueryTabManager: ObservableObject {
 // MARK: - Visible Container
 
 extension QueryTabManager {
-    /// The tabs the strip lists: the visible entry's, plus the ones that name no container.
     var visibleTabs: [QueryTab] {
         if let cached = _visibleTabs { return cached }
         let listed = tabs.filter(isVisible)
@@ -833,19 +746,13 @@ extension QueryTabManager {
         WorkspaceAnchoring.containerName(of: tab, target: containerTarget)
     }
 
-    /// A tab that names no container belongs to no entry, so every entry shows it: a server
-    /// dashboard, or a query tab on an engine whose query tabs run against whatever is browsed.
+    // A tab naming no container (a server dashboard, a query tab on a browse-following engine) shows in every entry.
     func isVisible(_ tab: QueryTab) -> Bool {
         guard let visibleContainer, let container = containerName(of: tab) else { return true }
         return container == visibleContainer
     }
 
-    /// Puts an entry in front. The selection stays when it is already in that entry, lands on the
-    /// tab last used there otherwise, and on nothing when the entry holds no tab of its own, which
-    /// is the entry's empty state rather than a tab from somewhere else.
-    ///
-    /// It never moves the browse cursor. Whoever moved the cursor calls this, or calls it first and
-    /// moves the cursor after.
+    // Selection stays, falls back to the entry's last-used tab, or clears. Never moves the browse cursor; callers do that.
     func show(container: String?) {
         guard containerTarget != nil else { return }
         let container = container.flatMap { $0.isEmpty ? nil : $0 }
@@ -857,20 +764,14 @@ extension QueryTabManager {
         selectedTabId = landing
     }
 
-    /// A new window's only tab. Its entry is put in front before the tab is selected, so a window
-    /// built around a tab never reads as the user picking a tab in another entry, which would move
-    /// the connection's database on its own.
+    // Entry goes in front before selecting, so a new window never reads as a user pick that moves the database.
     func seed(with tab: QueryTab) {
         tabs = [tab]
         show(container: containerName(of: tab) ?? visibleContainer)
         selectedTabId = tab.id
     }
 
-    /// A tab is bound to the database, or the schema on an engine whose entries are schemas, it was
-    /// opened in. One a caller opened without naming it, such as a New Tab on a schema engine,
-    /// Favorites or Open in Editor, gets the visible entry's. Left unbound it ran against whatever
-    /// the connection browsed next, and picking a tab of another entry moves that: a statement
-    /// typed against one schema would run against the other.
+    // Unbound tabs ran against whatever the connection browsed next, so a statement typed for one schema ran on another.
     func bindToVisibleContainer(_ tab: inout QueryTab) {
         guard let visibleContainer,
               Self.bindsToContainer(tab.tabType),
@@ -886,16 +787,13 @@ extension QueryTabManager {
         }
     }
 
-    /// Where a tab opened without naming a database goes: the entry on screen. The browse cursor
-    /// lags it while a switch to that entry is on its way, and a tab bound to the cursor then would
-    /// take the window straight back to the entry the user just left.
+    // The entry on screen, not the browse cursor, which lags a switch and would pull the window back to the old entry.
     func openingDatabase(browsing browseDatabase: String) -> String {
         guard containerTarget == .database, let visibleContainer else { return browseDatabase }
         return visibleContainer
     }
 
-    /// Restored tabs from before tabs were bound to their entry: they ran against the container the
-    /// connection was on, which is the one the restore lands in.
+    // Tabs from before entry binding ran against the connection's container, which is the one the restore lands in.
     func bindUnboundTabs() {
         guard visibleContainer != nil,
               tabs.contains(where: { Self.bindsToContainer($0.tabType) && containerName(of: $0) == nil })
@@ -907,7 +805,7 @@ extension QueryTabManager {
         tabs = bound
     }
 
-    /// Server-wide tabs answer for the whole connection, so they belong to every entry.
+    // Server-wide tabs answer for the whole connection, so they belong to every entry.
     private static func bindsToContainer(_ type: TabType) -> Bool {
         switch type {
         case .query, .table, .createTable, .erDiagram, .objectSource, .tableListing:
@@ -934,9 +832,7 @@ extension QueryTabManager {
         return visibleTabs.last?.id
     }
 
-    /// Selecting a tab of another entry, or moving the selected tab into one, takes the window to
-    /// that entry: the selected tab is always one the strip lists. A selection that names a tab not
-    /// in the list yet is the moment inside a close or an adoption, and is left alone.
+    // The selected tab is always listed; a selection naming an unlisted tab is mid close or adoption and left alone.
     fileprivate func reconcileVisibleContainer() {
         guard containerTarget != nil,
               let id = selectedTabId,
diff --git a/apple/TablePro/Models/Query/QueryTabState.swift b/apple/TablePro/Models/Query/QueryTabState.swift
index 3f99be903a..42fa43be7a 100644
--- a/apple/TablePro/Models/Query/QueryTabState.swift
+++ b/apple/TablePro/Models/Query/QueryTabState.swift
@@ -8,12 +8,6 @@ import Foundation
 import TableProPluginKit
 import TableProUtilities
 
-@MainActor
-final class GridSelectionState: ObservableObject {
-    @Published var indices: Set<Int> = []
-}
-
-/// Type of tab
 enum TabType: Equatable, Codable, Hashable {
     case query
     case table
@@ -24,12 +18,10 @@ enum TabType: Equatable, Codable, Hashable {
     case insights
     case objectSource
     case versionHistory
-    /// The tables of one database or schema, as a read-only grid. Built from the catalog each time it
-    /// loads, never from SQL saved with the tab.
+    // Read-only grid of one database's or schema's tables, rebuilt from the catalog on each load, never from saved SQL.
     case tableListing
 }
 
-/// Minimal representation of a tab for persistence
 struct PersistedTab: Codable {
     let id: UUID
     let title: String
@@ -37,9 +29,7 @@ struct PersistedTab: Codable {
     let tabType: TabType
     let tableName: String?
     var isView: Bool = false
-    /// The object's own kind, as its `TableInfo.TableType` raw value. Optional and a raw String so a
-    /// file written before this existed decodes to nil, and a spelling a newer build invents decodes
-    /// to nil too rather than throwing and taking the whole tab aggregate with it.
+    // Optional raw String so old files and kinds a newer build invents decode to nil instead of failing the whole tab set.
     var objectTypeRawValue: String?
     var databaseName: String = ""
     var schemaName: String?
@@ -50,9 +40,7 @@ struct PersistedTab: Codable {
     var versionHistorySubject: VersionHistorySubject?
     var queryParameters: [QueryParameter]?
     var sortColumns: [PersistedSortColumn]?
-    /// Who chose the saved order. Absent in every file written before this existed, which decodes
-    /// back to the behaviour those files were written under: `.user` when columns were saved,
-    /// `.unset` when none were.
+    // Nil in files written before this existed: decodes to .user when columns were saved, .unset when none were.
     var sortSource: SortSource?
     var restoredPage: Int?
     var restoredPageSize: Int?
@@ -65,7 +53,7 @@ struct PersistedTab: Codable {
     var isPinned: Bool = false
     var isTemporary: Bool = false
 
-    /// Set when the query was too large for the tab-state JSON and lives in a sidecar file.
+    // Set when the query was too large for the tab-state JSON and lives in a sidecar file.
     var overflowFileName: String?
 
     init(
@@ -220,7 +208,6 @@ enum SortDirection: String, Equatable, Codable, CaseIterable, Identifiable {
     }
 }
 
-/// A single column in a multi-column sort
 struct SortColumn: Equatable {
     var columnIndex: Int
     var direction: SortDirection
@@ -233,25 +220,19 @@ struct SortColumn: Equatable {
     }
 }
 
-/// A sort column captured for cross-launch persistence, keyed by name so it survives column reordering
+// Keyed by name so it survives column reordering across launches.
 struct PersistedSortColumn: Codable, Equatable {
     let columnName: String
     let direction: SortDirection
 }
 
-/// Who decided the order the rows are in.
-///
-/// Three answers, not two, and the third is what makes "Don't Sort" stick. An empty `SortState`
-/// used to mean both "nothing has decided yet" and "the user turned sorting off", so
-/// `wantsDefaultSort` could not tell them apart and wrote the app default back over an explicit
-/// clear on the next first load. `.unset` is the former; `columns: [], source: .user` is the latter.
+// .unset vs .user with no columns tells "nothing decided yet" from "user turned sorting off", so Don't Sort sticks.
 enum SortSource: String, Equatable, Codable {
     case unset
     case user
     case defaultSort
 }
 
-/// Tracks sorting state for a table (supports multi-column sort)
 struct SortState: Equatable {
     var columns: [SortColumn] = []
     var source: SortSource = .unset
@@ -263,8 +244,7 @@ struct SortState: Equatable {
 
     var isSorting: Bool { !columns.isEmpty }
 
-    /// The sort in the name-keyed shape both persistence and navigation history store it in. A
-    /// column with no name cannot be resolved back against a re-fetched result, so it is dropped.
+    // A column with no name cannot be resolved against a re-fetched result, so it is dropped.
     var persistedColumns: [PersistedSortColumn] {
         columns.compactMap { column in
             guard let name = column.columnName else { return nil }
@@ -277,31 +257,18 @@ struct SortState: Equatable {
     var direction: SortDirection { columns.first?.direction ?? .ascending }
 }
 
-/// Tracks pagination state for navigating large datasets
 struct PaginationState: Equatable {
-    var totalRowCount: Int?         // Total rows in table (from COUNT(*))
-    var pageSize: Int               // Rows per page (passed from manager/coordinator)
-    var currentPage: Int = 1         // Current page number (1-based)
-    var currentOffset: Int = 0       // Current OFFSET for SQL query
-    /// A fetch is in flight for the rows this state describes.
-    ///
-    /// Raised synchronously by whatever discards the tab's rows, in the same block that discards
-    /// them, and lowered when the rows land or the attempt fails. It cannot be derived from
-    /// `TabExecutionRegistry.isExecuting`: retargeting a tab clears the row buffer synchronously
-    /// but only *schedules* the load, so the claim arrives a main-actor turn later and the status
-    /// bar can render an empty buffer that nothing has yet called a load.
+    var totalRowCount: Int?
+    var pageSize: Int
+    var currentPage: Int = 1
+    var currentOffset: Int = 0
+    // Raised where rows are discarded; not derived from TabExecutionRegistry, whose claim lands a main-actor turn later.
     var isLoading: Bool = false
-    var isApproximateRowCount: Bool = false  // True when totalRowCount is from fast estimate
-    var isCountingExact: Bool = false        // True while a user-requested exact count is running
-    /// The message a failed `Count Exactly` put on the tab, so a later count that succeeds takes
-    /// down its own error and no other.
+    var isApproximateRowCount: Bool = false
+    var isCountingExact: Bool = false
+    // From a failed Count Exactly, kept so a later successful count clears only this error.
     var exactCountError: String?
-    /// An automatic row count is running, so the total on screen is not the one this page settles on.
-    ///
-    /// Separate from `isCountingExact`, which the user asked for and which owns the spinner. This
-    /// one is silent: it exists so `Count Exactly` is not offered against a total that is about to
-    /// be replaced anyway. The execution claim cannot answer this, because it settles the moment
-    /// phase 1 applies, before the count is even dispatched.
+    // Silent automatic count in flight, so Count Exactly is not offered; the execution claim settles before it dispatches.
     var isCountPending: Bool = false
 
     // Result truncation state (query tabs)
@@ -310,16 +277,13 @@ struct PaginationState: Equatable {
     var baseQueryForMore: String?
     var baseQueryParameterValues: [String?]?
 
-    /// The query and its bindings are one fact, so they are replaced together. Setting the query
-    /// alone left the previous run's bindings in place, and Fetch All then sent them with a query
-    /// that no longer had placeholders, which the server rejects.
+    // Set together: stale bindings sent with a placeholder-free query made Fetch All fail on the server.
     mutating func setBaseQueryForMore(_ sql: String?, parameterValues: [String?]?) {
         baseQueryForMore = sql
         baseQueryParameterValues = parameterValues
     }
 
-    /// Default page size constant (used when no explicit value is provided)
-    /// Note: For new tabs, callers should pass AppSettingsManager.shared.dataGrid.defaultPageSize
+    // Fallback only; new tabs pass AppSettingsManager.shared.dataGrid.defaultPageSize.
     static let defaultPageSize = 1_000
 
     init(
@@ -338,36 +302,26 @@ struct PaginationState: Equatable {
 
     // MARK: - Computed Properties
 
-    /// Total number of pages
-    ///
-    /// The ceiling is taken with `quotientAndRemainder` rather than `(total + pageSize - 1) / pageSize`
-    /// because the custom rows-per-page field used to accept `Int.max`, and the addition then trapped
-    /// on overflow the next time the status bar rendered.
+    // quotientAndRemainder, not (total + pageSize - 1): the rows-per-page field once accepted Int.max and overflowed.
     var totalPages: Int {
         guard let total = totalRowCount, total > 0, pageSize > 0 else { return 1 }
         let (quotient, remainder) = total.quotientAndRemainder(dividingBy: pageSize)
         return remainder == 0 ? quotient : quotient + 1
     }
 
-    /// Any asynchronous work this state is still waiting on.
     var isBusy: Bool {
         isLoading || isLoadingMore || isCountingExact || isCountPending
     }
 
-    /// Whether the total is a real count rather than a driver estimate.
-    ///
-    /// An estimate cannot bound navigation. MySQL's `TABLE_ROWS` under-reports InnoDB routinely, and
-    /// an estimate kept as the total left every row past it unreachable behind a disabled Next.
+    // An estimate cannot bound navigation: MySQL's TABLE_ROWS under-reports InnoDB and stranded rows behind a disabled Next.
     var hasExactRowCount: Bool {
         totalRowCount != nil && !isApproximateRowCount
     }
 
-    /// Whether any total is available, exact or estimated.
     var hasRowCountTotal: Bool {
         totalRowCount != nil
     }
 
-    /// Whether there is a next page available
     var hasNextPage: Bool {
         currentPage < totalPages
     }
@@ -381,21 +335,20 @@ struct PaginationState: Equatable {
         return loadedRowCount >= pageSize
     }
 
-    /// Whether there is a previous page available
+    // A table tab pages through currentPage; hasMoreRows is a query result cut short.
+    func hasUnloadedRows(loadedRowCount: Int) -> Bool {
+        hasMoreRows || canGoToNextPage(loadedRowCount: loadedRowCount)
+    }
+
     var hasPreviousPage: Bool {
         currentPage > 1
     }
 
-    /// Starting row number for current page (1-based)
     var rangeStart: Int {
         currentOffset + 1
     }
 
-    /// Ending row number for the current page, from the rows the page actually returned.
-    ///
-    /// Deriving it from `pageSize` fabricated a range the grid never showed: a table whose driver
-    /// estimate said a million rows but which returned twelve reported "1-1000 of ~1,000,000 rows".
-    /// The loaded count is the only number that describes what is on screen.
+    // From loaded rows, not pageSize: an estimate of 1M that returned 12 rows showed "1-1000 of ~1,000,000 rows".
     func rangeEnd(loadedRowCount: Int) -> Int {
         currentOffset + max(loadedRowCount, 0)
     }
@@ -431,52 +384,34 @@ struct PaginationState: Equatable {
         setPage(totalPages)
     }
 
-    /// A page beyond the last is refused only when the last one is actually known. With an estimate
-    /// there is no trustworthy upper bound, and refusing on one strands the rows past it.
+    // Pages past the last are refused only for an exact total; an estimate is no trustworthy upper bound.
     mutating func goToPage(_ page: Int) {
         guard page > 0, hasRowCountTotal else { return }
         guard !hasExactRowCount || page <= totalPages else { return }
         setPage(page)
     }
 
-    /// Applies a total the app derived on its own, rather than one the user asked for.
-    ///
-    /// An estimate never replaces an exact count. The automatic count re-runs after every execution,
-    /// including a page turn, and on a driver whose cheap count is an estimate that silently undid a
-    /// `Count Exactly` and brought the button back on the next page. Retiring an exact count is a
-    /// deliberate act, so it belongs to the paths that ask for fresh data, not to this one.
-    /// A nil total blanks it, which is what a filter change asks for and is never an estimate.
+    // Never replaces an exact count: the auto count re-runs on every page turn and undid Count Exactly. Nil blanks it.
     mutating func applyDerivedRowCount(_ total: Int?, isApproximate: Bool) {
         guard !isApproximate || !hasExactRowCount else { return }
         totalRowCount = total
         isApproximateRowCount = isApproximate
     }
 
-    /// Drops the total so the next execution derives it again from scratch.
-    ///
-    /// For the paths that change the row set or ask for it fresh, where the count on screen is no
-    /// longer describing the table. Clearing the number rather than flagging it approximate matters:
-    /// `rowCountPlan` skips counting a table whose total already exceeds the count threshold, so a
-    /// real count left in place and merely relabelled would keep its `~` forever, with `Last page`
-    /// disabled and no `Count Exactly` to put it right. Cleared, the tab counts exactly the way a
-    /// freshly opened one does.
+    // Cleared, not marked approximate: rowCountPlan skips counting a total above the threshold, so the ~ would stick.
     mutating func retireDerivedRowCount() {
         totalRowCount = nil
         isApproximateRowCount = false
     }
 
-    /// Reset pagination to first page
     mutating func reset() {
         currentPage = 1
         currentOffset = 0
         isLoading = false
-        /// A count belonging to the rows being replaced is not this tab's business any more. Left
-        /// set, a superseded attempt's mark would suppress `Count Exactly` on the new table until
-        /// something else happened to clear it.
+        // A superseded count's mark would otherwise suppress Count Exactly on the new table.
         isCountPending = false
     }
 
-    /// Reset result truncation state
     mutating func resetLoadMore() {
         hasMoreRows = false
         isLoadingMore = false
@@ -484,18 +419,13 @@ struct PaginationState: Equatable {
         baseQueryParameterValues = nil
     }
 
-    /// Update page size (limit), keeping the first visible row inside the new page.
-    ///
-    /// `setPage` is what re-derives the offset. Assigning `currentPage` alone left the old offset in
-    /// place, so changing 20 to 100 on page 3 ran `LIMIT 100 OFFSET 40` while the indicator read
-    /// "1 / N" and First and Previous went inert.
+    // Goes through setPage to re-derive the offset; setting currentPage alone ran LIMIT 100 OFFSET 40 shown as page 1.
     mutating func updatePageSize(_ newSize: Int) {
         guard newSize > 0 else { return }
         pageSize = newSize
         setPage((currentOffset / pageSize) + 1)
     }
 
-    /// Update offset directly and recalculate page
     mutating func updateOffset(_ newOffset: Int) {
         guard newOffset >= 0 else { return }
         currentOffset = newOffset
@@ -503,7 +433,6 @@ struct PaginationState: Equatable {
     }
 }
 
-/// Stores column layout (widths and order) within a tab session
 struct ColumnLayoutState: Equatable {
     var columnWidths: [String: CGFloat] = [:]
     var columnContentWidths: [String: CGFloat]?
@@ -512,20 +441,13 @@ struct ColumnLayoutState: Equatable {
     // Leading columns in display order, a count so a result that repeats a name stays unambiguous.
     var frozenColumnCount: Int = 0
 
-    /// Splices a captured order into the stored one, keeping names the capture never saw.
-    ///
-    /// A capture only lists the columns the query returned, and hiding a column takes it out of
-    /// that projection. Overwriting with the capture therefore drops the hidden column's position,
-    /// and showing it again appends it at the end, which reorders a grid the user never touched.
-    /// Names the capture does cover take its order; the rest hold their slots.
+    // A capture omits hidden columns, so names it doesn't cover keep their slots instead of jumping to the end when shown.
     static func mergedColumnOrder(current: [String]?, incoming: [String]?) -> [String]? {
         guard let incoming else { return current }
         guard let current, !current.isEmpty else { return incoming }
 
         let incomingSet = Set(incoming)
-        // Only a narrowing of the same column set is a partial capture worth splicing. Anything
-        // else is a different result, and merging there would accumulate names from a table the
-        // layout no longer describes.
+        // Only a narrowing of the same column set is a partial capture; anything else is a different result.
         guard incomingSet.isSubset(of: Set(current)) else { return incoming }
         var remaining = incoming.makeIterator()
         var merged: [String] = []
@@ -552,8 +474,7 @@ struct ColumnLayoutState: Equatable {
         frozenColumnCount = other.frozenColumnCount
     }
 
-    /// Drops the geometry outright. Reset is not a capture, so it must not go through the merge,
-    /// which deliberately keeps a stored order when a capture carries none.
+    // Reset is not a capture, so it skips the merge, which keeps a stored order when a capture carries none.
     mutating func resetGeometry() {
         columnWidths = [:]
         columnContentWidths = nil
@@ -568,9 +489,7 @@ struct ColumnLayoutState: Equatable {
     }
 }
 
-/// Deliberately has no `isExecuting`. Busy state is derived from `TabExecutionRegistry`, because a
-/// stored flag could not be reset by a tab retarget and so kept a retargeted tab busy forever,
-/// silently swallowing every later navigation.
+// No isExecuting on purpose: busy comes from TabExecutionRegistry, as a stored flag kept retargeted tabs busy forever.
 struct TabExecutionState: Equatable {
     var executionTime: TimeInterval?
     var statusMessage: String?
@@ -579,14 +498,10 @@ struct TabExecutionState: Equatable {
     var rowsAffected: Int = 0
     var lastExecutedAt: Date?
 
-    /// Set when work on this tab finished somewhere the user could not see it, cleared when they
-    /// select the tab. This is the channel that survives a missed banner, a denied notification
-    /// permission and a Focus mode, none of which the app can do anything about.
+    // Set when work finished out of sight, cleared on select; survives missed banners, denied notifications and Focus.
     var finishedUnseenAt: Date?
 
-    /// Hand-written, and every field the UI draws from has to be in it. `finishedUnseenAt` drives
-    /// a dot in the tab strip, so leaving it out here would mean the dot never appeared: SwiftUI
-    /// compares the tab and sees no change.
+    // Hand-written: every field the UI draws must be compared, or SwiftUI sees no change (finishedUnseenAt drives a dot).
     static func == (lhs: TabExecutionState, rhs: TabExecutionState) -> Bool {
         lhs.executionTime == rhs.executionTime
             && lhs.statusMessage == rhs.statusMessage
@@ -604,19 +519,10 @@ struct TabTableContext: Equatable {
     var isEditable: Bool = false
     var isView: Bool = false
 
-    /// The object's own kind, carried beside `isView` rather than replacing it.
-    ///
-    /// `isView` is a read-only mark that a dozen Bool-only carriers already speak (deeplinks, the URL
-    /// parser, scripting, recents), and a tab saved by an older build can carry it false over a
-    /// materialized view. It cannot say which of seven kinds the object is. This can, and only the
-    /// kind says which *structure* edits the object accepts. (#2726)
-    ///
-    /// Nil on a tab restored from a file written before this existed, and on any path that never
-    /// learned the kind; `resolvedObjectKind()` falls back to what `isView` can still tell us.
+    // Beside isView, which can't tell seven kinds apart; only the kind says which structure edits the object accepts (#2726).
     var objectType: TableInfo.TableType?
 
-    // Read on the session that holds it, and browsed only: a staged row edit would land on whatever table the name
-    // reaches once the temporary one is dropped.
+    // Browse only: a staged row edit would land on whatever table the name reaches once the temporary one is dropped.
     var isTemporary = false
 
     func resolvedObjectKind() -> TableInfo.TableType {
@@ -629,18 +535,14 @@ struct TabTableContext: Equatable {
 
     var primaryKeyColumn: String? { primaryKeyColumns.first }
 
-    /// A tab opened without an explicit database carries an empty name and follows the window's
-    /// browse cursor, so comparing the stored value against a real database name never matches.
+    // An empty name means the tab follows the window's browse cursor.
     func resolvedDatabaseName(browsing browseDatabaseName: String) -> String {
         databaseName.isEmpty ? browseDatabaseName : databaseName
     }
 }
 
 struct TabQueryContent: Equatable {
-    /// Holds the query text behind a reference. SwiftUI's attribute-graph diff compares a value by walking its memory
-    /// layout, so a stored `String` field made it normalize the whole multi-megabyte query (NFC) on every view update.
-    /// Storing the text in a class makes that walk compare an 8-byte pointer instead. Value semantics are preserved
-    /// because the setter replaces the box.
+    // Boxed: SwiftUI's graph diff walks a stored String, which NFC-normalized multi-MB queries on every view update.
     private final class QueryStorage: Sendable {
         let text: String
         init(_ text: String) { self.text = text }
@@ -694,9 +596,7 @@ struct TabQueryContent: Equatable {
     }
 
     static func == (lhs: TabQueryContent, rhs: TabQueryContent) -> Bool {
-        // Cheap scalar fields short-circuit first. The query and saved-file text can be multiple megabytes and are
-        // bridged from NSTextStorage, so they are compared last and with `sameText` to avoid Swift's canonical Unicode
-        // comparison (O(n) on the bridged text); the same-box identity check makes an unchanged query O(1).
+        // Cheap fields first; multi-MB text last, via box identity and sameText to skip canonical Unicode comparison.
         lhs.isParameterPanelVisible == rhs.isParameterPanelVisible
             && lhs.diskChange == rhs.diskChange
             && lhs.dismissedDiskChange == rhs.dismissedDiskChange
@@ -708,7 +608,7 @@ struct TabQueryContent: Equatable {
             && sameText(lhs.savedFileContent, rhs.savedFileContent)
     }
 
-    /// Literal text equality that skips Swift's canonical Unicode comparison, returning in O(1) when the lengths differ.
+    // Literal comparison, skipping Swift's canonical Unicode equality; O(1) when the lengths differ.
     private static func sameText(_ lhs: String?, _ rhs: String?) -> Bool {
         switch (lhs, rhs) {
         case (nil, nil):
@@ -723,12 +623,7 @@ struct TabQueryContent: Equatable {
 
 struct TabDisplayState: Equatable {
     var resultsViewMode: ResultsViewMode = .data
-    /// The geometry columns of the result currently installed, decided where the rows are installed
-    /// rather than at each reader.
-    ///
-    /// Deciding it costs a sample of the column's values, and the status bar asks on every render
-    /// while the View menu asks on every validation, so it is answered once per result. Nothing but
-    /// `MainContentCoordinator.installTableRows` writes it.
+    // Set once per result in installTableRows: detection samples values, and the status bar and View menu ask constantly.
     var spatialColumns: [SpatialColumn] = []
     var erDiagramSchemaKey: String?
     var objectRef: DatabaseObjectRef?
@@ -755,7 +650,6 @@ struct TabDisplayState: Equatable {
         leaveOutputModeWithoutOutput()
     }
 
-    /// A re-read of one result takes its place, label and pin included, and leaves the others alone.
     @MainActor
     mutating func replaceResult(_ outgoingId: UUID, with result: ResultSet) {
         guard let index = resultSets.firstIndex(where: { $0.id == outgoingId }) else { return }
@@ -773,9 +667,7 @@ struct TabDisplayState: Equatable {
         leaveOutputModeWithoutOutput()
     }
 
-    /// Output mode shows what the active result printed, so it cannot outlive a result that printed nothing. The
-    /// rows of a new result are installed, and their modes reconciled, before the result itself replaces the old
-    /// one, which is too early to see the new result's output.
+    // Output mode can't outlive a silent result; checked here since row install reconciles modes before the result swap.
     @MainActor
     private mutating func leaveOutputModeWithoutOutput() {
         guard resultsViewMode == .output, activeResultSet?.serverOutput.isEmpty != false else { return }
diff --git a/apple/TablePro/Models/UI/DataGridConfiguration.swift b/apple/TablePro/Models/UI/DataGridConfiguration.swift
index f42660aec7..e6313ae64d 100644
--- a/apple/TablePro/Models/UI/DataGridConfiguration.swift
+++ b/apple/TablePro/Models/UI/DataGridConfiguration.swift
@@ -2,65 +2,47 @@
 //  DataGridConfiguration.swift
 //  TablePro
 //
-//  Configuration struct for DataGridView, replacing individual config properties.
-//
 
 import Foundation
 
+// What a grid offers. Where its rows came from lives in `traits`; where its layout is saved lives in its store.
 struct DataGridConfiguration: Equatable {
     var dropdownColumns: Set<Int>?
     var typePickerColumns: Set<Int>?
     var customDropdownOptions: [Int: [GridMenuOption]]?
-    var connectionId: UUID?
-    var databaseType: DatabaseType?
-    var tableName: String?
-    var databaseName: String?
-    var schemaName: String?
     var primaryKeyColumns: [String] = []
-    var tabType: TabType?
     var showRowNumbers: Bool = true
-    var hiddenColumns: Set<String> = []
 
-    /// Columns drawn as a checkbox whose state the delegate owns, for a grid that reviews rows rather
-    /// than edits them. Keyed by index, because the column is the grid's own and has no name a table
-    /// column could share.
+    // Keyed by index: the column is the grid's own and has no name a table column could share.
     var checkboxColumns: Set<Int> = []
 
-    /// Whether the grid offers the commands that belong to a result: filtering by a column, column
-    /// hiding, export and the JSON view. A grid whose rows are a comparison answers none of them, and
-    /// a command that does nothing is worse than one that is not there.
-    var supportsColumnCommands: Bool = true
-
     var supportsValueFilter: Bool = true
 
-    var filterMenuColumnTypes: [ColumnType]?
-
-    /// Headings whose cells this grid must not let the user change, even though the rest of the grid
-    /// is editable. The Structure tab sets it per object kind: PostgreSQL takes a view's
-    /// `RENAME COLUMN` and `SET DEFAULT` and refuses its `SET NOT NULL` and `SET DATA TYPE`, so Name
-    /// and Default stay open while Nullable and Type lock. Name-keyed because that is the handle
-    /// `isColumnWritable` already works in. (#2726)
+    // PostgreSQL renames a view's column and sets its default but refuses its NOT NULL and type (#2726).
     var lockedColumns: Set<String> = []
 
-    /// This grid shows rows of a result, so the Data Grid sort preferences apply to it.
-    ///
-    /// `tabType` cannot answer this: the Structure grid runs inside a `.table` tab and lists columns,
-    /// and a query result runs in a `.query` tab and is as much the data grid as a table is. The
-    /// question is what the grid holds, not which tab it sits in.
+    // A result's rows, not a list of columns: the Data Grid sort preferences apply.
     var appliesRowSortPreferences: Bool = false
 
-    // Records: a table, a query, a file or a listing. Off on the Structure grids, whose Copy writes column and
-    // index definitions a paste reads back, and which have no INSERT or UPDATE to offer.
+    // Off on the Structure grids, whose Copy writes definitions a paste reads back.
     var appliesRowCopyFormat: Bool = false
 
-    /// Whether a heading click or the heading menu orders the rows. A Cassandra table cannot be ordered by an
-    /// arbitrary column, so its table grid offers no sort rather than one the server refuses.
+    // A Cassandra table cannot be ordered by an arbitrary column.
     var supportsColumnSort: Bool = true
 
-    /// Why these rows cannot be written back, when they cannot. A grid that silently refuses every
-    /// keystroke reads as broken, so the reason rides with the configuration and the grid shows it.
+    // A grid that refuses every keystroke silently reads as broken.
     var editRefusalMessage: String?
 
-    /// Keyed by heading; a column not named here keeps `DataGridMetrics.dataColumnMinWidth`.
     var columnMinimumWidths: [String: CGFloat] = [:]
+
+    var isEditable: Bool = false
+
+    var commands: Set<DataGridCommand> = []
+
+    var traits: DataGridEngineTraits = .none
+
+    var rowReorder: DataGridRowReorder = .disabled
+
+    // VoiceOver's name for the grid ("Active Sessions"); nil reads "Data grid".
+    var accessibilityLabel: String?
 }
diff --git a/apple/TablePro/Models/UI/FindCounterText.swift b/apple/TablePro/Models/UI/FindCounterText.swift
new file mode 100644
index 0000000000..908416f657
--- /dev/null
+++ b/apple/TablePro/Models/UI/FindCounterText.swift
@@ -0,0 +1,40 @@
+//
+//  FindCounterText.swift
+//  TablePro
+//
+
+import Foundation
+
+enum FindScope: Equatable {
+    case allRowsLoaded
+    case pageOfMore
+}
+
+enum FindCounterText {
+    static func text(matchCount: Int, currentIndex: Int?, scope: FindScope) -> String {
+        guard matchCount > 0 else { return emptyText(scope: scope) }
+
+        let position = (currentIndex ?? 0) + 1
+        switch scope {
+        case .allRowsLoaded:
+            return String(
+                format: String(localized: "%1$@ of %2$@"),
+                position.formatted(),
+                matchCount.formatted()
+            )
+        case .pageOfMore:
+            return String(
+                format: String(localized: "%1$@ of %2$@ on this page"),
+                position.formatted(),
+                matchCount.formatted()
+            )
+        }
+    }
+
+    private static func emptyText(scope: FindScope) -> String {
+        switch scope {
+        case .allRowsLoaded: String(localized: "No matches")
+        case .pageOfMore: String(localized: "Not on this page")
+        }
+    }
+}
diff --git a/apple/TablePro/Models/UI/GridSelection.swift b/apple/TablePro/Models/UI/GridSelection.swift
index fa307d8c56..6cc2c6a2a4 100644
--- a/apple/TablePro/Models/UI/GridSelection.swift
+++ b/apple/TablePro/Models/UI/GridSelection.swift
@@ -4,15 +4,21 @@ struct GridSelection: Equatable {
     var rectangles: [GridRect]
     var activeCell: GridCoord?
     var anchor: GridCoord?
-    /// The display positions the user picked *as columns*, by clicking their headings.
-    ///
-    /// Recorded rather than re-derived, because geometry cannot tell the gestures apart. A
-    /// rectangle spanning every row is what a heading click builds, and equally what Select All,
-    /// Shift+Space and an ordinary cell drag build whenever the page is short enough. Reading the
-    /// intent back out of the shape painted the whole heading row as selected on Cmd+A, hid a
-    /// swept block's own outline, and armed the data file window's Delete Column on every column of
-    /// the file.
+    // Recorded, not read from shape: a full-height rectangle is also Select All, Shift+Space or a drag on a short page.
     var columns: IndexSet = []
+    // Geometry can't tell the pick: an all-columns range on a narrow grid is still cells, and a click's pick is one cell.
+    enum Mode: Equatable {
+        case cells
+        // A cell click: its row is selected and the cursor sits on the cell.
+        case cursor
+        // Row numbers, Select All, Shift+Space.
+        case rows
+    }
+
+    var mode: Mode = .cells
+
+    var picksRows: Bool { mode == .rows }
+    var isRows: Bool { mode != .cells }
 
     static let empty = GridSelection(rectangles: [], activeCell: nil, anchor: nil)
 
@@ -34,8 +40,7 @@ struct GridSelection: Equatable {
         return set
     }
 
-    /// The display positions the selection covers. Convert with
-    /// `TableViewCoordinator.dataColumnIndices(in:)` before indexing anything that holds values.
+    // Display positions: convert with TableViewCoordinator.dataColumnIndices(in:) before indexing anything holding values.
     var affectedColumns: IndexSet {
         var set = IndexSet()
         for rect in rectangles {
@@ -59,7 +64,6 @@ struct GridSelection: Equatable {
         return GridRect(rows: minRow...maxRow, columns: minColumn...maxColumn)
     }
 
-    /// The display positions covered on one row.
     func columns(in row: Int) -> IndexSet {
         var set = IndexSet()
         for rect in rectangles where rect.rows.contains(row) {
@@ -68,13 +72,7 @@ struct GridSelection: Equatable {
         return set
     }
 
-    /// The part of this selection that still fits a grid of the given size, or `.empty` when none
-    /// of it does.
-    ///
-    /// A selection restored onto a remounted grid describes the result it was made against, and the
-    /// row count can have shrunk in between. `NSTableView.selectRowIndexes` is all-or-nothing on an
-    /// out-of-range member, measured, so an unclamped restore selects nothing at all rather than the
-    /// rows that do still exist.
+    // NSTableView.selectRowIndexes selects nothing if any index is out of range (measured), and a restored result can shrink.
     func clamped(rowLimit: Int, columnLimit: Int) -> GridSelection {
         let fitted = rectangles.compactMap { $0.clamped(rowLimit: rowLimit, columnLimit: columnLimit) }
         guard !fitted.isEmpty else { return .empty }
@@ -84,14 +82,7 @@ struct GridSelection: Equatable {
                   coord.displayColumn >= 0, coord.displayColumn < columnLimit else { return nil }
             return coord
         }
-        /// A marker only survives while its block still covers the column. The row count can have
-        /// grown as well as shrunk, and a result that gained rows leaves the old block short of the
-        /// end: keeping the marker then told the heading and the column commands they had a whole
-        /// column while the fill, the copy and the affected rows stopped short, and
-        /// `removeEntireColumn` could no longer match the stale block to take it back off.
-        ///
-        /// Checking the geometry here is not the inference this field replaced. It validates a
-        /// recorded intent against the result now in front of it, rather than inventing one.
+        // A marker survives only while its block still covers the column: a grown result left a stale marker short of the end.
         let stillWholeColumns = columns.filteredIndexSet { position in
             guard position >= 0, position < columnLimit else { return false }
             return fitted.contains { rect in
@@ -102,7 +93,8 @@ struct GridSelection: Equatable {
             rectangles: fitted,
             activeCell: fit(activeCell),
             anchor: fit(anchor),
-            columns: stillWholeColumns
+            columns: stillWholeColumns,
+            mode: mode
         )
     }
 
@@ -111,7 +103,8 @@ struct GridSelection: Equatable {
             rectangles: rectangles + other.rectangles,
             activeCell: other.activeCell ?? activeCell,
             anchor: other.anchor ?? anchor,
-            columns: columns.union(other.columns)
+            columns: columns.union(other.columns),
+            mode: mode == other.mode ? mode : .cells
         )
     }
 
@@ -119,8 +112,7 @@ struct GridSelection: Equatable {
         GridSelection(rectangles: [rect], activeCell: active, anchor: anchor)
     }
 
-    /// One whole column the user picked by its heading, carrying the position as well as the block,
-    /// so the heading knows it was chosen rather than merely covered.
+    // Carries the position, so the heading knows it was chosen rather than merely covered.
     static func column(_ displayColumn: Int, totalRows: Int) -> GridSelection {
         let anchor = GridCoord(row: 0, displayColumn: displayColumn)
         return GridSelection(
@@ -133,8 +125,7 @@ struct GridSelection: Equatable {
 }
 
 internal extension GridSelection {
-    /// Rectangles overlap (a Cmd+drag over a block, a picked column under a swept one), so summing
-    /// their areas counts a cell twice. Walked by row band, so a whole-column pick costs one band.
+    // Rectangles overlap, so areas can't be summed; walked by row band, so a whole-column pick costs one band.
     var uniqueCellCount: Int {
         if rectangles.count == 1, let only = rectangles.first {
             return only.rows.count * only.columns.count
@@ -168,81 +159,10 @@ internal extension GridSelection {
         markers.remove(cell.displayColumn)
         return rebuilt(rectangles: remaining, markers: markers, active: activeCell, origin: anchor)
     }
-
-    /// `indices` are positions in the grown grid, as `NSTableView.insertRows(at:)` takes them.
-    static func row(_ row: Int, afterInserting indices: IndexSet) -> Int {
-        var row = row
-        for range in indices.rangeView {
-            guard range.lowerBound <= row else { break }
-            row += range.count
-        }
-        return row
-    }
-
-    /// `indices` are positions before the removal, as `NSTableView.removeRows(at:)` takes them. Nil
-    /// when the row itself was removed.
-    static func row(_ row: Int, afterRemoving indices: IndexSet) -> Int? {
-        guard !indices.contains(row) else { return nil }
-        return row - indices.count(in: 0..<max(0, row))
-    }
-
-    func insertingRows(_ indices: IndexSet, newRowCount: Int) -> GridSelection {
-        guard !isEmpty, !indices.isEmpty, newRowCount > 0 else { return self }
-        let oldRowCount = newRowCount - indices.count
-        func shiftedRow(_ row: Int) -> Int {
-            Self.row(row, afterInserting: indices)
-        }
-        func shiftedCoord(_ coord: GridCoord?) -> GridCoord? {
-            coord.map { GridCoord(row: shiftedRow($0.row), displayColumn: $0.displayColumn) }
-        }
-        let moved = rectangles.map { rect -> GridRect in
-            if isPickedColumn(rect, rowCount: oldRowCount) {
-                return GridRect(rows: 0...(newRowCount - 1), columns: rect.columns)
-            }
-            return GridRect(
-                rows: shiftedRow(rect.rows.lowerBound)...shiftedRow(rect.rows.upperBound),
-                columns: rect.columns
-            )
-        }
-        return rebuilt(
-            rectangles: moved,
-            markers: wholeColumns(in: moved, rowCount: newRowCount),
-            active: shiftedCoord(activeCell),
-            origin: shiftedCoord(anchor)
-        )
-    }
-
-    func removingRows(_ indices: IndexSet, newRowCount: Int) -> GridSelection {
-        guard !isEmpty, !indices.isEmpty else { return self }
-        guard newRowCount > 0 else { return .empty }
-        func shiftedRow(_ row: Int) -> Int? {
-            Self.row(row, afterRemoving: indices)
-        }
-        func shiftedCoord(_ coord: GridCoord?) -> GridCoord? {
-            guard let coord, let row = shiftedRow(coord.row) else { return nil }
-            return GridCoord(row: row, displayColumn: coord.displayColumn)
-        }
-        let kept = rectangles.compactMap { rect -> GridRect? in
-            var survivors = IndexSet(integersIn: rect.rows.lowerBound...rect.rows.upperBound)
-            survivors.subtract(indices)
-            guard let first = survivors.first,
-                  let last = survivors.last,
-                  let lower = shiftedRow(first),
-                  let upper = shiftedRow(last) else { return nil }
-            return GridRect(rows: lower...upper, columns: rect.columns)
-        }
-        return rebuilt(
-            rectangles: kept,
-            markers: wholeColumns(in: kept, rowCount: newRowCount),
-            active: shiftedCoord(activeCell),
-            origin: shiftedCoord(anchor)
-        )
-    }
 }
 
 private extension GridSelection {
-    /// Every rectangle's row bounds are breakpoints, so the rectangles covering a band are the same
-    /// on each of its rows and one column union serves the whole band.
+    // Rectangle row bounds are breakpoints, so one column union serves every row of a band.
     func forEachRowBand(_ body: (Range<Int>, IndexSet) -> Void) {
         var breakpoints = rectangles.flatMap { [$0.rows.lowerBound, $0.rows.upperBound + 1] }
         breakpoints.sort()
@@ -263,23 +183,7 @@ private extension GridSelection {
         }
     }
 
-    func isPickedColumn(_ rect: GridRect, rowCount: Int) -> Bool {
-        !columns.isEmpty
-            && columns.contains(integersIn: rect.columns.lowerBound...rect.columns.upperBound)
-            && rect.rows.lowerBound <= 0
-            && rect.rows.upperBound >= rowCount - 1
-    }
-
-    func wholeColumns(in rects: [GridRect], rowCount: Int) -> IndexSet {
-        columns.filteredIndexSet { position in
-            rects.contains { rect in
-                rect.columns.contains(position) && rect.rows.lowerBound <= 0 && rect.rows.upperBound >= rowCount - 1
-            }
-        }
-    }
-
-    /// A cursor left outside the selection would be drawn on a cell that is no longer selected, so
-    /// it moves to the last rectangle, as the Cmd+click toggle has always done.
+    // A cursor outside the selection would draw on an unselected cell, so it moves to the last rectangle (as Cmd+click does).
     func rebuilt(rectangles kept: [GridRect], markers: IndexSet, active: GridCoord?, origin: GridCoord?) -> GridSelection {
         guard let last = kept.last else { return .empty }
         func inside(_ coord: GridCoord?) -> GridCoord? {
diff --git a/apple/TablePro/Models/UI/GridSelectionOwner.swift b/apple/TablePro/Models/UI/GridSelectionOwner.swift
index 02510af884..b20f998971 100644
--- a/apple/TablePro/Models/UI/GridSelectionOwner.swift
+++ b/apple/TablePro/Models/UI/GridSelectionOwner.swift
@@ -2,22 +2,16 @@
 //  GridSelectionOwner.swift
 //  TablePro
 //
-//  Resolves which grid owns the row selection in `GridSelectionState`. The data grid,
-//  the structure grid, and the new-table grid all publish into that one channel, so
-//  every consumer has to agree on whose display positions the indices are.
-//
 
 import Foundation
 
+// Which grid's model holds the selection the inspector, the Edit menu and the status bar read.
 internal enum GridSelectionOwner: Equatable {
     case dataGrid
     case schemaGrid
     case none
 
-    /// The mode arm is an exhaustive switch rather than an exception list, so a mode added later
-    /// cannot compile without saying whose display positions its selection is. It used to name
-    /// `.chart` alone in an if-chain, which meant any new mode fell through to the `tabType`
-    /// switch below and silently claimed the data grid's channel.
+    // An exhaustive switch over the mode, so a mode added later has to say whose selection it shows.
     static func resolve(tabType: TabType?, resultsViewMode: ResultsViewMode?) -> GridSelectionOwner {
         guard let tabType else { return .none }
         if tabType == .createTable { return .schemaGrid }
@@ -27,8 +21,7 @@ internal enum GridSelectionOwner: Equatable {
             case .structure:
                 return .schemaGrid
             case .chart, .output:
-                /// Nothing in a chart or in printed output selects a row, so the indices left over
-                /// from the grid are nobody's.
+                // Nothing in a chart or in printed output selects a row.
                 return .none
             case .data, .json, .map:
                 break
@@ -37,9 +30,7 @@ internal enum GridSelectionOwner: Equatable {
 
         switch tabType {
         case .table, .query:
-            /// Map writes into this channel itself: clicking a shape selects that row, and the
-            /// indices it writes are the data grid's display positions, resolved through
-            /// `DisplayRowMapping`.
+            // Map selects through the same model: a clicked shape selects its row.
             return .dataGrid
         case .createTable, .erDiagram, .serverDashboard, .usersRoles, .insights, .objectSource, .versionHistory,
              .tableListing:
diff --git a/apple/TablePro/Models/UI/MultiRowEditState.swift b/apple/TablePro/Models/UI/MultiRowEditState.swift
index 2d98137185..294d697f48 100644
--- a/apple/TablePro/Models/UI/MultiRowEditState.swift
+++ b/apple/TablePro/Models/UI/MultiRowEditState.swift
@@ -15,47 +15,38 @@ struct FieldEditState: Identifiable {
     let isLongText: Bool
     let isJson: Bool
 
-    /// Every selected cell that has a value holds bytes, one character per byte in `originalValue`.
-    /// The column type cannot say so: a spatial column is text on one engine and a blob on another.
+    // Read from the values, not the column type: a spatial column is text on one engine and a blob on another.
     var isBinaryValue: Bool = false
 
     var isPrimaryKey: Bool = false
     var isForeignKey: Bool = false
 
-    /// Set when the owning grid dictates the editor instead of the column type.
+    // Set when the owning grid dictates the editor instead of the column type.
     var editor: FieldEditorKind?
 
-    /// Which editor the field's own type and value ask for, resolved once here.
-    ///
-    /// Resolving it costs a full `JSONSerialization` parse of the value and a PHP-serialized parse
-    /// after it, and `FieldEditorResolver` was reached from two view bodies per field. Every hover,
-    /// every inspector tab switch and every pending-edit keystroke re-parsed every value in the row.
+    // Resolved once: it costs a JSONSerialization and a PHP-serialized parse, and view bodies re-parsed it on every hover.
     var resolvedEditor: FieldEditorKind?
 
-    /// A schema field has no data type, so it offers no type badge and no NULL or DEFAULT state.
+    // A schema field has no data type, so it offers no type badge and no NULL or DEFAULT state.
     var isSchemaField: Bool = false
 
-    /// The server owns the value, or refuses to change it on this kind of object, so the field is
-    /// shown without an editor. Refusing the edit further down instead would leave a pending value
-    /// here that nothing can clear, and the inspector would go on reporting an unsaved change that
-    /// Save never writes.
+    // Shown without an editor: refusing the edit further down left a pending value here that Save never writes.
     var isServerOwned: Bool = false
 
-    /// False for a NOT NULL column. Nil from the schema reads as nullable, as the grid's menus do.
+    // Nil from the schema reads as nullable, as the grid's menus do.
     var isNullable = true
 
-    /// Leaving the column out of an INSERT makes the server fill it, which is what Set DEFAULT gives.
+    // Leaving the column out of an INSERT makes the server fill it, which is what Set DEFAULT gives.
     var serverAssignsValue = false
 
     var displayFormat: ValueDisplayFormat?
 
-    /// A value the selected rows hold. A lengthless MySQL `CHAR` takes the compact UUID form only when its values do.
+    // A lengthless MySQL CHAR takes the compact UUID form only when its values do.
     var sampleText: String?
 
     var declaredType: String?
 
-    /// The edit is recorded elsewhere: by the grid that owns a schema row, or in the change manager for rows
-    /// that now disagree, which no single pending value can stand for.
+    // Recorded by the grid owning a schema row, or the change manager for rows that disagree, which no pending value can hold.
     var hasCommittedEdit: Bool = false
 
     var originalValue: String?
@@ -68,14 +59,12 @@ struct FieldEditState: Identifiable {
 
     var isPendingDefault: Bool
 
-    /// `pendingValue` is SQL from `CellExpressionVocabulary`, staged to be written unquoted.
+    // pendingValue is SQL from CellExpressionVocabulary, staged to be written unquoted.
     var isPendingExpression = false
 
-    /// No selected row has a field for the column, which only an engine that tells a missing field
-    /// from NULL reports.
+    // Only an engine that tells a missing field from NULL reports this.
     var isAbsent = false
 
-    /// The user asked for the field to be taken out of the row.
     var isPendingRemoval = false
 
     // A selected row's value is still on the server, so the field shows no value and takes no edit.
@@ -101,16 +90,14 @@ enum FieldEditContinuity {
     case discrete
 }
 
-/// A field the inspector writes itself, for the save that runs when no pending change holds its
-/// edits.
+// For the save that runs when no pending change holds the inspector's edits.
 struct InspectorFieldEdit: Equatable {
     let columnIndex: Int
     let columnName: String
     let newValue: String?
-    /// The edit takes the field out of the row, which `newValue` cannot say: it reads nil for NULL
-    /// as well.
+    // newValue cannot say this: it reads nil for NULL as well.
     var removesField = false
-    /// `newValue` is SQL picked from the field's menu, written unquoted.
+    // newValue is SQL picked from the field's menu, written unquoted.
     var isExpression = false
 }
 
@@ -118,51 +105,39 @@ struct InspectorFieldEdit: Equatable {
 final class MultiRowEditState: ObservableObject {
     @Published var fields: [FieldEditState] = []
 
-    /// A field's new literal value, and whether it arrived a character at a time. Typing is folded into one
-    /// undo step; choosing NULL, DEFAULT or a picker value is its own step.
+    // Typing folds into one undo step; choosing NULL, DEFAULT or a picker value is its own step.
     @Published var onFieldChanged: ((Int, PluginCellValue, FieldEditContinuity) -> Void)?
 
-    /// A field set to SQL the database evaluates, picked from its menu or typed. `onFieldChanged` cannot carry
-    /// that, and a plain `.text` must never be read as SQL.
+    // A plain .text must never be read as SQL, so an expression takes its own callback.
     @Published var onFieldExpressionChanged: ((Int, String, FieldEditContinuity) -> Void)?
 
-    /// A value of its own for each row, such as a fresh UUID: one value over several rows would repeat a key.
+    // A value per row, such as a fresh UUID: one value over several rows would repeat a key.
     @Published var onFieldValuesChanged: ((Int, [RowID: PluginCellValue]) -> Void)?
 
-    /// A field cleared back to what the rows held, when they disagree on it, some of them have
-    /// no field for it, or some held SQL. It has no single value to send, so it asks for each row's own
-    /// configured value instead, for the field to go missing again on the rows that lacked it (the first set),
-    /// and for SQL again on the rows that held it (the second).
+    // Disagreeing rows have no single value: each row's own value, plus the rows to make absent again and to restore SQL on.
     @Published var onFieldReverted: ((Int, [RowID: PluginCellValue], Set<RowID>, Set<RowID>) -> Void)?
 
-    /// Remove Field on a field, for the rows the selection was configured with.
     @Published var onFieldRemoved: ((Int, [RowID]) -> Void)?
 
-    /// A value window still open over a selection that has moved on. It names the rows it was
-    /// opened for, because the fields it was opened from are gone. The flag says the value is SQL.
+    // A value window outliving its selection names its rows, since its fields are gone; the flag says the value is SQL.
     @Published var onDetachedFieldChanged: ((Int, PluginCellValue, [RowID], Bool) -> Void)?
 
-    @Published private(set) var selectedRowIndices: Set<Int> = []
-
-    /// The rows an edit is staged against, captured when the selection was configured.
-    ///
-    /// `selectedRowIndices` are display positions, and a commit that resolves them when the
-    /// keystroke arrives writes into whatever row the sort, the value filter or a later selection
-    /// left at that position.
+    // The rows an edit is staged against, captured when the selection was configured, never a display position.
     @Published private(set) var rowIDs: [RowID] = []
+    // The schema row the fields came from, for a grid whose rows have no identity.
+    private var schemaDisplayRow: Int?
 
     @Published private(set) var allRows: [[String?]] = []
-    /// The columns each row in `allRows` has no field for.
+    // Per row of allRows: the columns it has no field for.
     @Published private(set) var absentCells: [Set<Int>] = []
     @Published private(set) var unloadedCells: [Set<Int>] = []
-    /// The columns each row in `allRows` holds staged SQL in.
+    // Per row of allRows: the columns holding staged SQL.
     @Published private(set) var expressionCells: [Set<Int>] = []
     @Published private(set) var columns: [String] = []
     @Published private(set) var columnTypes: [ColumnType] = []
     private var nonNullableColumns: Set<String> = []
 
-    /// The engine whose vocabulary typed text is read against, and what the table's writer takes. Nil and
-    /// `.none` offer no Set Value command and promote nothing.
+    // Nil and .none offer no Set Value command and promote nothing.
     private(set) var databaseType: DatabaseType?
     private(set) var cellWriter: CellWriterSupport = .none
     private(set) var rowsAreInserted = false
@@ -182,8 +157,7 @@ final class MultiRowEditState: ObservableObject {
     }
 
     func configure(
-        selectedRowIndices: Set<Int>,
-        rowIDs: [RowID] = [],
+        rowIDs: [RowID],
         allRows: [[String?]],
         absentCells: [Set<Int>] = [],
         unloadedCells: [Set<Int>] = [],
@@ -203,9 +177,9 @@ final class MultiRowEditState: ObservableObject {
         cellWriter: CellWriterSupport = .none
     ) {
         let columnsChanged = self.columns != columns
-        let selectionChanged = self.selectedRowIndices != selectedRowIndices
+        let selectionChanged = self.rowIDs != rowIDs || schemaDisplayRow != nil
 
-        self.selectedRowIndices = selectedRowIndices
+        schemaDisplayRow = nil
         self.rowIDs = rowIDs
         self.allRows = allRows
         self.absentCells = absentCells
@@ -267,11 +241,7 @@ final class MultiRowEditState: ObservableObject {
                 }
             }
 
-            /// A column edited elsewhere, in the grid or by an earlier inspector edit. A modified field that is now
-            /// missing is one an edit removed, and one that now reads NULL is a pending NULL: written as an empty
-            /// pending value it read as `''`, and the boolean picker showed false. Rows that now disagree stay
-            /// Multiple values: an empty pending value there read as one value, and typing into it looked like
-            /// editing a single cell.
+            // Edited elsewhere: as an empty pending value a NULL read as '' and disagreeing rows looked like one cell.
             if externallyModifiedColumns.contains(colIndex), pendingValue == nil, !isPendingNull, !isPendingDefault,
                !isPendingRemoval {
                 if isAbsent {
@@ -318,10 +288,7 @@ final class MultiRowEditState: ObservableObject {
             if let preservedId {
                 newField.id = preservedId
             }
-            /// The column's display format decides the editor here exactly as it does in the grid.
-            /// Without it the inspector resolved from the raw value alone, so a column the user had
-            /// set to JSON or PHP-serialized opened a plain text field in the inspector while the
-            /// grid rendered it structured.
+            // Same display format as the grid, or a column set to JSON or PHP-serialized opened a plain text field here.
             newField.resolvedEditor = FieldEditorResolver.resolve(
                 for: columnTypeEnum,
                 isLongText: isLongText,
@@ -336,8 +303,7 @@ final class MultiRowEditState: ObservableObject {
         self.fields = newFields
     }
 
-    /// The columns whose selected cells are bytes. One text cell rules a column out, because a
-    /// binary field commits bytes to every selected row, and a column of NULLs alone has none.
+    // One text cell rules a column out, since a binary field commits bytes to every row; an all-NULL column has none.
     static func binaryColumns(in rows: [[PluginCellValue]]) -> Set<Int> {
         var holdsBytes: [Bool] = []
         var holdsText: [Bool] = []
@@ -361,8 +327,7 @@ final class MultiRowEditState: ObservableObject {
         return Set(holdsBytes.indices.filter { holdsBytes[$0] && !holdsText[$0] })
     }
 
-    // A value holding an invisible character takes the text view only while marks are on, so a field
-    // shown when the setting changes is resolved again.
+    // An invisible-character value takes the text view only while marks are on, so a setting change re-resolves.
     private func adoptInvisibleCharacterSetting() {
         let reveals = AppSettingsManager.shared.dataGrid.showInvisibleCharacters
         guard reveals != revealsInvisibleCharacters else { return }
@@ -383,14 +348,12 @@ final class MultiRowEditState: ObservableObject {
         }
     }
 
-    /// Configure state for a single schema row supplied by the grid that owns the selection.
-    /// Field ids survive a reconfigure of the same row so a commit does not rebuild the
-    /// editors and drop focus while the user is still moving between fields.
+    // Field ids survive a reconfigure of the same row so a commit does not rebuild the editors and drop focus.
     func configure(schemaFields: [InspectorRowField], displayRow: Int) {
         let names = schemaFields.map(\.name)
-        let reusedIds = selectedRowIndices == [displayRow] && columns == names ? fields.map(\.id) : []
+        let reusedIds = schemaDisplayRow == displayRow && columns == names ? fields.map(\.id) : []
 
-        selectedRowIndices = [displayRow]
+        schemaDisplayRow = displayRow
         rowIDs = []
         absentCells = []
         unloadedCells = []
@@ -433,14 +396,13 @@ final class MultiRowEditState: ObservableObject {
         }
     }
 
-    /// What a field's editor is showing right now, read from the store rather than from a copy an
-    /// earlier render captured. This is what a field's value binding answers.
+    // Read from the store, not a copy an earlier render captured; a field's value binding answers with this.
     func currentText(at index: Int) -> String {
         guard fields.indices.contains(index) else { return "" }
         return FieldValueState.resolve(fields[index]).editableText
     }
 
-    /// What Set Value can do to the field, the same answer the grid's menu gives for the column.
+    // Same answer the grid's menu gives for the column.
     func setValueCommands(for field: FieldEditState, isWritable: Bool) -> [SetValueCommand] {
         setValueContext(for: field, isWritable: isWritable).map(SetValueOptions.commands(for:)) ?? []
     }
@@ -479,25 +441,20 @@ final class MultiRowEditState: ObservableObject {
         var pending = Self.resolvePendingValue(value, original: original, isJson: fields[index].isJson)
         let expression = pending.flatMap { typedExpression($0, columnType: fields[index].columnTypeEnum) }
         var staged = pending.map { PluginCellValue.entered($0, columnType: fields[index].columnTypeEnum) }
-        /// A NOT NULL column whose type has no empty value holds nothing an emptied field could
-        /// mean, so the field goes back to its stored value, as the grid's cell does.
+        // NOT NULL with no empty value for the type: the field goes back to its stored value, as the grid's cell does.
         if staged == .null, !fields[index].isNullable {
             pending = nil
             staged = nil
         }
         resetPending(at: index)
         fields[index].pendingValue = pending
-        /// The field keeps its empty text while the change it stages is NULL: swapping the editor
-        /// for the pending NULL pill would take the field away in the middle of typing a new value.
+        // The field keeps its empty text while staging NULL; the NULL pill would take it away mid-typing.
         if let expression {
             onFieldExpressionChanged?(index, expression, .typing)
         } else if let staged {
             onFieldChanged?(index, staged, .typing)
         } else if hadPendingEdit {
-            /// `originalValue` is nil for three different situations, and only one of them is a
-            /// value: a stored NULL, a selection whose rows do not agree, and a field the rows do
-            /// not have. Sending it as one value wrote NULL into every selected row when the user
-            /// cleared a field they all disagreed on, which the field then reported as unedited.
+            // originalValue nil is a stored NULL, disagreeing rows or a missing field; one value wrote NULL into every row.
             let absentRows = configuredAbsentRows(atColumn: index)
             let expressionRows = configuredExpressionRows(atColumn: index)
             if fields[index].hasMultipleValues || !absentRows.isEmpty || !expressionRows.isEmpty {
@@ -508,8 +465,7 @@ final class MultiRowEditState: ObservableObject {
         }
     }
 
-    /// The vocabulary's SQL for typed text, as the grid reads a typed cell. A value the rows were configured
-    /// with never comes through here, so stored text that spells a function stays text.
+    // Only typed text comes here, so stored text that spells a function stays text.
     private func typedExpression(_ text: String, columnType: ColumnType?) -> String? {
         guard let databaseType,
               let entry = CellEntry.typed(text, columnType: columnType, databaseType: databaseType, writer: cellWriter),
@@ -518,8 +474,7 @@ final class MultiRowEditState: ObservableObject {
         return sql
     }
 
-    /// What each row held when the selection was configured, which is what a field with no value of
-    /// its own reverts to.
+    // What a field with no value of its own reverts to.
     private func configuredValues(atColumn index: Int) -> [RowID: PluginCellValue] {
         var values: [RowID: PluginCellValue] = [:]
         for (rowID, row) in zip(rowIDs, allRows) where row.indices.contains(index) {
@@ -528,8 +483,7 @@ final class MultiRowEditState: ObservableObject {
         return values
     }
 
-    /// A binary field holds its bytes one character per byte. Sent back as text, that string is
-    /// staged over the blob as a real change, and SQLite cuts it at the first NUL.
+    // Sent back as text, a binary field's string is staged over the blob as a change, and SQLite cuts it at the first NUL.
     private func storedCell(_ value: String?, atColumn index: Int) -> PluginCellValue {
         guard let value else { return .null }
         guard fields.indices.contains(index), fields[index].isBinaryValue else { return .text(value) }
@@ -544,11 +498,7 @@ final class MultiRowEditState: ObservableObject {
         Set(rowIDs.indices.filter { expressionCells[safe: $0]?.contains(index) == true }.map { rowIDs[$0] })
     }
 
-    /// A commit from a detached value window, which outlives the selection it was opened from.
-    ///
-    /// While that selection is still the one on screen this is an ordinary field edit. Once it has
-    /// moved the fields no longer describe those rows, so the value goes straight to the rows the
-    /// window was opened for rather than into whatever is selected now.
+    // Once the selection has moved, the value goes to the rows the window was opened for, not to what is selected now.
     func updateDetachedField(columnIndex: Int, rowIDs: [RowID], value: String?) {
         guard !rowIDs.isEmpty else { return }
         if self.rowIDs == rowIDs, fields.indices.contains(columnIndex) {
@@ -600,11 +550,7 @@ final class MultiRowEditState: ObservableObject {
         onFieldChanged?(index, .null, .discrete)
     }
 
-    /// Takes the field out of every selected row. The value is gone as well, so it reads as
-    /// neither NULL nor any value.
-    ///
-    /// Rows that had no field for it when the selection was configured are back as they were,
-    /// which leaves nothing pending, exactly as typing a field's own value back does.
+    // Rows that had no field to begin with are back as they were, so nothing is pending for them.
     func removeField(at index: Int) {
         guard index < fields.count, !rowIDs.isEmpty else { return }
         resetPending(at: index)
@@ -627,8 +573,7 @@ final class MultiRowEditState: ObservableObject {
         onFieldExpressionChanged?(index, expression.sql, .discrete)
     }
 
-    /// Several rows each get a UUID of their own, so the field then reads Multiple values, and typing over it
-    /// writes the typed value to every row as on any field the rows disagree on.
+    // Each row gets its own UUID, so the field then reads Multiple values.
     func generateUUID(at index: Int, version: UUIDVersion, generator: UUIDValueGenerator = .shared) {
         guard fields.indices.contains(index),
               let context = setValueContext(for: fields[index], isWritable: true),
@@ -651,8 +596,7 @@ final class MultiRowEditState: ObservableObject {
             rowIDs.map { ($0, form.value(for: generator.make(version))) },
             uniquingKeysWith: { first, _ in first }
         )
-        /// The rows hold these values now, so clearing a later edit goes back to them, as it does once the
-        /// inspector is rebuilt from the rows.
+        // Clearing a later edit goes back to these values, as it does once the inspector is rebuilt from the rows.
         for (position, rowID) in rowIDs.enumerated() {
             guard let value = values[rowID], allRows.indices.contains(position),
                   allRows[position].indices.contains(index) else { continue }
@@ -703,7 +647,7 @@ final class MultiRowEditState: ObservableObject {
         onFieldReverted = nil
         onFieldRemoved = nil
         onDetachedFieldChanged = nil
-        selectedRowIndices = []
+        schemaDisplayRow = nil
         rowIDs = []
         allRows = []
         absentCells = []
diff --git a/apple/TablePro/Models/UI/TabFindState.swift b/apple/TablePro/Models/UI/TabFindState.swift
deleted file mode 100644
index ae248fc7e2..0000000000
--- a/apple/TablePro/Models/UI/TabFindState.swift
+++ /dev/null
@@ -1,93 +0,0 @@
-//
-//  TabFindState.swift
-//  TablePro
-//
-
-import Foundation
-
-struct FindMatch: Equatable, Hashable {
-    let displayRow: Int
-    let columnIndex: Int
-}
-
-enum FindScope: Equatable {
-    case allRowsLoaded
-    case pageOfMore
-}
-
-struct TabFindState: Equatable {
-    var term: String
-    var isVisible: Bool
-    var matches: [FindMatch]
-    var currentMatchIndex: Int?
-    var scope: FindScope
-
-    init(isVisible: Bool = false) {
-        term = ""
-        self.isVisible = isVisible
-        matches = []
-        currentMatchIndex = nil
-        scope = .allRowsLoaded
-    }
-
-    var currentMatch: FindMatch? {
-        guard let index = currentMatchIndex, index >= 0, index < matches.count else { return nil }
-        return matches[index]
-    }
-
-    var canEscalateToAllRows: Bool {
-        scope == .pageOfMore && !term.isEmpty
-    }
-
-    mutating func clearMatches() {
-        matches = []
-        currentMatchIndex = nil
-    }
-
-    mutating func stepForward() {
-        guard !matches.isEmpty else { return }
-        guard let index = currentMatchIndex else {
-            currentMatchIndex = 0
-            return
-        }
-        currentMatchIndex = (index + 1) % matches.count
-    }
-
-    mutating func stepBackward() {
-        guard !matches.isEmpty else { return }
-        guard let index = currentMatchIndex else {
-            currentMatchIndex = matches.count - 1
-            return
-        }
-        currentMatchIndex = (index - 1 + matches.count) % matches.count
-    }
-}
-
-enum FindCounterText {
-    static func text(matchCount: Int, currentIndex: Int?, scope: FindScope) -> String {
-        guard matchCount > 0 else { return emptyText(scope: scope) }
-
-        let position = (currentIndex ?? 0) + 1
-        switch scope {
-        case .allRowsLoaded:
-            return String(
-                format: String(localized: "%1$@ of %2$@"),
-                position.formatted(),
-                matchCount.formatted()
-            )
-        case .pageOfMore:
-            return String(
-                format: String(localized: "%1$@ of %2$@ on this page"),
-                position.formatted(),
-                matchCount.formatted()
-            )
-        }
-    }
-
-    private static func emptyText(scope: FindScope) -> String {
-        switch scope {
-        case .allRowsLoaded: String(localized: "No matches")
-        case .pageOfMore: String(localized: "Not on this page")
-        }
-    }
-}
diff --git a/apple/TablePro/Resources/Localizable.xcstrings b/apple/TablePro/Resources/Localizable.xcstrings
index eda57dfcda..adfb8a9735 100644
--- a/apple/TablePro/Resources/Localizable.xcstrings
+++ b/apple/TablePro/Resources/Localizable.xcstrings
@@ -22889,6 +22889,9 @@
           }
         }
       }
+    },
+    "All Columns" : {
+
     },
     "All columns visible" : {
       "localizations" : {
@@ -158219,6 +158222,9 @@
     },
     "Search Icons" : {
 
+    },
+    "Search In" : {
+
     },
     "Search index %1$@ uses %2$@. Change or drop that search index first, then save again." : {
       "extractionState" : "manual",
@@ -158454,6 +158460,9 @@
           }
         }
       }
+    },
+    "Search stopped" : {
+
     },
     "Search tables, views, databases, queries…" : {
       "localizations" : {
@@ -168631,6 +168640,16 @@
         }
       }
     },
+    "Sort key %d of %d, %@" : {
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "new",
+            "value" : "Sort key %1$d of %2$d, %3$@"
+          }
+        }
+      }
+    },
     "Sorted ascending" : {
       "localizations" : {
         "fr" : {
diff --git a/apple/TablePro/Resources/Themes/tablepro.catppuccin-latte.json b/apple/TablePro/Resources/Themes/tablepro.catppuccin-latte.json
index 8cf7be7217..385ce65b3c 100644
--- a/apple/TablePro/Resources/Themes/tablepro.catppuccin-latte.json
+++ b/apple/TablePro/Resources/Themes/tablepro.catppuccin-latte.json
@@ -8,17 +8,11 @@
     "boolTrue": "#40A02B",
     "deleted": "#D20F3926",
     "deletedText": "#D20F3980",
-    "focusBorder": "#8839EF",
     "gridLine": "#BCC0CC",
-    "headerBackground": "#E6E9EF",
-    "headerText": "#4C4F69",
-    "inactiveSelection": "#CCD0DA",
     "inserted": "#40A02B26",
     "modified": "#DF8E1D26",
     "nullValue": "#7C7F93",
     "rowNumber": "#8C8FA1",
-    "selection": "#CCD0DA",
-    "selectionText": "#4C4F69",
     "text": "#4C4F69"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.catppuccin-mocha.json b/apple/TablePro/Resources/Themes/tablepro.catppuccin-mocha.json
index 2ce5a2d0e8..3a72c559ef 100644
--- a/apple/TablePro/Resources/Themes/tablepro.catppuccin-mocha.json
+++ b/apple/TablePro/Resources/Themes/tablepro.catppuccin-mocha.json
@@ -8,17 +8,11 @@
     "boolTrue": "#A6E3A1",
     "deleted": "#F38BA826",
     "deletedText": "#F38BA880",
-    "focusBorder": "#CBA6F7",
     "gridLine": "#45475A",
-    "headerBackground": "#181825",
-    "headerText": "#CDD6F4",
-    "inactiveSelection": "#313244",
     "inserted": "#A6E3A126",
     "modified": "#F9E2AF26",
     "nullValue": "#9399B2",
     "rowNumber": "#7F849C",
-    "selection": "#313244",
-    "selectionText": "#CDD6F4",
     "text": "#CDD6F4"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.dracula.json b/apple/TablePro/Resources/Themes/tablepro.dracula.json
index 94a1575329..c1bf304da2 100644
--- a/apple/TablePro/Resources/Themes/tablepro.dracula.json
+++ b/apple/TablePro/Resources/Themes/tablepro.dracula.json
@@ -8,17 +8,11 @@
     "boolTrue": "#50FA7B",
     "deleted": "#FF555526",
     "deletedText": "#FF555580",
-    "focusBorder": "#BD93F9",
     "gridLine": "#44475A",
-    "headerBackground": "#21222C",
-    "headerText": "#F8F8F2",
-    "inactiveSelection": "#44475A80",
     "inserted": "#50FA7B26",
     "modified": "#FFB86C4D",
     "nullValue": "#6272A4",
     "rowNumber": "#6272A4",
-    "selection": "#44475A",
-    "selectionText": "#F8F8F2",
     "text": "#F8F8F2"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.github-dark.json b/apple/TablePro/Resources/Themes/tablepro.github-dark.json
index cb921d592e..c941acf3d1 100644
--- a/apple/TablePro/Resources/Themes/tablepro.github-dark.json
+++ b/apple/TablePro/Resources/Themes/tablepro.github-dark.json
@@ -8,17 +8,11 @@
     "boolTrue": "#3FB950",
     "deleted": "#F8514926",
     "deletedText": "#F8514980",
-    "focusBorder": "#1F6FEB",
     "gridLine": "#30363D",
-    "headerBackground": "#161B22",
-    "headerText": "#E6EDF3",
-    "inactiveSelection": "#343941",
     "inserted": "#2EA04326",
     "modified": "#BB800926",
     "nullValue": "#8B949E",
     "rowNumber": "#6E7681",
-    "selection": "#142744",
-    "selectionText": "#E6EDF3",
     "text": "#E6EDF3"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.github-light.json b/apple/TablePro/Resources/Themes/tablepro.github-light.json
index b18d295e08..24f5eeb8ea 100644
--- a/apple/TablePro/Resources/Themes/tablepro.github-light.json
+++ b/apple/TablePro/Resources/Themes/tablepro.github-light.json
@@ -8,17 +8,11 @@
     "boolTrue": "#1A7F37",
     "deleted": "#FF818226",
     "deletedText": "#CF222E80",
-    "focusBorder": "#0969DA",
     "gridLine": "#D0D7DE",
-    "headerBackground": "#F6F8FA",
-    "headerText": "#1F2328",
-    "inactiveSelection": "#EFF1F3",
     "inserted": "#4AC26B26",
     "modified": "#D4A72C26",
     "nullValue": "#6E7781",
     "rowNumber": "#8C959F",
-    "selection": "#CEE1F8",
-    "selectionText": "#1F2328",
     "text": "#1F2328"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.gruvbox-dark.json b/apple/TablePro/Resources/Themes/tablepro.gruvbox-dark.json
index 7cb0d25f12..0a9fa77e46 100644
--- a/apple/TablePro/Resources/Themes/tablepro.gruvbox-dark.json
+++ b/apple/TablePro/Resources/Themes/tablepro.gruvbox-dark.json
@@ -8,17 +8,11 @@
     "boolTrue": "#B8BB26",
     "deleted": "#FB493426",
     "deletedText": "#FB493480",
-    "focusBorder": "#689D6A",
     "gridLine": "#504945",
-    "headerBackground": "#32302F",
-    "headerText": "#EBDBB2",
-    "inactiveSelection": "#3C3836",
     "inserted": "#B8BB2626",
     "modified": "#D7992126",
     "nullValue": "#928374",
     "rowNumber": "#665C54",
-    "selection": "#384539",
-    "selectionText": "#EBDBB2",
     "text": "#EBDBB2"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.gruvbox-light.json b/apple/TablePro/Resources/Themes/tablepro.gruvbox-light.json
index 2ef6cd9cf9..cab686b6db 100644
--- a/apple/TablePro/Resources/Themes/tablepro.gruvbox-light.json
+++ b/apple/TablePro/Resources/Themes/tablepro.gruvbox-light.json
@@ -8,17 +8,11 @@
     "boolTrue": "#79740E",
     "deleted": "#9D000626",
     "deletedText": "#9D000680",
-    "focusBorder": "#427B58",
     "gridLine": "#D5C4A1",
-    "headerBackground": "#F2E5BC",
-    "headerText": "#3C3836",
-    "inactiveSelection": "#EBDBB2",
     "inserted": "#79740E26",
     "modified": "#D7992126",
     "nullValue": "#928374",
     "rowNumber": "#BDAE93",
-    "selection": "#D6DCB0",
-    "selectionText": "#3C3836",
     "text": "#3C3836"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.nord.json b/apple/TablePro/Resources/Themes/tablepro.nord.json
index a2b30e1b3b..5ec322af04 100644
--- a/apple/TablePro/Resources/Themes/tablepro.nord.json
+++ b/apple/TablePro/Resources/Themes/tablepro.nord.json
@@ -8,17 +8,11 @@
     "boolTrue": "#A3BE8C",
     "deleted": "#BF616A26",
     "deletedText": "#BF616A80",
-    "focusBorder": "#88C0D0",
     "gridLine": "#434C5E",
-    "headerBackground": "#3B4252",
-    "headerText": "#D8DEE9",
-    "inactiveSelection": "#434C5E80",
     "inserted": "#A3BE8C26",
     "modified": "#EBCB8B4D",
     "nullValue": "#4C566A",
     "rowNumber": "#4C566A",
-    "selection": "#434C5E",
-    "selectionText": "#ECEFF4",
     "text": "#D8DEE9"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.one-dark.json b/apple/TablePro/Resources/Themes/tablepro.one-dark.json
index f9098d550a..c350fa8510 100644
--- a/apple/TablePro/Resources/Themes/tablepro.one-dark.json
+++ b/apple/TablePro/Resources/Themes/tablepro.one-dark.json
@@ -8,17 +8,11 @@
     "boolTrue": "#98C379",
     "deleted": "#E0525226",
     "deletedText": "#E06C7580",
-    "focusBorder": "#528BFF",
     "gridLine": "#3E4452",
-    "headerBackground": "#21252B",
-    "headerText": "#ABB2BF",
-    "inactiveSelection": "#323842",
     "inserted": "#43D08A26",
     "modified": "#E0C28526",
     "nullValue": "#7F848E",
     "rowNumber": "#636D83",
-    "selection": "#3E4451",
-    "selectionText": "#D7DAE0",
     "text": "#ABB2BF"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.one-light.json b/apple/TablePro/Resources/Themes/tablepro.one-light.json
index 0af9b52720..63451b4990 100644
--- a/apple/TablePro/Resources/Themes/tablepro.one-light.json
+++ b/apple/TablePro/Resources/Themes/tablepro.one-light.json
@@ -8,17 +8,11 @@
     "boolTrue": "#50A14F",
     "deleted": "#FF141426",
     "deletedText": "#E4564980",
-    "focusBorder": "#526FFF",
     "gridLine": "#DBDBDC",
-    "headerBackground": "#EAEAEB",
-    "headerText": "#383A42",
-    "inactiveSelection": "#DBDBDC",
     "inserted": "#2DB44826",
     "modified": "#F2A60D26",
     "nullValue": "#A0A1A7",
     "rowNumber": "#9D9D9F",
-    "selection": "#DBDBDC",
-    "selectionText": "#232324",
     "text": "#383A42"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.solarized-dark.json b/apple/TablePro/Resources/Themes/tablepro.solarized-dark.json
index 7f7374fcab..07b0431b68 100644
--- a/apple/TablePro/Resources/Themes/tablepro.solarized-dark.json
+++ b/apple/TablePro/Resources/Themes/tablepro.solarized-dark.json
@@ -8,17 +8,11 @@
     "boolTrue": "#859900",
     "deleted": "#DC322F26",
     "deletedText": "#DC322F80",
-    "focusBorder": "#2AA198",
     "gridLine": "#23464F",
-    "headerBackground": "#00212B",
-    "headerText": "#93A1A1",
-    "inactiveSelection": "#003846",
     "inserted": "#85990026",
     "modified": "#B5890026",
     "nullValue": "#586E75",
     "rowNumber": "#586E75",
-    "selection": "#005A6F",
-    "selectionText": "#EEE8D5",
     "text": "#839496"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.solarized-light.json b/apple/TablePro/Resources/Themes/tablepro.solarized-light.json
index 9ff51235cf..5b8e6e2967 100644
--- a/apple/TablePro/Resources/Themes/tablepro.solarized-light.json
+++ b/apple/TablePro/Resources/Themes/tablepro.solarized-light.json
@@ -8,17 +8,11 @@
     "boolTrue": "#859900",
     "deleted": "#DC322F26",
     "deletedText": "#DC322F80",
-    "focusBorder": "#268BD2",
     "gridLine": "#DDD6C1",
-    "headerBackground": "#EEE8D5",
-    "headerText": "#586E75",
-    "inactiveSelection": "#EEE0B5",
     "inserted": "#85990026",
     "modified": "#B5890026",
     "nullValue": "#93A1A1",
     "rowNumber": "#93A1A1",
-    "selection": "#DFCA88",
-    "selectionText": "#073642",
     "text": "#657B83"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.tokyo-night-light.json b/apple/TablePro/Resources/Themes/tablepro.tokyo-night-light.json
index 02342393c3..d99ba60db0 100644
--- a/apple/TablePro/Resources/Themes/tablepro.tokyo-night-light.json
+++ b/apple/TablePro/Resources/Themes/tablepro.tokyo-night-light.json
@@ -8,17 +8,11 @@
     "boolTrue": "#385F0D",
     "deleted": "#E8686826",
     "deletedText": "#8C435180",
-    "focusBorder": "#2959AA",
     "gridLine": "#C1C2C7",
-    "headerBackground": "#D6D8DF",
-    "headerText": "#343B59",
-    "inactiveSelection": "#C9CBD6",
     "inserted": "#2D9C9126",
     "modified": "#8F5E1526",
     "nullValue": "#888B94",
     "rowNumber": "#9DA0AB",
-    "selection": "#ACB0BF",
-    "selectionText": "#343B59",
     "text": "#343B59"
   },
   "editor": {
diff --git a/apple/TablePro/Resources/Themes/tablepro.tokyo-night.json b/apple/TablePro/Resources/Themes/tablepro.tokyo-night.json
index 3fa07811f3..5dcca7b6ae 100644
--- a/apple/TablePro/Resources/Themes/tablepro.tokyo-night.json
+++ b/apple/TablePro/Resources/Themes/tablepro.tokyo-night.json
@@ -8,17 +8,11 @@
     "boolTrue": "#9ECE6A",
     "deleted": "#DB4B4B26",
     "deletedText": "#F7768E80",
-    "focusBorder": "#7AA2F7",
     "gridLine": "#232433",
-    "headerBackground": "#16161E",
-    "headerText": "#A9B1D6",
-    "inactiveSelection": "#222433",
     "inserted": "#41A6B526",
     "modified": "#E0AF6826",
     "nullValue": "#51597D",
     "rowNumber": "#363B54",
-    "selection": "#2B2F41",
-    "selectionText": "#A9B1D6",
     "text": "#A9B1D6"
   },
   "editor": {
diff --git a/apple/TablePro/Theme/ThemeColor.swift b/apple/TablePro/Theme/ThemeColor.swift
index f302a86e11..49ed7e7f06 100644
--- a/apple/TablePro/Theme/ThemeColor.swift
+++ b/apple/TablePro/Theme/ThemeColor.swift
@@ -11,7 +11,7 @@ internal extension ThemeColor {
         )
     }
 
-    /// A color that cannot convert to sRGB, a pattern for one, becomes mid grey rather than failing.
+    // A color with no sRGB form, a pattern for one, becomes mid grey rather than failing.
     init(_ color: NSColor) {
         guard let converted = color.usingColorSpace(.sRGB) else {
             self.init(red: 0x80, green: 0x80, blue: 0x80)
@@ -41,10 +41,7 @@ internal enum HexColor {
 }
 
 internal extension ThemeSlot {
-    /// What the slot draws when no theme overrides it: the color AppKit itself uses on that
-    /// surface. Every value is dynamic, so it resolves against the drawing view's own appearance,
-    /// accent, highlight and contrast. A tint is built inside a provider, because
-    /// `withAlphaComponent` on a system color outside one freezes it at the current appearance.
+    // A tint is built inside a provider: `withAlphaComponent` on a system color outside one freezes it.
     var nativeColor: NSColor {
         switch self {
         case .windowBackdrop: return .windowBackgroundColor
@@ -65,13 +62,7 @@ internal extension ThemeSlot {
         case .gridBackground: return .controlBackgroundColor
         case .gridText, .gridBoolTrue, .gridBoolFalse: return .labelColor
         case .gridAlternateRow: return NativeThemeColors.alternateRow
-        case .gridHeaderBackground: return .controlBackgroundColor
-        case .gridHeaderText: return .headerTextColor
         case .gridLine: return .separatorColor
-        case .gridSelection: return .selectedContentBackgroundColor
-        case .gridSelectionText: return .alternateSelectedControlTextColor
-        case .gridInactiveSelection: return .unemphasizedSelectedContentBackgroundColor
-        case .gridFocusBorder: return .keyboardFocusIndicatorColor
         case .gridNullValue: return .secondaryLabelColor
         case .gridRowNumber: return .secondaryLabelColor
         case .gridModified: return NativeThemeColors.modifiedRow
@@ -83,8 +74,7 @@ internal extension ThemeSlot {
 }
 
 internal enum NativeThemeColors {
-    /// macOS 14 draws the caret in the Highlight color through `textInsertionPointColor`. Earlier
-    /// releases draw it in the text color.
+    // macOS 14 draws the caret in the Highlight color; earlier releases in the text color.
     static let insertionPoint: NSColor = {
         if #available(macOS 14.0, *) {
             return .textInsertionPointColor
@@ -92,8 +82,7 @@ internal enum NativeThemeColors {
         return .textColor
     }()
 
-    /// No system color exists for a current-line band; a faint accent keeps it on the user's
-    /// Accent color the way the selection and focus ring are.
+    // No system color exists for a current-line band; a faint accent follows Accent like the selection.
     static let currentLine = NSColor(name: NSColor.Name("tablepro.native.currentLine")) { appearance in
         NSColor.controlAccentColor.withAlphaComponent(appearance.isDarkTheme ? 0.14 : 0.08)
     }
diff --git a/apple/TablePro/Theme/ThemeTableChrome.swift b/apple/TablePro/Theme/ThemeTableChrome.swift
index 2b62a0d772..b65bf2a13c 100644
--- a/apple/TablePro/Theme/ThemeTableChrome.swift
+++ b/apple/TablePro/Theme/ThemeTableChrome.swift
@@ -3,20 +3,11 @@ import Combine
 import SwiftUI
 import TableProTheme
 
-/// Themes an `NSTableView` or `NSOutlineView` that shows content. Never a source list: its selection
-/// and background belong to the sidebar glass, which draws them without calling the row view.
-///
-/// A property is written only while the active theme sets its slot, and gets back the value it had
-/// once the theme stops, so under a default theme the table is exactly what AppKit draws. Rows take
-/// the theme's background and selection through a `ThemeTableRowDrawing` row, and only while the
-/// theme sets one of them: a row class that overrides a drawing method leaves AppKit's layer-backed
-/// selection, the vibrant material in a popover among them.
+// Never on a source list: the sidebar glass draws its selection and background without calling the row view.
 @MainActor
 internal final class ThemeTableChrome {
     internal enum Family {
-        /// Records and schema objects, on the data grid's slots.
         case records
-        /// Values and code, on the editor's slots.
         case code
 
         internal var background: ThemeSlot {
@@ -40,17 +31,10 @@ internal final class ThemeTableChrome {
             }
         }
 
-        /// The data grid's header slots. A code table's header, where it has one, stays AppKit's.
-        internal var headerSlots: [ThemeSlot] {
+        // A records table's selection is always the system's, as the data grid's is.
+        internal var selection: ThemeSlot? {
             switch self {
-            case .records: return [.gridHeaderBackground, .gridHeaderText]
-            case .code: return []
-            }
-        }
-
-        internal func selection(emphasized: Bool) -> ThemeSlot {
-            switch self {
-            case .records: return emphasized ? .gridSelection : .gridInactiveSelection
+            case .records: return nil
             case .code: return .editorSelection
             }
         }
@@ -64,12 +48,9 @@ internal final class ThemeTableChrome {
     internal let family: Family
     internal let scope: ThemeScope
 
-    /// True while the theme sets the rows' background or a selection, which only a themed row class
-    /// draws. A delegate returns AppKit's own row view otherwise.
+    // A row class that overrides a drawing method loses AppKit's layer-backed selection, so it is used only while needed.
     internal private(set) var themesRows = false
 
-    /// True while the rows are rebuilt for a new row class. The expansion and selection AppKit
-    /// reports meanwhile are the ones the table already had.
     internal private(set) var isRebuildingRows = false
 
     private weak var tableView: NSTableView?
@@ -77,11 +58,9 @@ internal final class ThemeTableChrome {
     private weak var themedScrollView: NSScrollView?
     private var scrollViewDrewBackground = true
     private var originalGridColor: NSColor?
-    private var originalHeaderView: NSTableHeaderView?
-    private var originalCornerView: NSView?
     private var themeCancellable: AnyCancellable?
 
-    /// Attach before the table builds its rows, and once it is inside its scroll view.
+    // Attach before the table builds its rows, and once it is inside its scroll view.
     internal init(tableView: NSTableView, family: Family, scope: ThemeScope = .live) {
         self.tableView = tableView
         self.family = family
@@ -95,18 +74,12 @@ internal final class ThemeTableChrome {
         backgroundOriginals != nil
     }
 
-    /// True while the table's header is a `ThemeTableHeaderView` in place of the one its owner gave it.
-    internal var isHeaderThemed: Bool {
-        originalHeaderView != nil
-    }
-
     internal func apply() {
         restyle()
         guard let tableView, hasStaleRows(in: tableView) else { return }
         rebuildRows(of: tableView)
     }
 
-    /// Nil while the theme leaves the rows alone, so the table builds AppKit's own row view.
     internal func makeRowView(in tableView: NSTableView) -> ThemeTableRowView? {
         guard themesRows else { return nil }
         let reused = tableView.makeView(withIdentifier: ThemeTableRowView.reuseIdentifier, owner: nil)
@@ -116,8 +89,7 @@ internal final class ThemeTableChrome {
         return rowView
     }
 
-    /// Nil while the theme leaves the background alone, and the row draws AppKit's. A themed table
-    /// stripes its rows itself: AppKit's stripes are the system pair whatever the table's color.
+    // AppKit's stripes are the system pair whatever the table's color, so a themed table stripes itself.
     internal func rowBackgroundColor(forRow row: Int) -> NSColor? {
         guard let originals = backgroundOriginals, row >= 0 else { return nil }
         let palette = scope.palette
@@ -127,15 +99,13 @@ internal final class ThemeTableChrome {
         return palette[alternate]
     }
 
-    /// Nil unless the theme sets its own selection, so a default theme keeps AppKit's, which follows
-    /// Accent and focus.
-    internal func selectionColor(emphasized: Bool) -> NSColor? {
+    internal func selectionColor(emphasized _: Bool) -> NSColor? {
+        guard let slot = family.selection else { return nil }
         let resolved = scope.resolved
-        let slot = family.selection(emphasized: emphasized)
         return resolved.isOverridden(slot) ? resolved[slot] : nil
     }
 
-    internal func isOnThemedSelection(_ rowView: NSTableRowView) -> Bool {
+    private func isOnThemedSelection(_ rowView: NSTableRowView) -> Bool {
         rowView.isSelected && selectionColor(emphasized: rowView.isEmphasized) != nil
     }
 
@@ -145,13 +115,10 @@ internal final class ThemeTableChrome {
         let backgroundSlots = [family.background] + [family.alternateRow].compactMap { $0 }
         applyBackground(to: tableView, themed: backgroundSlots.contains { resolved.isOverridden($0) })
         applyGridColor(to: tableView, themed: family.gridLine.map { resolved.isOverridden($0) } ?? false)
-        applyHeader(to: tableView, themed: family.headerSlots.contains { resolved.isOverridden($0) })
-        let selectionSlots = [family.selection(emphasized: true), family.selection(emphasized: false)]
-        themesRows = isBackgroundThemed || selectionSlots.contains { resolved.isOverridden($0) }
+        themesRows = isBackgroundThemed || family.selection.map { resolved.isOverridden($0) } ?? false
         tableView.needsDisplay = true
         tableView.enumerateAvailableRowViews { rowView, _ in
             rowView.needsDisplay = true
-            (rowView as? ThemeTableRowView)?.publishSelection()
         }
     }
 
@@ -164,8 +131,8 @@ internal final class ThemeTableChrome {
         return isStale
     }
 
-    /// AppKit asks for a row view only when it builds a row, so a new class needs a reload. An
-    /// outline drops its selection on a reload, and the clip view clamps while rows are rebuilt.
+    // AppKit asks for a row view only when it builds a row, so a new class needs a reload. An outline
+    // drops its selection on a reload, and the clip view clamps while rows are rebuilt.
     private func rebuildRows(of tableView: NSTableView) {
         isRebuildingRows = true
         defer { isRebuildingRows = false }
@@ -200,8 +167,7 @@ internal final class ThemeTableChrome {
         outlineView.selectRowIndexes(rows, byExtendingSelection: false)
     }
 
-    /// The scroll view's own background is the content-background material; a themed table drops it
-    /// so the material never shows through an elastic scroll.
+    // The scroll view's own background is the content-background material, which an elastic scroll would show.
     private func applyBackground(to tableView: NSTableView, themed: Bool) {
         guard themed else {
             restoreBackground(of: tableView)
@@ -251,124 +217,18 @@ internal final class ThemeTableChrome {
         }
         tableView.gridColor = scope.palette[slot]
     }
-
-    /// AppKit's header paints its own band over anything beneath it, so a themed header is ours and
-    /// the owner's comes back when the theme stops coloring it.
-    private func applyHeader(to tableView: NSTableView, themed: Bool) {
-        guard themed else {
-            restoreHeader(of: tableView)
-            return
-        }
-        if let header = tableView.headerView as? ThemeTableHeaderView, header.chrome === self {
-            header.needsDisplay = true
-            tableView.cornerView?.needsDisplay = true
-            return
-        }
-        guard let original = tableView.headerView else { return }
-        originalHeaderView = original
-        originalCornerView = tableView.cornerView
-
-        let header = ThemeTableHeaderView(frame: original.frame)
-        header.chrome = self
-        header.menu = original.menu
-        tableView.headerView = header
-        let corner = ThemeTableCornerView(frame: originalCornerView?.frame ?? .zero)
-        corner.chrome = self
-        tableView.cornerView = corner
-    }
-
-    private func restoreHeader(of tableView: NSTableView) {
-        guard let original = originalHeaderView else { return }
-        tableView.headerView = original
-        tableView.cornerView = originalCornerView
-        originalHeaderView = nil
-        originalCornerView = nil
-    }
-}
-
-// MARK: - Header
-
-/// Drawn like the data grid's header. Each title goes through its cell's interior drawing, which
-/// keeps AppKit's alignment and truncation. The sort indicator is drawn here because AppKit draws it
-/// from the header view's own pass, which this replaces.
-internal final class ThemeTableHeaderView: NSTableHeaderView {
-    internal weak var chrome: ThemeTableChrome?
-
-    override internal func draw(_ dirtyRect: NSRect) {
-        guard let chrome, let tableView else {
-            super.draw(dirtyRect)
-            return
-        }
-        let scope = chrome.scope
-        SortableHeaderChrome.fillBackground(dirtyRect, scope: scope)
-        let textColor = scope.resolved[.gridHeaderText]
-        let dragged = draggedColumn
-        for index in tableView.tableColumns.indices where index != dragged {
-            drawHeading(ofColumn: index, at: headerRect(ofColumn: index), in: dirtyRect, textColor: textColor, scope: scope)
-        }
-        // A column being dragged follows the pointer over its neighbours, as AppKit's header draws it.
-        if dragged >= 0, dragged < tableView.tableColumns.count {
-            let floating = headerRect(ofColumn: dragged).offsetBy(dx: draggedDistance, dy: 0)
-            if floating.intersects(dirtyRect) {
-                SortableHeaderChrome.fillBackground(floating, scope: scope)
-            }
-            drawHeading(ofColumn: dragged, at: floating, in: dirtyRect, textColor: textColor, scope: scope)
-        }
-        SortableHeaderChrome.drawBottomSeparator(in: bounds, scope: scope)
-    }
-
-    private func drawHeading(ofColumn index: Int, at heading: NSRect, in dirtyRect: NSRect, textColor: NSColor, scope: ThemeScope) {
-        guard let tableView, heading.width > 0, heading.intersects(dirtyRect) else { return }
-        let column = tableView.tableColumns[index]
-        let cell = column.headerCell
-        let nativeTextColor = cell.textColor
-        cell.textColor = textColor
-        if let sort = sortState(of: column, in: tableView) {
-            var title = heading
-            title.size.width = max(0, cell.sortIndicatorRect(forBounds: heading).minX - heading.minX)
-            cell.drawInterior(withFrame: title, in: self)
-            cell.drawSortIndicator(withFrame: heading, in: self, ascending: sort.ascending, priority: sort.priority)
-        } else {
-            cell.drawInterior(withFrame: heading, in: self)
-        }
-        cell.textColor = nativeTextColor
-        SortableHeaderChrome.drawColumnDivider(in: heading, scope: scope)
-    }
-
-    /// AppKit shows only the primary sort key's indicator.
-    private func sortState(of column: NSTableColumn, in tableView: NSTableView) -> (ascending: Bool, priority: Int)? {
-        guard let key = column.sortDescriptorPrototype?.key,
-              let primary = tableView.sortDescriptors.first, primary.key == key
-        else { return nil }
-        return (primary.ascending, 0)
-    }
-}
-
-/// The square over the vertical scroller beside a themed header, which AppKit would paint in its own
-/// header band.
-internal final class ThemeTableCornerView: NSView {
-    internal weak var chrome: ThemeTableChrome?
-
-    override internal var isFlipped: Bool { true }
-
-    override internal func draw(_ dirtyRect: NSRect) {
-        let scope = chrome?.scope ?? .live
-        SortableHeaderChrome.fillBackground(dirtyRect, scope: scope)
-        SortableHeaderChrome.drawBottomSeparator(in: bounds, scope: scope)
-    }
 }
 
 // MARK: - Row drawing
 
-/// A row class that draws through its `ThemeTableChrome`. Each row class forwards its drawing
-/// overrides here, so they exist only on a class the table uses while the theme draws its rows.
+// Each row class forwards its drawing overrides here, so they exist only on a class the table uses
+// while the theme draws its rows.
 @MainActor
 internal protocol ThemeTableRowDrawing: NSTableRowView {
     var chrome: ThemeTableChrome? { get set }
 }
 
 internal extension ThemeTableChrome {
-    /// False while the theme leaves the row's background alone, and the row draws AppKit's.
     func drawBackground(of rowView: NSTableRowView, in dirtyRect: NSRect) -> Bool {
         guard !rowView.isGroupRowStyle,
               let tableView = rowView.superview as? NSTableView,
@@ -379,8 +239,7 @@ internal extension ThemeTableChrome {
         return true
     }
 
-    /// AppKit's selection recolored rather than replaced, so it keeps the shape the table style gives
-    /// it: inset and rounded in an inset table, full width in a plain one.
+    // AppKit's selection recolored rather than replaced keeps the shape the table style gives it.
     func drawSelection(of rowView: NSTableRowView, in dirtyRect: NSRect, native: (NSRect) -> Void) {
         guard let fill = selectionColor(emphasized: rowView.isEmphasized),
               let context = NSGraphicsContext.current?.cgContext
@@ -397,28 +256,16 @@ internal extension ThemeTableChrome {
         context.restoreGState()
     }
 
-    /// A theme picks its selection to sit behind its own text, so the text does not flip to white.
+    // A theme picks its selection to sit behind its own text, so the text does not flip to white.
     func interiorBackgroundStyle(of rowView: NSTableRowView, native: NSView.BackgroundStyle) -> NSView.BackgroundStyle {
         isOnThemedSelection(rowView) ? .normal : native
     }
 }
 
-/// The row a `ThemeTableChrome` hands out while the theme draws the rows. It tells its records cells
-/// when they sit on the theme's selection.
 internal final class ThemeTableRowView: NSTableRowView, ThemeTableRowDrawing {
     internal static let reuseIdentifier = NSUserInterfaceItemIdentifier("ThemeTableRow")
 
-    internal weak var chrome: ThemeTableChrome? {
-        didSet { publishSelection() }
-    }
-
-    override internal var isSelected: Bool {
-        didSet { publishSelection() }
-    }
-
-    override internal var isEmphasized: Bool {
-        didSet { publishSelection() }
-    }
+    internal weak var chrome: ThemeTableChrome?
 
     override internal func drawBackground(in dirtyRect: NSRect) {
         guard chrome?.drawBackground(of: self, in: dirtyRect) == true else {
@@ -439,53 +286,25 @@ internal final class ThemeTableRowView: NSTableRowView, ThemeTableRowDrawing {
         let native = super.interiorBackgroundStyle
         return chrome?.interiorBackgroundStyle(of: self, native: native) ?? native
     }
-
-    internal var isOnThemedSelection: Bool {
-        chrome?.isOnThemedSelection(self) ?? false
-    }
-
-    internal func publishSelection() {
-        let isThemed = isOnThemedSelection
-        for case let cell as ThemeTableChrome.HostingCell in subviews {
-            cell.isOnThemedSelection = isThemed
-        }
-    }
 }
 
 // MARK: - Records cell text
 
 internal extension ThemeTableChrome {
-    /// The slot a records cell's text takes, or nil for the cell's own hierarchical text, which
-    /// turns white on AppKit's emphasized selection.
+    // Nil keeps the cell's own hierarchical text, which turns white on AppKit's emphasized selection.
     static func recordsTextSlot(
-        onThemedSelection: Bool,
         onEmphasizedSelection: Bool,
         highContrast: Bool,
         scope: ThemeScope = .live
     ) -> ThemeSlot? {
         guard !onEmphasizedSelection else { return nil }
-        let theme = scope.activeTheme
-        if onThemedSelection, theme.isOverridden(.gridSelectionText, highContrast: highContrast) {
-            return .gridSelectionText
-        }
-        return theme.isOverridden(.gridText, highContrast: highContrast) ? .gridText : nil
+        return scope.activeTheme.isOverridden(.gridText, highContrast: highContrast) ? .gridText : nil
     }
 
-    /// A SwiftUI cell of a records table. Its text takes the theme's grid text, and the selection text
-    /// while its `ThemeTableRowView` sits on the theme's selection.
     final class HostingCell: NSHostingView<AnyView> {
-        private let selection = RecordsCellSelection()
         private var scope = ThemeScope.live
 
-        internal var isOnThemedSelection: Bool {
-            get { selection.isThemed }
-            set {
-                guard selection.isThemed != newValue else { return }
-                selection.isThemed = newValue
-            }
-        }
-
-        /// `scope` is the one the table's chrome reads, so the text matches the rows.
+        // Pass the scope the table's chrome reads, so the text matches the rows.
         internal static func make(
             _ identifier: NSUserInterfaceItemIdentifier,
             in tableView: NSTableView,
@@ -506,24 +325,12 @@ internal extension ThemeTableChrome {
         }
 
         internal func show(_ content: some View) {
-            rootView = AnyView(content.modifier(RecordsCellText(selection: selection, scope: scope)))
-        }
-
-        /// A reused cell can land in another row, or in AppKit's own row view once the theme stops.
-        override internal func viewDidMoveToSuperview() {
-            super.viewDidMoveToSuperview()
-            isOnThemedSelection = (superview as? ThemeTableRowView)?.isOnThemedSelection ?? false
+            rootView = AnyView(content.modifier(RecordsCellText(scope: scope)))
         }
     }
 }
 
-@MainActor
-private final class RecordsCellSelection: ObservableObject {
-    @Published var isThemed = false
-}
-
 private struct RecordsCellText: ViewModifier {
-    @ObservedObject var selection: RecordsCellSelection
     @ObservedObject private var themeEngine = ThemeEngine.shared
     @Environment(\.colorSchemeContrast) private var contrast
 
@@ -531,32 +338,23 @@ private struct RecordsCellText: ViewModifier {
 
     func body(content: Content) -> some View {
         if #available(macOS 14, *) {
-            content.modifier(
-                ProminenceAwareRecordsCellText(
-                    isOnThemedSelection: selection.isThemed,
-                    scope: scope,
-                    contrast: contrast
-                )
-            )
+            content.modifier(ProminenceAwareRecordsCellText(scope: scope, contrast: contrast))
         } else {
             content
         }
     }
 }
 
-/// macOS 13 has no `backgroundProminence`, so a cell there cannot tell AppKit's emphasized selection
-/// apart and keeps its system text.
+// macOS 13 has no `backgroundProminence`, so a cell there cannot see AppKit's emphasized selection and keeps its system text.
 @available(macOS 14, *)
 private struct ProminenceAwareRecordsCellText: ViewModifier {
     @Environment(\.backgroundProminence) private var prominence
 
-    let isOnThemedSelection: Bool
     let scope: ThemeScope
     let contrast: ColorSchemeContrast
 
     func body(content: Content) -> some View {
         let slot = ThemeTableChrome.recordsTextSlot(
-            onThemedSelection: isOnThemedSelection,
             onEmphasizedSelection: prominence == .increased,
             highContrast: contrast == .increased,
             scope: scope
diff --git a/apple/TablePro/ViewModels/TableListingViewModel.swift b/apple/TablePro/ViewModels/TableListingViewModel.swift
index 48a63019db..81cb17dc03 100644
--- a/apple/TablePro/ViewModels/TableListingViewModel.swift
+++ b/apple/TablePro/ViewModels/TableListingViewModel.swift
@@ -6,21 +6,12 @@
 import Combine
 import Foundation
 
-/// The rows of one listing tab, and what the reader did with its grid.
-///
-/// A refresh keeps the rows on screen until new ones land, and a failed refresh keeps them too. A load
-/// that a newer one has superseded, or that was cancelled, commits nothing, whatever it came back with.
 @MainActor
 internal final class TableListingViewModel: ObservableObject {
     @Published private(set) var state: MetadataLoadState<TableListing> = .idle
-    /// Moves each time a load lands, so the grid redraws rows that changed under the same tab.
-    @Published private(set) var revision = 0
 
-    @Published var sortState = SortState()
-    @Published var selectedRows: Set<Int> = []
-    @Published var columnLayout = ColumnLayoutState()
-    let changeManager = AnyChangeManager(DataChangeManager())
-    let gridDelegate = HeldRowsGridDelegate()
+    // Outlives the tab's view, so the sort, the selection and the column widths survive a tab switch.
+    let grid = HeldRowsGridAdapter(configuration: DataGridConfiguration(), sortsHeldRows: true)
 
     private let scope: DatabaseScope
     private let loader: TableListingLoader
@@ -39,16 +30,11 @@ internal final class TableListingViewModel: ObservableObject {
         self.scope = scope
         self.loader = loader
         self.metadataProvider = metadataProvider
-        /// Heard here rather than by the view, which exists only while its tab is selected: asking again for
-        /// a listing in a tab behind another one selects it and refreshes it in the same turn.
         refreshSubscription = refreshRequests
             .filter { $0 == tabId }
             .sink { [weak self] _ in self?.reload() }
-        gridDelegate.onSortStateChanged = { [weak self] in self?.sortState = $0 }
     }
 
-    /// The view's task runs again every time the tab comes back, so a listing already on screen or on its
-    /// way is left alone. A cancelled load settles back to idle, and runs again here.
     @discardableResult
     func loadIfNeeded() -> Task<Void, Never>? {
         guard case .idle = state else { return nil }
@@ -73,7 +59,6 @@ internal final class TableListingViewModel: ObservableObject {
         return task
     }
 
-    /// For a closed tab: its load is left to nobody, and nothing it returns may land.
     func cancel() {
         loadTask?.cancel()
         generation &+= 1
@@ -85,14 +70,12 @@ internal final class TableListingViewModel: ObservableObject {
     private func commit(_ outcome: MetadataFetchOutcome<TableListing>, token: Int) {
         guard token == generation else { return }
         state = state.settled(by: outcome, discardingValue: false)
-        revision &+= 1
+        if case .loaded(let listing) = state {
+            grid.setRows(listing.rows)
+        }
     }
 }
 
-/// The listing models of a window's tabs, kept for as long as their tab is open.
-///
-/// Only the selected tab's view exists, so a model the view held went with every switch to another tab,
-/// and the rows, the sort and the column widths with it, and coming back listed the tables again.
 @MainActor
 internal final class TableListingModelStore {
     private var models: [UUID: TableListingViewModel] = [:]
@@ -106,8 +89,6 @@ internal final class TableListingModelStore {
         return model
     }
 
-    /// A closed tab's load is cancelled rather than left running for nobody on a metadata connection the
-    /// sidebar and the next listing wait on.
     func retainTabs(_ openTabIds: Set<UUID>) {
         for (tabId, model) in models where !openTabIds.contains(tabId) {
             model.cancel()
diff --git a/apple/TablePro/Views/Agent/AgentResultRowsView.swift b/apple/TablePro/Views/Agent/AgentResultRowsView.swift
index cbd8bb3d51..d644b8706a 100644
--- a/apple/TablePro/Views/Agent/AgentResultRowsView.swift
+++ b/apple/TablePro/Views/Agent/AgentResultRowsView.swift
@@ -6,34 +6,16 @@
 import SwiftUI
 import TableProPluginKit
 
-/// The rows a session read, drawn by the app's own data grid.
-///
-/// Read-only, and modelled on `CompareRowGrid`, which is the other place a grid reviews rows it does
-/// not own: a change manager of its own and a column layout held in `@State` so nothing reaches
-/// `FileColumnLayoutPersister`. A `DataGridConfiguration` naming only the database type keeps
-/// `columnLayoutKey` nil, so an agent result can never write into a real table's saved column
-/// widths.
-///
-/// Sorting is answered here rather than announced and dropped. The rows are held in full and there
-/// is no query to re-run, so `TableRowsSorting` puts them in order and the grid redraws; a grid
-/// whose headers move a sort indicator that changes nothing is worse than one that cannot sort.
-///
-/// Drawing rows by hand here was the alternative and it is worse in ways that are not obvious: the
-/// grid already gives type-aware formatting, the Data Grid font (rather than a system text style,
-/// which is the two-font-domain defect), column separators that scale, an accessibility cell tree,
-/// selection and copy. None of that is worth reimplementing beside the real one.
+// The rows a session read, drawn read-only by the app's own grid. They are held in full and there is no
+// query to re-run, so a header click sorts them here.
 internal struct AgentResultRowsView: View {
     internal let runs: [AgentQueryRun]
-    /// Decodes each run once. The pane owns it, so the answer survives a redraw and a sort.
     internal let artifacts: AgentArtifactCache
     internal let connection: DatabaseConnection?
 
-    @State private var changeManager = AnyChangeManager(DataChangeManager())
-    @State private var selectedRows: Set<Int> = []
-    @State private var columnLayout = ColumnLayoutState()
     @State private var selectedRunId: String?
-    @State private var sortState = SortState()
-    @StateObject private var gridDelegate = HeldRowsGridDelegate()
+    @State private var loadedRunId: String?
+    @StateObject private var grid = HeldRowsGridAdapter(configuration: DataGridConfiguration(), sortsHeldRows: true)
 
     var body: some View {
         if runs.isEmpty {
@@ -51,10 +33,6 @@ internal struct AgentResultRowsView: View {
                 Divider()
                 result(for: run)
             }
-            .onChange(of: run.id) { _ in
-                selectedRows = []
-                sortState = SortState()
-            }
         }
     }
 
@@ -76,14 +54,11 @@ internal struct AgentResultRowsView: View {
         )
     }
 
-    /// Four answers where there used to be two, because "nothing to draw" was four different things
-    /// and the pane said the same sentence for each: a write that changed rows read as a query that
-    /// had matched none.
     @ViewBuilder
     private func result(for run: AgentQueryRun) -> some View {
         switch artifacts.payload(for: run) {
         case .rows(let decoded):
-            grid(decoded, for: run)
+            rowsGrid(decoded, for: run)
         case .noRows:
             state(
                 title: String(localized: "No Rows"),
@@ -105,40 +80,41 @@ internal struct AgentResultRowsView: View {
         }
     }
 
-    private func grid(_ decoded: TableRows, for run: AgentQueryRun) -> some View {
-        let rows = TableRowsSorting.sorted(decoded, by: sortState)
-        return DataGridView(
-            tableRowsProvider: { rows },
-            changeManager: changeManager,
-            isEditable: false,
-            configuration: DataGridConfiguration(
-                databaseType: connection?.type,
-                showRowNumbers: true,
-                supportsColumnCommands: false,
-                supportsValueFilter: false,
-                appliesRowCopyFormat: true
-            ),
-            delegate: gridDelegate,
-            selectedRowIndices: $selectedRows,
-            sortState: $sortState,
-            columnLayout: $columnLayout,
-            contentRevision: contentRevision(for: run)
-        )
-        .onAppear {
-            gridDelegate.onSortStateChanged = { sortState = $0 }
+    private func rowsGrid(_ decoded: TableRows, for run: AgentQueryRun) -> some View {
+        // task(id:) runs with this body's values; onChange(of:) would run with the previous body's (measured).
+        DataGridView(model: grid.model)
+            .task(id: run.id) { load(decoded, for: run) }
+    }
+
+    // Another run starts with no selection, sort or display formats; the same run keeps them across a remount.
+    private func load(_ decoded: TableRows, for run: AgentQueryRun) {
+        grid.model.configuration = configuration
+        guard loadedRunId != run.id else { return }
+        if loadedRunId != nil {
+            grid.model.clearSelection()
+            grid.showSort(SortState())
+            grid.model.store.displayFormats = []
         }
+        loadedRunId = run.id
+        grid.setRows(decoded)
+    }
+
+    private var configuration: DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.traits = DataGridEngineTraits(databaseType: connection?.type)
+        configuration.showRowNumbers = true
+        configuration.supportsValueFilter = false
+        configuration.appliesRowCopyFormat = true
+        configuration.commands = [.freezeColumns, .displayAs]
+        return configuration
     }
 
-    /// On the grid's background, so the pane keeps one color between a run with rows and one without.
     private func state(title: String, systemImage: String, description: String) -> some View {
         UnavailableStateView(title, systemImage: systemImage, description: Text(description))
             .frame(maxWidth: .infinity, maxHeight: .infinity)
             .gridStandInBackground()
     }
 
-    /// Grouped, because a count is read at a glance and "1,204" is legible where "1204" has to be
-    /// counted. A statement that reports no count at all is one from a tool that answers in the
-    /// bridge's shape without sending one.
     private static func changeSummary(_ rowsAffected: Int?) -> String {
         guard let rowsAffected else {
             return String(localized: "The statement returned no rows to show.")
@@ -152,18 +128,6 @@ internal struct AgentResultRowsView: View {
         return String(format: template, rowsAffected.formatted(.number.grouping(.automatic)))
     }
 
-    /// Moves whenever the rows the grid should be drawing move, which a sort does without changing
-    /// the run.
-    private func contentRevision(for run: AgentQueryRun) -> Int {
-        var hasher = Hasher()
-        hasher.combine(run.id)
-        for column in sortState.columns {
-            hasher.combine(column.columnIndex)
-            hasher.combine(column.direction)
-        }
-        return hasher.finalize()
-    }
-
     private func summary(of sql: String) -> String {
         let flattened = sql
             .replacingOccurrences(of: "\n", with: " ")
diff --git a/apple/TablePro/Views/Compare/CompareRowGrid.swift b/apple/TablePro/Views/Compare/CompareRowGrid.swift
index 386c82e9d1..80ed3e5c35 100644
--- a/apple/TablePro/Views/Compare/CompareRowGrid.swift
+++ b/apple/TablePro/Views/Compare/CompareRowGrid.swift
@@ -2,17 +2,8 @@
 //  CompareRowGrid.swift
 //  TablePro
 //
-//  One table's row differences as rows: every column, the source line over the
-//  target line for a changed row, and the differing cells marked.
-//
-//  The data grid draws it, read-only, so a table of any width costs what the
-//  grid costs rather than a view per cell. Its marks are the grid's own: a row
-//  only in the source is underlined as an inserted row is, a row only in the
-//  target is struck through, and a changed value is underlined on the source
-//  line and struck through on the target line. Each carries a tint as a second
-//  cue and reads to VoiceOver in comparison words, not in editing ones.
-//
 
+import Combine
 import SwiftUI
 import TableProPluginKit
 
@@ -23,7 +14,7 @@ internal struct CompareRowGridLine {
 }
 
 @MainActor
-internal final class CompareRowGridModel: DataGridViewDelegate {
+internal final class CompareRowGridModel: ObservableObject {
     internal static let includeColumn = 0
     internal static let leadingColumnCount = 3
 
@@ -35,17 +26,37 @@ internal final class CompareRowGridModel: DataGridViewDelegate {
         let entryCount: Int
     }
 
+    internal let grid = HeldRowsGridAdapter(configuration: CompareRowGridModel.configuration(databaseType: nil))
     private(set) var lines: [CompareRowGridLine] = []
-    private(set) var tableRows = TableRows()
-    private var states: [RowVisualState] = []
     private var loadedKey: LoadKey?
     private var planId = ""
     private weak var session: CompareSyncSession?
 
-    /// A grid row is a display position, which stops matching the line order as soon as a column's
-    /// value filter narrows the grid, so every row the grid names is resolved back through it.
-    private weak var coordinator: TableViewCoordinator?
+    internal init() {
+        grid.checkboxState = { [weak self] rowID, column in
+            self?.checkboxState(rowID: rowID, column: column)
+        }
+        grid.checkboxChange = { [weak self] isOn, rowIDs, column in
+            self?.setIncluded(isOn, rowIDs: rowIDs, column: column)
+        }
+    }
+
+    internal var model: DataGridModel { grid.model }
+    internal var tableRows: TableRows { grid.heldRows }
+
+    private static func configuration(databaseType: DatabaseType?) -> DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.traits = DataGridEngineTraits(databaseType: databaseType)
+        configuration.showRowNumbers = false
+        configuration.checkboxColumns = [includeColumn]
+        configuration.supportsValueFilter = false
+        configuration.supportsColumnSort = false
+        configuration.appliesRowCopyFormat = true
+        configuration.commands = [.freezeColumns, .displayAs]
+        return configuration
+    }
 
+    @discardableResult
     internal func ensureLoaded(
         key: LoadKey,
         plan: DataComparePlan,
@@ -53,16 +64,25 @@ internal final class CompareRowGridModel: DataGridViewDelegate {
         session: CompareSyncSession
     ) -> TableRows {
         self.session = session
+        grid.model.configuration = Self.configuration(databaseType: session.source?.databaseType)
         guard loadedKey != key else { return tableRows }
+        // A row is a line of this load, so a selection made against another load names nothing here.
+        if loadedKey != nil {
+            grid.model.clearSelection()
+        }
         loadedKey = key
         planId = plan.id
         lines = entries.flatMap(Self.lines(for:))
         let columns = plan.columnNames
-        states = lines.map { Self.visualState(for: $0, columns: columns) }
-        tableRows = TableRows(
-            rows: ContiguousArray(lines.enumerated().map { index, line in
-                Row(id: .existing(index), values: Self.values(for: line, columns: columns))
-            }),
+        var states: [RowID: RowVisualState] = [:]
+        let rows = ContiguousArray(lines.enumerated().map { index, line -> Row in
+            let rowID = RowID.existing(index)
+            states[rowID] = Self.visualState(for: line, columns: columns)
+            return Row(id: rowID, values: Self.values(for: line, columns: columns))
+        })
+        grid.visualStates = states
+        let loaded = TableRows(
+            rows: rows,
             columns: [
                 String(localized: "Include"),
                 String(localized: "Change"),
@@ -71,9 +91,22 @@ internal final class CompareRowGridModel: DataGridViewDelegate {
             columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: Self.leadingColumnCount)
                 + plan.columns.map { Self.displayType(for: $0) }
         )
+        // Display formats are kept by data index, so another table's columns start with raw values.
+        if loaded.columns != tableRows.columns || loaded.columnTypes != tableRows.columnTypes {
+            grid.model.store.displayFormats = []
+        }
+        grid.setRows(loaded)
         return tableRows
     }
 
+    // An exclusion changed from the menu or from Space: the checkboxes repaint, the rows and selection stay.
+    internal func redrawCheckboxes(forLines lineIndexes: [Int]? = nil) {
+        let indexes = lineIndexes ?? Array(lines.indices)
+        grid.redrawCells(Set(indexes.compactMap { line -> CellPosition? in
+            grid.storageIndex(of: .existing(line)).map { CellPosition(row: $0, column: Self.includeColumn) }
+        }))
+    }
+
     private static func displayType(for column: CompareColumn) -> ColumnType {
         displayType(source: column.sourceColumnType, target: column.targetColumnType)
     }
@@ -138,42 +171,24 @@ internal final class CompareRowGridModel: DataGridViewDelegate {
         return values
     }
 
-    private func lineIndex(forDisplayRow row: Int) -> Int? {
-        let index = coordinator?.tableRowsIndex(forDisplayRow: row) ?? row
-        return lines.indices.contains(index) ? index : nil
+    private func lineIndex(of rowID: RowID) -> Int? {
+        guard case .existing(let index) = rowID, lines.indices.contains(index) else { return nil }
+        return index
     }
 
-    // MARK: - DataGridViewDelegate
-
-    internal func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        coordinator = tableViewCoordinator
-    }
-
-    internal func dataGridVisualState(forRow row: Int) -> RowVisualState? {
-        guard let index = lineIndex(forDisplayRow: row), states.indices.contains(index) else { return nil }
-        return states[index]
-    }
-
-    internal func dataGridCheckboxState(row: Int, column: Int) -> Bool? {
-        guard column == Self.includeColumn, let index = lineIndex(forDisplayRow: row) else { return nil }
+    private func checkboxState(rowID: RowID, column: DataGridColumn) -> Bool? {
+        guard column.dataIndex == Self.includeColumn, let index = lineIndex(of: rowID) else { return nil }
         let line = lines[index]
         guard line.opensEntry, line.entry.kind.isDifference,
               let session, let plan = session.dataPlans.first(where: { $0.id == planId }) else { return nil }
         return session.isRowIncluded(line.entry, in: plan)
     }
 
-    // The delegate's default copies nothing, which left Copy and Select All then Copy silent on this grid.
-    internal func dataGridCopyRows(_ indices: Set<Int>) {
-        coordinator?.copyRowsAsTSV(at: indices, includeHeaders: false)
-    }
-
-    internal func dataGridSetCheckbox(_ isOn: Bool, rows: IndexSet, column: Int) {
-        guard column == Self.includeColumn, let session else { return }
-        let entries = rows.compactMap { row -> RowDiffEntry? in
-            guard let index = lineIndex(forDisplayRow: row), lines[index].opensEntry else { return nil }
-            return lines[index].entry
-        }
-        session.setRowsIncluded(isOn, entries: entries, planId: planId)
+    private func setIncluded(_ isOn: Bool, rowIDs: [RowID], column: DataGridColumn) {
+        guard column.dataIndex == Self.includeColumn, let session else { return }
+        let indexes = rowIDs.compactMap(lineIndex(of:)).filter { lines[$0].opensEntry }
+        session.setRowsIncluded(isOn, entries: indexes.map { lines[$0].entry }, planId: planId)
+        redrawCheckboxes(forLines: indexes)
     }
 }
 
@@ -183,46 +198,27 @@ internal struct CompareRowGrid: View {
     internal let filter: RowDiffFilter
     internal let entries: [RowDiffEntry]
 
-    @State private var model = CompareRowGridModel()
-    @State private var changeManager = AnyChangeManager(DataChangeManager())
-    @State private var selectedRows: Set<Int> = []
-    @State private var columnLayout = ColumnLayoutState()
+    @StateObject private var model = CompareRowGridModel()
 
-    internal var body: some View {
-        let key = CompareRowGridModel.LoadKey(
+    private var key: CompareRowGridModel.LoadKey {
+        CompareRowGridModel.LoadKey(
             planId: plan.id,
             answer: plan.summary?.answerIdentity,
             columns: plan.columnNames,
             filter: filter,
             entryCount: entries.count
         )
-        let model = model
-        let plan = plan
-        let entries = entries
-        let session = session
-        return DataGridView(
-            tableRowsProvider: { model.ensureLoaded(key: key, plan: plan, entries: entries, session: session) },
-            changeManager: changeManager,
-            isEditable: false,
-            configuration: DataGridConfiguration(
-                databaseType: session.source?.databaseType,
-                showRowNumbers: false,
-                checkboxColumns: [CompareRowGridModel.includeColumn],
-                supportsColumnCommands: false,
-                supportsValueFilter: false,
-                supportsColumnSort: false
-            ),
-            delegate: model,
-            selectedRowIndices: $selectedRows,
-            sortState: .constant(SortState()),
-            columnLayout: $columnLayout,
-            /// The exclusions ride along, so including or excluding every listed row from the menu
-            /// repaints the checkboxes rather than leaving them until the next click or scroll.
-            contentRevision: key.hashValue ^ plan.excludedRowKeys.hashValue
-        )
-        .onChange(of: key) { _ in
-            selectedRows = []
-        }
+    }
+
+    // task(id:) runs with this body's values; onChange(of:) would run with the previous body's (measured).
+    internal var body: some View {
+        DataGridView(model: model.model)
+            .task(id: key) { load() }
+            .onChange(of: plan.excludedRowKeys) { _ in model.redrawCheckboxes() }
+    }
+
+    private func load() {
+        model.ensureLoaded(key: key, plan: plan, entries: entries, session: session)
     }
 }
 
diff --git a/apple/TablePro/Views/DataFiles/DataFileColumnMenuBuilder.swift b/apple/TablePro/Views/DataFiles/DataFileColumnMenuBuilder.swift
index 36f711b5f9..d7429d3f6d 100644
--- a/apple/TablePro/Views/DataFiles/DataFileColumnMenuBuilder.swift
+++ b/apple/TablePro/Views/DataFiles/DataFileColumnMenuBuilder.swift
@@ -50,10 +50,10 @@ enum DataFileColumnMenuBuilder {
         return items
     }
 
-    static func rowItems(forPageRow row: Int) -> [NSMenuItem] {
+    static func rowItems(abovePageRow above: Int, belowPageRow below: Int) -> [NSMenuItem] {
         [
-            rowItem(String(localized: "Insert Row Above"), #selector(DataFileSplitViewController.dataFileInsertRowAbove(_:)), row),
-            rowItem(String(localized: "Insert Row Below"), #selector(DataFileSplitViewController.dataFileInsertRowBelow(_:)), row)
+            rowItem(String(localized: "Insert Row Above"), #selector(DataFileSplitViewController.dataFileInsertRowAbove(_:)), above),
+            rowItem(String(localized: "Insert Row Below"), #selector(DataFileSplitViewController.dataFileInsertRowBelow(_:)), below)
         ]
     }
 
diff --git a/apple/TablePro/Views/DataFiles/DataFileContentView.swift b/apple/TablePro/Views/DataFiles/DataFileContentView.swift
index ca68516b15..fe2a2dd979 100644
--- a/apple/TablePro/Views/DataFiles/DataFileContentView.swift
+++ b/apple/TablePro/Views/DataFiles/DataFileContentView.swift
@@ -9,7 +9,6 @@ import TableProTheme
 
 struct DataFileContentView: View {
     @ObservedObject var controller: DataFileController
-    let gridDelegate: DataFileGridDelegate
 
     var body: some View {
         VStack(spacing: 0) {
@@ -17,10 +16,6 @@ struct DataFileContentView: View {
                 DataFileFilterPanel(controller: controller)
                 Divider()
             }
-            if controller.find.isVisible, controller.loadState == .loaded {
-                DataFileFindBar(controller: controller)
-                Divider()
-            }
             content
             if controller.sheets.count > 1 {
                 Divider()
@@ -66,23 +61,9 @@ struct DataFileContentView: View {
     }
 
     private var grid: some View {
-        DataGridView(
-            tableRowsProvider: { controller.tableRows },
-            tableRowsMutator: { _ in .none },
-            paginationOffsetProvider: { controller.pageOffset },
-            changeManager: controller.anyChangeManager,
-            isEditable: controller.isEditable && !controller.isBusy,
-            configuration: configuration,
-            delegate: gridDelegate,
-            selectedRowIndices: $controller.selectedRowIndices,
-            sortState: Binding(
-                get: { controller.sortState },
-                set: { controller.updateSort($0) }
-            ),
-            columnLayout: $controller.columnLayout,
-            selectionSummary: controller.selectionSummary
-        )
-        .accessibilityIdentifier("data-grid")
+        DataGridView(model: controller.gridModel)
+            .onAppear { controller.gridModel.configuration = configuration }
+            .onChange(of: configuration) { controller.gridModel.configuration = $0 }
     }
 
     private var emptyView: some View {
@@ -96,14 +77,23 @@ struct DataFileContentView: View {
     }
 
     private var configuration: DataGridConfiguration {
+        Self.gridConfiguration(for: controller)
+    }
+
+    static func gridConfiguration(for controller: DataFileController) -> DataGridConfiguration {
         var config = DataGridConfiguration()
+        let isEditable = controller.isEditable && !controller.isBusy
         config.showRowNumbers = true
-        config.hiddenColumns = controller.columnLayout.hiddenColumns
+        config.isEditable = isEditable
         config.supportsValueFilter = false
         config.appliesRowCopyFormat = true
-        config.filterMenuColumnTypes = controller.columnNames.ids.map {
-            DataFileColumnTypes.filterType(for: controller.kind(of: $0))
+        var commands: Set<DataGridCommand> = [
+            .filterWithColumn, .hideColumns, .showRowsAsJSON, .exportResults, .freezeColumns, .displayAs,
+        ]
+        if isEditable {
+            commands.formUnion([.addRow, .deleteRows, .pasteRows])
         }
+        config.commands = commands
         return config
     }
 }
diff --git a/apple/TablePro/Views/DataFiles/DataFileFilterPanel.swift b/apple/TablePro/Views/DataFiles/DataFileFilterPanel.swift
index 959ec6b47f..382be0f527 100644
--- a/apple/TablePro/Views/DataFiles/DataFileFilterPanel.swift
+++ b/apple/TablePro/Views/DataFiles/DataFileFilterPanel.swift
@@ -42,8 +42,7 @@ extension DataFileController: FilterPanelActions {
     }
 
     func focusGrid() {
-        guard let tableView = gridCoordinator?.tableView else { return }
-        tableView.window?.makeFirstResponder(tableView)
+        gridModel.focus()
     }
 
     func addBlankFilter(columnName: String) {
diff --git a/apple/TablePro/Views/DataFiles/DataFileFindBar.swift b/apple/TablePro/Views/DataFiles/DataFileFindBar.swift
deleted file mode 100644
index cd105ef574..0000000000
--- a/apple/TablePro/Views/DataFiles/DataFileFindBar.swift
+++ /dev/null
@@ -1,156 +0,0 @@
-//
-//  DataFileFindBar.swift
-//  TablePro
-//
-
-import SwiftUI
-
-struct DataFileFindBar: View {
-    @ObservedObject var controller: DataFileController
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: 6) {
-            findRow
-            if controller.find.isReplaceVisible, controller.isEditable {
-                replaceRow
-            }
-        }
-        .padding(.horizontal, 12)
-        .padding(.vertical, 6)
-    }
-
-    private var findRow: some View {
-        HStack(spacing: 8) {
-            NativeSearchField(
-                text: Binding(
-                    get: { controller.find.text },
-                    set: { newValue in
-                        controller.find.text = newValue
-                        controller.scheduleFind()
-                    }
-                ),
-                placeholder: String(localized: "Find in file"),
-                controlSize: .regular,
-                onSubmit: { controller.findNext() },
-                focusOnAppear: true,
-                accessibilityIdentifier: "data-file-find-field"
-            )
-            .frame(maxWidth: 320)
-
-            optionsMenu
-
-            Text(counterText)
-                .font(.callout)
-                .foregroundStyle(controller.find.isPatternInvalid ? Color.red : Color.secondary)
-                .monospacedDigit()
-
-            HStack(spacing: 2) {
-                Button(String(localized: "Previous match"), systemImage: "chevron.left") {
-                    controller.findPrevious()
-                }
-                .help(String(localized: "Previous match"))
-                Button(String(localized: "Next match"), systemImage: "chevron.right") {
-                    controller.findNext()
-                }
-                .help(String(localized: "Next match"))
-            }
-            .labelStyle(.iconOnly)
-            .buttonStyle(.borderless)
-            .disabled(controller.find.matches.isEmpty)
-
-            if let scope = controller.find.scopeColumn, let name = controller.columnNames.name(for: scope) {
-                Button {
-                    controller.find.scopeColumn = nil
-                    controller.runFind()
-                } label: {
-                    Label(String(format: String(localized: "In column %@"), name), systemImage: "xmark.circle.fill")
-                }
-                .buttonStyle(.borderless)
-                .help(String(localized: "Search every column"))
-            }
-
-            Spacer()
-
-            if !controller.find.isReplaceVisible, controller.isEditable {
-                Button(String(localized: "Replace…")) {
-                    controller.find.isReplaceVisible = true
-                }
-                .buttonStyle(.borderless)
-            }
-
-            Button(String(localized: "Done")) {
-                controller.hideFind()
-            }
-            .buttonStyle(.borderless)
-            .keyboardShortcut(.cancelAction)
-        }
-    }
-
-    private var replaceRow: some View {
-        HStack(spacing: 8) {
-            TextField(
-                String(localized: "Replace with"),
-                text: Binding(get: { controller.find.replacement }, set: { controller.find.replacement = $0 })
-            )
-            .textFieldStyle(.roundedBorder)
-            .frame(maxWidth: 320)
-            .accessibilityIdentifier("data-file-replace-field")
-
-            Button(String(localized: "Replace")) {
-                controller.replaceCurrent()
-            }
-            .disabled(controller.find.currentIndex == nil || controller.isBusy)
-
-            Button(String(localized: "Replace All")) {
-                controller.replaceAll()
-                controller.focusGrid()
-            }
-            .disabled(!controller.find.hasQuery || controller.find.isPatternInvalid || controller.isBusy)
-            .accessibilityIdentifier("data-file-replace-all")
-
-            Spacer()
-        }
-    }
-
-    private var optionsMenu: some View {
-        Menu {
-            Toggle(String(localized: "Match Case"), isOn: option(\.matchesCase))
-            Toggle(String(localized: "Whole Words"), isOn: option(\.matchesWholeWords))
-            Toggle(String(localized: "Regular Expression"), isOn: option(\.isRegularExpression))
-        } label: {
-            Label { Text("Find Options") } icon: { Image(systemName: "slider.horizontal.3") }
-        }
-        .labelStyle(.iconOnly)
-        .menuStyle(.borderlessButton)
-        .fixedSize()
-        .help(String(localized: "Find Options"))
-    }
-
-    private func option(_ keyPath: WritableKeyPath<DataFileFindState, Bool>) -> Binding<Bool> {
-        Binding(
-            get: { controller.find[keyPath: keyPath] },
-            set: { newValue in
-                controller.find[keyPath: keyPath] = newValue
-                controller.runFind()
-            }
-        )
-    }
-
-    private var counterText: String {
-        guard controller.find.hasQuery else { return "" }
-        if controller.find.isPatternInvalid {
-            return String(localized: "Invalid regular expression")
-        }
-        if controller.find.isSearching {
-            return String(localized: "Searching…")
-        }
-        guard let index = controller.find.currentIndex, !controller.find.matches.isEmpty else {
-            return String(localized: "No matches")
-        }
-        return String(
-            format: String(localized: "%@ of %@"),
-            (index + 1).formatted(),
-            controller.find.matches.count.formatted()
-        )
-    }
-}
diff --git a/apple/TablePro/Views/DataFiles/DataFileGridAdapter.swift b/apple/TablePro/Views/DataFiles/DataFileGridAdapter.swift
new file mode 100644
index 0000000000..b9cca534a7
--- /dev/null
+++ b/apple/TablePro/Views/DataFiles/DataFileGridAdapter.swift
@@ -0,0 +1,275 @@
+//
+//  DataFileGridAdapter.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+import TableProTabular
+
+// The data file grid's rows are the controller's current page; every edit, sort and column command goes
+// through the controller, which owns the file and its undo.
+@MainActor
+final class DataFileGridAdapter {
+    let model: DataGridModel
+    weak var controller: DataFileController?
+    weak var owner: DataFileSplitViewController?
+    private let detachedChangeState = AnyChangeManager(DataFileChangeManager())
+
+    init(model: DataGridModel) {
+        self.model = model
+        model.dataSource = self
+        model.actions = self
+        model.datasetFinder = self
+    }
+
+    private func pageRows(of rowIDs: [RowID]) -> Set<Int> {
+        Set(rowIDs.compactMap { model.displayIndex(of: $0) })
+    }
+
+    private func columnID(for column: DataGridColumn) -> TabularColumnID? {
+        guard let controller, controller.columnNames.ids.indices.contains(column.dataIndex) else { return nil }
+        return controller.columnNames.ids[column.dataIndex]
+    }
+
+    nonisolated private static func copiedField(_ cell: PluginCellValue) -> String {
+        guard case .text(let text) = cell else { return "" }
+        return text
+            .replacingOccurrences(of: "\t", with: " ")
+            .replacingOccurrences(of: "\r", with: " ")
+            .replacingOccurrences(of: "\n", with: " ")
+    }
+}
+
+extension DataFileGridAdapter: DataGridDataSource {
+    var gridRows: TableRows { controller?.tableRows ?? TableRows() }
+    var gridChangeState: AnyChangeManager { controller?.anyChangeManager ?? detachedChangeState }
+    var gridRowNumberOffset: Int { controller?.pageOffset ?? 0 }
+
+    func gridSummaryColumnPolicy() -> SelectionSummaryColumnPolicy? {
+        guard let controller else { return nil }
+        return SelectionSummaryColumnPolicy(
+            rules: controller.columnNames.ids.map { DataFileColumnTypes.summaryRule(for: controller.kind(of: $0)) },
+            emptyTextIsEmpty: true
+        )
+    }
+}
+
+extension DataFileGridAdapter: DataGridActions {
+    // One command is one commit: the controller writes the table once and registers one undo step.
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        guard let controller, controller.isEditable, !edits.isEmpty else { return false }
+        var applied = false
+        controller.batchCellEdits(actionName: actionName) {
+            for edit in edits {
+                guard case .existing(let key) = edit.rowID else { continue }
+                controller.setCell(key: key, column: edit.dataIndex, text: edit.newValue.isNull ? nil : edit.newValue.asText ?? "")
+                applied = true
+            }
+        }
+        return applied
+    }
+
+    func gridDeleteRows(_ rowIDs: [RowID]) {
+        owner?.deleteRows(pageRows(of: rowIDs))
+    }
+
+    // A file's NULL or missing cell copies as empty, and a tab or line break in a value as a space,
+    // so each record pastes into a spreadsheet as one line.
+    func gridCopyRows(_ rowIDs: [RowID]) -> Bool {
+        let tableRows = model.rows
+        let copied = rowIDs.compactMap { tableRows.row(withID: $0) }
+        guard !copied.isEmpty else { return false }
+        let projection = VisibleColumnProjection(indices: model.columns.columns.map(\.dataIndex))
+        let tsv = copied.map { row in
+            projection.values(Array(row.values)).map(Self.copiedField).joined(separator: "\t")
+        }.joined(separator: "\n")
+        ClipboardService.shared.writeRows(
+            tsv: tsv,
+            html: nil,
+            gridRows: GridRowsClipboardPayload(
+                columns: projection.columns(tableRows.columns),
+                copying: copied,
+                expressionColumns: copied.map { _ in [] },
+                projection: projection
+            )
+        )
+        return true
+    }
+
+    func gridAddRow() {
+        controller?.appendRow()
+    }
+
+    func gridCanPasteRows() -> Bool {
+        guard let controller else { return false }
+        return controller.isEditable && ClipboardService.shared.hasText
+    }
+
+    // Rows copied as CSV, JSON or Markdown carry their values, which the tab-separated parser cannot read back.
+    func gridPasteRows() {
+        guard let controller else { return }
+        if let copied = ClipboardService.shared.readGridRows() {
+            controller.pasteRows(DataFilePasteParser.rows(from: copied, into: controller.columnNames.displayNames))
+            return
+        }
+        guard let raw = ClipboardService.shared.readText(), !raw.isEmpty else { return }
+        controller.pasteRows(DataFilePasteParser.rows(from: raw))
+    }
+
+    // The cells the command names, except that picked columns cover every visible row of the file, not only the page.
+    func gridSetCellsToValue(_ cells: [(rowID: RowID, column: DataGridColumn)]) -> Bool {
+        guard let owner, let controller else { return false }
+        let named = cells.compactMap { cell -> (column: TabularColumnID, key: Int)? in
+            guard case .existing(let key) = cell.rowID, let column = columnID(for: cell.column) else { return nil }
+            return (column: column, key: key)
+        }
+        let picked = controller.selectedColumnIDs()
+        let coversPickedColumns = !picked.isEmpty && Set(named.map(\.column)) == Set(picked)
+        guard let target = coversPickedColumns ? controller.cellTarget() : controller.cellTarget(cells: named) else {
+            return false
+        }
+        owner.presentSetCellsToValue(target)
+        return true
+    }
+
+    func gridSortDidChange(_ sort: SortState) {
+        controller?.updateSort(sort)
+    }
+
+    // The inspector shows the selection, so rows the menu was opened on outside it become the selection.
+    func gridShowRowsAsJSON(_ rowIDs: [RowID]) {
+        if !rowIDs.isEmpty, Set(model.selectedRowIDs) != Set(rowIDs) {
+            model.selectRows(rowIDs)
+        }
+        controller?.isInspectorVisible = true
+    }
+
+    func gridExportResults() {
+        owner?.presentExport()
+    }
+
+    func gridHideColumn(_ column: DataGridColumn) {
+        controller?.columnLayout.hiddenColumns.insert(column.name)
+    }
+
+    func gridShowAllColumns() {
+        controller?.columnLayout.hiddenColumns.removeAll()
+    }
+
+    func gridFilterWithColumn(_ column: DataGridColumn) {
+        guard let controller, controller.columnNames.id(forName: column.name) != nil else { return }
+        controller.addBlankFilter(columnName: column.name)
+    }
+
+    func gridCellMenuItems(for rowID: RowID, column: DataGridColumn) -> [NSMenuItem] {
+        guard let controller, let id = columnID(for: column),
+              let row = controller.tableRows.row(withID: rowID), column.dataIndex < row.values.count else { return [] }
+        let item = CellFilterMenuBuilder.menuItem(
+            columnName: column.name,
+            columnType: DataFileColumnTypes.filterType(for: controller.kind(of: id)),
+            value: row.values[column.dataIndex]
+        ) { [weak controller] filter in
+            controller?.addFilter(filter)
+        }
+        return item.map { [$0] } ?? []
+    }
+
+    func gridColumnMenuItems(for column: DataGridColumn) -> [NSMenuItem] {
+        guard let controller, let id = columnID(for: column) else { return [] }
+        return DataFileColumnMenuBuilder.items(
+            for: id,
+            controller: controller,
+            selectedColumns: controller.selectedColumnIDs()
+        )
+    }
+
+    // Insert Row Above and Below anchor at the row right-clicked, inside a selection or not.
+    func gridRowMenuItems(for rowIDs: [RowID], clickedRow: RowID) -> [NSMenuItem] {
+        guard let controller, controller.isEditable, let row = model.displayIndex(of: clickedRow) else { return [] }
+        return DataFileColumnMenuBuilder.rowItems(abovePageRow: row, belowPageRow: row)
+    }
+}
+
+// Find covers every row of the file: a page row's ID is `.existing(key)`, the key a match carries.
+extension DataFileGridAdapter: DataGridDatasetFinding {
+    func gridFindAll(_ query: GridDatasetFindQuery) async throws -> [GridFindState.Match] {
+        guard let controller else { return [] }
+        return try await controller.findMatches(query)
+    }
+
+    func gridDisplayPosition(of rowID: RowID) -> Int? {
+        guard case .existing(let key) = rowID else { return nil }
+        return controller?.displayPosition(ofKey: key)
+    }
+
+    func gridLoadRow(_ rowID: RowID) -> Bool {
+        guard let controller, case .existing(let key) = rowID, controller.displayPosition(ofKey: key) != nil else {
+            return false
+        }
+        controller.reveal(key: key, selecting: false)
+        return true
+    }
+
+    func gridReplace(_ match: GridFindState.Match, query: GridDatasetFindQuery, with template: String) -> Bool {
+        controller?.replaceMatch(match, query: query, with: template) ?? false
+    }
+
+    func gridReplaceAll(_ query: GridDatasetFindQuery, with template: String) {
+        controller?.replaceAll(query, with: template)
+    }
+}
+
+enum DataFilePasteParser {
+    static func rows(from text: String) -> [[String]] {
+        text.split(omittingEmptySubsequences: false, whereSeparator: { $0 == "\n" || $0 == "\r\n" })
+            .map { line in line.split(separator: "\t", omittingEmptySubsequences: false).map(String.init) }
+            .filter { !($0.count == 1 && $0[0].isEmpty) }
+    }
+
+    // By name when every copied column is one of the file's, once, so rows copied with columns reordered or
+    // hidden land where they came from. Anything else pastes in order, as its text would.
+    @MainActor
+    static func rows(from copied: GridRowsClipboardPayload, into columns: [String]) -> [[String]] {
+        let fileColumns = Set(columns)
+        guard Set(copied.columns).count == copied.columns.count, copied.columns.allSatisfy(fileColumns.contains) else {
+            return copied.rows.map { $0.map(text(of:)) }
+        }
+        let sources = columns.map { copied.columns.firstIndex(of: $0) }
+        return copied.rows.map { row in
+            sources.map { source in
+                guard let source, row.indices.contains(source) else { return "" }
+                return text(of: row[source])
+            }
+        }
+    }
+
+    // NULL pastes as the empty value this grid's own row copy writes for it.
+    @MainActor
+    static func text(of cell: PluginCellValue) -> String {
+        switch cell {
+        case .text(let text): return text
+        case .null: return ""
+        case .bytes(let data): return BlobFormattingService.shared.format(data, for: .copy) ?? ""
+        }
+    }
+}
+
+enum DataFileColumnTypes {
+    static func filterType(for kind: TabularInferredKind) -> ColumnType {
+        switch kind {
+        case .integer: return .integer(rawType: "INTEGER")
+        case .decimal: return .decimal(rawType: "DECIMAL")
+        case .boolean: return .boolean(rawType: "BOOLEAN")
+        case .date: return .date(rawType: "DATE")
+        case .text: return .text(rawType: "TEXT")
+        }
+    }
+
+    static func summaryRule(for kind: TabularInferredKind) -> SelectionSummaryColumnRule {
+        switch kind {
+        case .integer, .decimal: return .numeric
+        case .boolean, .date, .text: return .countOnly
+        }
+    }
+}
diff --git a/apple/TablePro/Views/DataFiles/DataFileGridDelegate.swift b/apple/TablePro/Views/DataFiles/DataFileGridDelegate.swift
deleted file mode 100644
index dddbf0f380..0000000000
--- a/apple/TablePro/Views/DataFiles/DataFileGridDelegate.swift
+++ /dev/null
@@ -1,190 +0,0 @@
-//
-//  DataFileGridDelegate.swift
-//  TablePro
-//
-
-import AppKit
-import TableProPluginKit
-import TableProTabular
-
-@MainActor
-final class DataFileGridDelegate: DataGridViewDelegate {
-    weak var owner: DataFileSplitViewController?
-    private let controller: DataFileController
-
-    init(controller: DataFileController) {
-        self.controller = controller
-    }
-
-    func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        controller.gridCoordinator = tableViewCoordinator
-    }
-
-    func dataGridDidEditCell(row: Int, column: Int, newValue: String?) {
-        controller.setCell(pageRow: row, column: column, text: newValue)
-    }
-
-    func dataGridDeleteRows(_ indices: Set<Int>) {
-        owner?.deleteRows(indices)
-    }
-
-    func dataGridAddRow() {
-        controller.appendRow()
-    }
-
-    func dataGridCopyRows(_ indices: Set<Int>) {
-        let lines = indices.sorted().compactMap { row -> String? in
-            guard controller.tableRows.rows.indices.contains(row) else { return nil }
-            return controller.tableRows.rows[row].values.map { value -> String in
-                guard case .text(let text) = value else { return "" }
-                return text
-                    .replacingOccurrences(of: "\t", with: " ")
-                    .replacingOccurrences(of: "\r", with: " ")
-                    .replacingOccurrences(of: "\n", with: " ")
-            }.joined(separator: "\t")
-        }
-        guard !lines.isEmpty else { return }
-        ClipboardService.shared.writeText(lines.joined(separator: "\n"))
-    }
-
-    func dataGridPasteRows() {
-        // Rows copied as CSV, JSON or Markdown carry their values, which the tab-separated parser cannot read back.
-        if let copied = ClipboardService.shared.readGridRows() {
-            controller.pasteRows(DataFilePasteParser.rows(from: copied, into: controller.columnNames.displayNames))
-            return
-        }
-        guard let raw = ClipboardService.shared.readText(), !raw.isEmpty else { return }
-        let rows = DataFilePasteParser.rows(from: raw)
-        controller.pasteRows(rows)
-    }
-
-    func dataGridCanPasteRows() -> Bool {
-        controller.isEditable && ClipboardService.shared.hasText
-    }
-
-    func dataGridSortStateChanged(_ state: SortState) {
-        controller.updateSort(state)
-    }
-
-    func dataGridUndo() {
-        controller.undoManager?.undo()
-    }
-
-    func dataGridRedo() {
-        controller.undoManager?.redo()
-    }
-
-    func dataGridShowRowAsJSON() {
-        controller.isInspectorVisible = true
-    }
-
-    func dataGridExportResults() {
-        owner?.presentExport()
-    }
-
-    func dataGridHideColumn(_ columnName: String) {
-        controller.columnLayout.hiddenColumns.insert(columnName)
-    }
-
-    func dataGridShowAllColumns() {
-        controller.columnLayout.hiddenColumns.removeAll()
-    }
-
-    func dataGridFilterColumn(_ columnName: String) {
-        guard controller.columnNames.id(forName: columnName) != nil else { return }
-        controller.addBlankFilter(columnName: columnName)
-    }
-
-    func dataGridFilterMenuItem(forRow displayRow: Int, dataColumn: Int) -> NSMenuItem? {
-        controller.gridCoordinator?.cellFilterMenuItem(forRow: displayRow, dataColumn: dataColumn) { [weak controller] filter in
-            controller?.addFilter(filter)
-        }
-    }
-
-    func dataGridColumnStructureMenuItems(forColumn dataColumnIndex: Int) -> [NSMenuItem] {
-        guard controller.columnNames.ids.indices.contains(dataColumnIndex) else { return [] }
-        return DataFileColumnMenuBuilder.items(
-            for: controller.columnNames.ids[dataColumnIndex],
-            controller: controller,
-            selectedColumns: controller.selectedColumnIDs()
-        )
-    }
-
-    func dataGridRowStructureMenuItems(forRow displayRow: Int) -> [NSMenuItem] {
-        guard controller.isEditable else { return [] }
-        return DataFileColumnMenuBuilder.rowItems(forPageRow: displayRow)
-    }
-
-    func dataGridSetCellsToValue(_ targets: [SetValueTarget]) -> Bool {
-        guard let owner else { return false }
-        if let target = controller.cellTarget(for: targets) {
-            owner.presentSetCellsToValue(target)
-        }
-        return true
-    }
-
-    func dataGridBatchEdits(actionName: String, _ edits: () -> Void) {
-        controller.batchCellEdits(actionName: actionName, edits)
-    }
-
-    func dataGridSummaryColumnPolicy() -> SelectionSummaryColumnPolicy? {
-        SelectionSummaryColumnPolicy(
-            rules: controller.columnNames.ids.map { DataFileColumnTypes.summaryRule(for: controller.kind(of: $0)) },
-            emptyTextIsEmpty: true
-        )
-    }
-}
-
-enum DataFilePasteParser {
-    static func rows(from text: String) -> [[String]] {
-        text.split(omittingEmptySubsequences: false, whereSeparator: { $0 == "\n" || $0 == "\r\n" })
-            .map { line in line.split(separator: "\t", omittingEmptySubsequences: false).map(String.init) }
-            .filter { !($0.count == 1 && $0[0].isEmpty) }
-    }
-
-    // By name when every copied column is one of the file's, once, so rows copied with columns reordered or
-    // hidden land where they came from. Anything else pastes in order, as its text would.
-    @MainActor
-    static func rows(from copied: GridRowsClipboardPayload, into columns: [String]) -> [[String]] {
-        let fileColumns = Set(columns)
-        guard Set(copied.columns).count == copied.columns.count, copied.columns.allSatisfy(fileColumns.contains) else {
-            return copied.rows.map { $0.map(text(of:)) }
-        }
-        let sources = columns.map { copied.columns.firstIndex(of: $0) }
-        return copied.rows.map { row in
-            sources.map { source in
-                guard let source, row.indices.contains(source) else { return "" }
-                return text(of: row[source])
-            }
-        }
-    }
-
-    // NULL pastes as the empty value this grid's own row copy writes for it.
-    @MainActor
-    static func text(of cell: PluginCellValue) -> String {
-        switch cell {
-        case .text(let text): return text
-        case .null: return ""
-        case .bytes(let data): return BlobFormattingService.shared.format(data, for: .copy) ?? ""
-        }
-    }
-}
-
-enum DataFileColumnTypes {
-    static func filterType(for kind: TabularInferredKind) -> ColumnType {
-        switch kind {
-        case .integer: return .integer(rawType: "INTEGER")
-        case .decimal: return .decimal(rawType: "DECIMAL")
-        case .boolean: return .boolean(rawType: "BOOLEAN")
-        case .date: return .date(rawType: "DATE")
-        case .text: return .text(rawType: "TEXT")
-        }
-    }
-
-    static func summaryRule(for kind: TabularInferredKind) -> SelectionSummaryColumnRule {
-        switch kind {
-        case .integer, .decimal: return .numeric
-        case .boolean, .date, .text: return .countOnly
-        }
-    }
-}
diff --git a/apple/TablePro/Views/DataFiles/DataFileRowDetailsView.swift b/apple/TablePro/Views/DataFiles/DataFileRowDetailsView.swift
index 872137fdd6..f7d8bc992e 100644
--- a/apple/TablePro/Views/DataFiles/DataFileRowDetailsView.swift
+++ b/apple/TablePro/Views/DataFiles/DataFileRowDetailsView.swift
@@ -80,7 +80,7 @@ struct DataFileRowDetailsView: View {
         }
         configuredKey = controller.key(forPageRow: row)
         editState.configure(
-            selectedRowIndices: [row],
+            rowIDs: [controller.tableRows.rows[row].id],
             allRows: [values],
             columns: controller.tableRows.columns,
             columnTypes: controller.tableRows.columnTypes
diff --git a/apple/TablePro/Views/DataFiles/DataFileSplitViewController+Actions.swift b/apple/TablePro/Views/DataFiles/DataFileSplitViewController+Actions.swift
index a90aadc642..8385777721 100644
--- a/apple/TablePro/Views/DataFiles/DataFileSplitViewController+Actions.swift
+++ b/apple/TablePro/Views/DataFiles/DataFileSplitViewController+Actions.swift
@@ -37,7 +37,7 @@ extension DataFileSplitViewController {
             guard let self else { return }
             _ = self.controller.deleteRows(pageRows: pageRows)
             let remaining = self.controller.tableRows.rows.count
-            self.controller.selectedRowIndices = remaining == 0 ? [] : [min(firstRow, remaining - 1)]
+            self.controller.selectRows(pageRows: remaining == 0 ? [] : [min(firstRow, remaining - 1)])
         }
         guard controller.rowsHaveData(pageRows: pageRows) else {
             proceed()
diff --git a/apple/TablePro/Views/DataFiles/DataFileSplitViewController.swift b/apple/TablePro/Views/DataFiles/DataFileSplitViewController.swift
index 1ab5459b11..5938f6871e 100644
--- a/apple/TablePro/Views/DataFiles/DataFileSplitViewController.swift
+++ b/apple/TablePro/Views/DataFiles/DataFileSplitViewController.swift
@@ -14,7 +14,6 @@ final class DataFileSplitViewController: NSSplitViewController {
 
     weak var dataFileDocument: DataFileDocument?
     let controller: DataFileController
-    let gridDelegate: DataFileGridDelegate
     private let contentItem: NSSplitViewItem
     private let inspectorItem: NSSplitViewItem
     private var cancellables: Set<AnyCancellable> = []
@@ -25,12 +24,8 @@ final class DataFileSplitViewController: NSSplitViewController {
     init(document: DataFileDocument) {
         dataFileDocument = document
         controller = document.controller
-        gridDelegate = DataFileGridDelegate(controller: document.controller)
 
-        let content = NSHostingController(rootView: DataFileContentView(
-            controller: document.controller,
-            gridDelegate: gridDelegate
-        ))
+        let content = NSHostingController(rootView: DataFileContentView(controller: document.controller))
         content.sizingOptions = []
         contentItem = NSSplitViewItem(viewController: content)
         contentItem.minimumThickness = Self.contentMinThickness
@@ -46,7 +41,7 @@ final class DataFileSplitViewController: NSSplitViewController {
         inspectorItem.isCollapsed = true
 
         super.init(nibName: nil, bundle: nil)
-        gridDelegate.owner = self
+        controller.gridAdapter.owner = self
         addSplitViewItem(contentItem)
         addSplitViewItem(inspectorItem)
 
@@ -87,8 +82,7 @@ final class DataFileSplitViewController: NSSplitViewController {
     }
 
     func focusGrid() {
-        guard let tableView = controller.gridCoordinator?.tableView else { return }
-        view.window?.makeFirstResponder(tableView)
+        controller.gridModel.focus()
     }
 
     override func validateUserInterfaceItem(_ item: NSValidatedUserInterfaceItem) -> Bool {
diff --git a/apple/TablePro/Views/DataFiles/DataFileStatisticsView.swift b/apple/TablePro/Views/DataFiles/DataFileStatisticsView.swift
index 44a85d3efc..4c7dda8e50 100644
--- a/apple/TablePro/Views/DataFiles/DataFileStatisticsView.swift
+++ b/apple/TablePro/Views/DataFiles/DataFileStatisticsView.swift
@@ -215,13 +215,11 @@ extension DataFileSplitViewController {
         }
     }
 
+    // A hidden column has no header, so its popover points at the middle of the content.
     private func headerAnchor(for id: TabularColumnID) -> (rect: NSRect, view: NSView) {
-        guard let coordinator = controller.gridCoordinator, let tableView = coordinator.tableView,
-              let headerView = tableView.headerView, let dataIndex = controller.columnNames.index(of: id),
-              let tableColumnIndex = tableView.tableColumns.firstIndex(where: { coordinator.dataColumnIndex(from: $0.identifier) == dataIndex })
-        else {
-            return (view.bounds.insetBy(dx: view.bounds.width / 2 - 1, dy: view.bounds.height / 2 - 1), view)
+        if let anchor = controller.headerAnchor(for: id) {
+            return (anchor.rect, anchor.view)
         }
-        return (headerView.headerRect(ofColumn: tableColumnIndex), headerView)
+        return (view.bounds.insetBy(dx: view.bounds.width / 2 - 1, dy: view.bounds.height / 2 - 1), view)
     }
 }
diff --git a/apple/TablePro/Views/DataGrid/Cells/DataGridBodyChrome.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridBodyChrome.swift
new file mode 100644
index 0000000000..0ec73c5095
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridBodyChrome.swift
@@ -0,0 +1,111 @@
+//
+//  DataGridBodyChrome.swift
+//  TablePro
+//
+
+import AppKit
+import TableProTheme
+
+// gridStyleMask stays empty: AppKit's vertical grid lines keep one subview per column and made a 500-column layout pass take 518 ms (#2381).
+@MainActor
+enum DataGridBodyChrome {
+    static let separatorThickness: CGFloat = 1
+
+    // One separator at the leading edge of every column the rect reaches, in the space of `view`.
+    static func separatorRects(in rect: NSRect, of view: NSView, tableView: NSTableView) -> [NSRect] {
+        guard rect.width > 0, rect.height > 0 else { return [] }
+        let inTableView = view.convert(rect, to: tableView)
+        return tableView.columnIndexes(in: inTableView).compactMap { tableColumnIndex in
+            let columnRect = view.convert(tableView.rect(ofColumn: tableColumnIndex), from: tableView)
+            guard columnRect.width > 0, columnRect.minX > 0 else { return nil }
+            let separator = NSRect(
+                x: columnRect.minX - separatorThickness,
+                y: rect.minY,
+                width: separatorThickness,
+                height: rect.height
+            )
+            return separator.intersects(rect) ? separator : nil
+        }
+    }
+
+    static func drawColumnSeparators(in rect: NSRect, of view: NSView, tableView: NSTableView) {
+        let separators = separatorRects(in: rect, of: view, tableView: tableView)
+        guard !separators.isEmpty else { return }
+        tableView.gridColor.setFill()
+        separators.forEach { $0.fill() }
+    }
+
+    struct RowBand: Equatable {
+        let row: Int
+        let rect: NSRect
+        let isTableRow: Bool
+    }
+
+    // The table's rows, then bands one row apart past the last row, numbered on as NSTableView continues its alternation.
+    static func rowBands(in rect: NSRect, of view: NSView, tableView: NSTableView) -> [RowBand] {
+        guard rect.width > 0, rect.height > 0 else { return [] }
+        let inTableView = view.convert(rect, to: tableView)
+        let rows = tableView.rows(in: inTableView)
+        var bands = (rows.location..<(rows.location + rows.length)).map { row in
+            RowBand(row: row, rect: view.convert(tableView.rect(ofRow: row), from: tableView), isTableRow: true)
+        }
+
+        let pitch = tableView.rowHeight + tableView.intercellSpacing.height
+        let rowCount = tableView.numberOfRows
+        let lastRowBottom = rowCount > 0 ? tableView.rect(ofRow: rowCount - 1).maxY : tableView.bounds.minY
+        guard pitch > 0, inTableView.maxY > lastRowBottom else { return bands }
+
+        var index = max(0, Int(((inTableView.minY - lastRowBottom) / pitch).rounded(.down)))
+        while lastRowBottom + CGFloat(index) * pitch < inTableView.maxY {
+            let band = NSRect(
+                x: inTableView.minX,
+                y: lastRowBottom + CGFloat(index) * pitch,
+                width: inTableView.width,
+                height: pitch
+            )
+            bands.append(RowBand(row: rowCount + index, rect: view.convert(band, from: tableView), isTableRow: false))
+            index += 1
+        }
+        return bands
+    }
+
+    // AppKit reads the table's own backgroundColor for the area an elastic scroll uncovers.
+    static func applyThemeColors(to tableView: NSTableView, scope: ThemeScope) {
+        let resolved = scope.resolved
+        let gridColor = resolved[.gridLine]
+        if tableView.gridColor != gridColor {
+            tableView.gridColor = gridColor
+        }
+        let background = resolved[.gridBackground]
+        if tableView.backgroundColor != background {
+            tableView.backgroundColor = background
+        }
+    }
+
+    // The theme's pair when it declares one, otherwise the system's alternating pair the slots fall back to.
+    static func stripeColor(forRow row: Int, of tableView: NSTableView, scope: ThemeScope) -> NSColor? {
+        guard tableView.usesAlternatingRowBackgroundColors else { return nil }
+        let resolved = scope.resolved
+        return row.isMultiple(of: 2) ? resolved[.gridBackground] : resolved[.gridAlternateRow]
+    }
+
+    // Opaque whatever the stripe is, because a frozen pane row covers the scrolling rows beneath it.
+    static func fillRowBackground(_ rect: NSRect, row: Int, of tableView: NSTableView, scope: ThemeScope) {
+        tableView.backgroundColor.setFill()
+        rect.fill()
+        guard let stripe = stripeColor(forRow: row, of: tableView, scope: scope) else { return }
+        stripe.setFill()
+        rect.fill(using: .sourceOver)
+    }
+
+    // NSTableView's own past-the-last-row drawing blends the stripe twice, measured on macOS 27.
+    static func drawTableBackground(in rect: NSRect, of tableView: NSTableView, scope: ThemeScope) {
+        tableView.backgroundColor.setFill()
+        rect.fill()
+        for band in rowBands(in: rect, of: tableView, tableView: tableView) where !band.isTableRow {
+            guard let stripe = stripeColor(forRow: band.row, of: tableView, scope: scope) else { continue }
+            stripe.setFill()
+            band.rect.intersection(rect).fill(using: .sourceOver)
+        }
+    }
+}
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellAccessoryGlyph.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellAccessoryGlyph.swift
similarity index 67%
rename from apple/TablePro/Views/Results/Cells/DataGridCellAccessoryGlyph.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridCellAccessoryGlyph.swift
index 100ff0737e..eb9f1003e7 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridCellAccessoryGlyph.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellAccessoryGlyph.swift
@@ -5,10 +5,7 @@
 
 import AppKit
 
-/// The symbol a cell draws at its trailing edge, rasterised once per appearance.
-///
-/// Shared by every cell in the grid, so the cache is static: the glyph depends on the role and the
-/// appearance it is drawn into, never on which cell asked for it.
+// Rasterised once per role and appearance, shared by every cell in every grid.
 @MainActor
 enum DataGridCellAccessoryGlyph {
     enum Role: Hashable {
@@ -42,10 +39,6 @@ enum DataGridCellAccessoryGlyph {
             }
         }
 
-        /// The bare arrow spends its whole point size on the arrow itself, where the circled variant
-        /// spent most of it on the ring, so 14 here would draw an arrow half again as large as the
-        /// one it replaced. 12 keeps the ink at 11 x 9 in the 16 x 16 accessory rect, close to the
-        /// dropdown chevron's weight and to the 13pt cell text.
         var pointSize: CGFloat {
             switch self {
             case .foreignKeyNormal, .foreignKeyEmphasized:
@@ -55,7 +48,6 @@ enum DataGridCellAccessoryGlyph {
             }
         }
 
-        /// An emphasized glyph sits on the row's selection, so it takes the selection's text color.
         func color(selectionText: NSColor) -> NSColor {
             switch self {
             case .foreignKeyNormal, .chevronNormal:
@@ -71,7 +63,7 @@ enum DataGridCellAccessoryGlyph {
     struct Glyph {
         let image: CGImage
         let pointSize: NSSize
-        /// Held so the color cannot be freed and its address reused while the bitmap is cached.
+        // Held so the color cannot be freed and its address reused while the bitmap is cached.
         fileprivate let color: NSColor
     }
 
@@ -84,12 +76,7 @@ enum DataGridCellAccessoryGlyph {
     private static var glyphs: [Key: Glyph] = [:]
     private static var glyphsRevision: Int?
 
-    /// Rasterizing resolves the dynamic symbol color, so a cached bitmap belongs to exactly one
-    /// appearance and one color. Keying on the appearance is what keeps a dark window from being
-    /// served the light bitmap, and `NSAppearance.currentDrawing()` only reports the drawing
-    /// appearance while AppKit is inside `draw(_:)`, `updateLayer` or `layout`.
-    /// The color is compared by identity on a hit, a pointer compare, since the palette hands every
-    /// cell the same object; a grid on another scope still gets its own bitmap.
+    // NSAppearance.currentDrawing() names the drawing appearance only inside draw, updateLayer or layout.
     static func image(for role: Role, color: NSColor) -> Glyph? {
         let revision = ThemeEngine.shared.revision
         if glyphsRevision != revision {
@@ -117,11 +104,7 @@ enum DataGridCellAccessoryGlyph {
         return Glyph(image: cgImage, pointSize: image.size, color: color)
     }
 
-    /// A symbol stretched to fill the accessory rect stops looking like a system symbol, so the
-    /// glyph draws at its own point size and the rect only ever clamps it. The clamp is one factor
-    /// across both axes, because clamping each axis on its own would distort the glyph exactly the
-    /// way filling the rect did. The origin rounds to whole points so a glyph narrower than its rect
-    /// by an odd number of points does not land on a half point and blur at 1x.
+    // Drawn at its own point size and only ever shrunk, by one factor on both axes, onto whole points.
     static func centeredRect(pointSize: NSSize, in rect: NSRect) -> NSRect {
         let scale = min(1, rect.width / pointSize.width, rect.height / pointSize.height)
         let size = NSSize(width: pointSize.width * scale, height: pointSize.height * scale)
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellAppearance.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellAppearance.swift
similarity index 69%
rename from apple/TablePro/Views/Results/Cells/DataGridCellAppearance.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridCellAppearance.swift
index 0c52229b40..bb2faafb71 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridCellAppearance.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellAppearance.swift
@@ -5,33 +5,18 @@
 
 import AppKit
 
-/// What one data cell looks like, resolved from its content and state.
-///
-/// Separated from the drawing so the decisions are testable without a view and without a graphics
-/// context: which font a NULL takes, when a modified cell keeps its tint, what colour text turns on
-/// a selected row. The renderer that consumes this makes no decisions of its own.
+// Every decision about one cell's look, kept apart from drawing so it is testable without a view.
 @MainActor
 struct DataGridCellAppearance: Equatable {
     let text: String
     let font: NSFont
     let textColor: NSColor
-    /// Painted behind the text, for a find match, a modified value or a highlight rule.
     let backgroundTint: NSColor?
-    /// The line a pending change draws through or under the text. Unlike the tint, it survives a
-    /// selection, which is what makes it the cue rather than a decoration on one.
     let textMark: DataGridCellTextMark?
     let accessory: DataGridCellAccessory
-    /// Which symbol the accessory draws, resolved here because it follows the row's state rather
-    /// than anything the renderer can see.
     let accessoryRole: DataGridCellAccessoryGlyph.Role?
     let accessoryColor: NSColor?
-    /// The cell cursor on a selected row, which the selection fill would swallow a focus ring behind.
-    let drawsFocusBorder: Bool
-    /// The cell cursor on an unselected row.
-    let drawsFocusRing: Bool
-    let focusColor: NSColor
     let checkboxMark: DataGridCheckboxMark?
-    /// Nil leaves invisible characters unmarked.
     let specialCharacterColor: NSColor?
 
     static func resolve(
@@ -41,7 +26,6 @@ struct DataGridCellAppearance: Equatable {
         palette: DataGridCellPalette,
         nullDisplayString: String,
         onEmphasizedSelection: Bool,
-        hasOverlay: Bool,
         checkboxMark: DataGridCheckboxMark? = nil,
         textTone: NSColor? = nil,
         revealsInvisibleCharacters: Bool = false
@@ -64,7 +48,6 @@ struct DataGridCellAppearance: Equatable {
         }
 
         let findTint: NSColor? = state.isCurrentFindMatch ? palette.findMatchTint : nil
-        let highlightColor = state.visualState.cellHighlightColor(forColumn: state.columnIndex)
         let stateTint: NSColor?
         if state.visualState.isDeleted || state.visualState.isInserted {
             stateTint = nil
@@ -72,11 +55,10 @@ struct DataGridCellAppearance: Equatable {
             || state.visualState.isStruck(columnIndex: state.columnIndex) {
             stateTint = palette.modifiedColumnTint
         } else {
-            stateTint = highlightColor?.washColor
+            stateTint = state.visualState.cellHighlightColor(forColumn: state.columnIndex)?.washColor
         }
 
-        // The modified or highlight tint stands down on a selected row so the selection fill is
-        // not painted over; a find match keeps its own highlight whatever else is true.
+        // The modified or highlight tint stands down on an emphasized selection; a find match keeps its highlight.
         let backgroundTint: NSColor?
         let textColor: NSColor
         if let findTint {
@@ -90,12 +72,7 @@ struct DataGridCellAppearance: Equatable {
             textColor = baseColor
         }
 
-        let accessory = DataGridCellAccessory.visible(
-            for: kind,
-            isEditable: state.isEditable,
-            rawValue: content.rawValue
-        )
-        let isCursorVisible = state.isFocused && !hasOverlay
+        let accessory = DataGridCellAccessory.visible(for: kind, isEditable: state.isEditable, rawValue: content.rawValue)
         // The editor's orange, except over a fill of the cell's own, where it takes the text's color.
         let specialCharacterColor: NSColor? = revealsInvisibleCharacters && content.placeholder == nil && kind != .checkbox
             ? (findTint != nil || onEmphasizedSelection ? textColor : .systemOrange)
@@ -109,7 +86,6 @@ struct DataGridCellAppearance: Equatable {
             text: kind == .checkbox ? "" : DataGridCellContent.resolvedDisplayText(
                 content.displayText,
                 placeholder: content.placeholder,
-                isLargeDataset: state.isLargeDataset,
                 nullDisplayString: nullDisplayString
             ),
             font: font,
@@ -119,9 +95,6 @@ struct DataGridCellAppearance: Equatable {
             accessory: accessory,
             accessoryRole: accessoryRole,
             accessoryColor: accessoryRole?.color(selectionText: palette.selectionText),
-            drawsFocusBorder: isCursorVisible && onEmphasizedSelection,
-            drawsFocusRing: isCursorVisible && !onEmphasizedSelection,
-            focusColor: onEmphasizedSelection ? palette.selectionText : palette.focusRing,
             checkboxMark: kind == .checkbox ? checkboxMark : nil,
             specialCharacterColor: specialCharacterColor
         )
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellContent.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellContent.swift
similarity index 77%
rename from apple/TablePro/Views/Results/Cells/DataGridCellContent.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridCellContent.swift
index 8d493c63b8..be6494909c 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridCellContent.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellContent.swift
@@ -10,7 +10,7 @@ enum DataGridCellPlaceholder: Equatable {
     case null
     case empty
     case defaultMarker
-    /// The row has no field for the column, which a document store tells apart from NULL.
+    // The row has no field for the column, which a document store tells apart from NULL.
     case absent
     case unloaded(byteCount: Int)
 }
@@ -41,22 +41,21 @@ struct DataGridCellContent {
     static func resolvedDisplayText(
         _ displayText: String,
         placeholder: DataGridCellPlaceholder?,
-        isLargeDataset: Bool,
         nullDisplayString: String
     ) -> String {
         switch placeholder {
         case .none:
             return displayText
         case .null:
-            return isLargeDataset ? "" : nullDisplayString
+            return nullDisplayString
         case .empty:
-            return isLargeDataset ? "" : String(localized: "Empty")
+            return String(localized: "Empty")
         case .defaultMarker:
-            return isLargeDataset ? "" : String(localized: "DEFAULT")
+            return String(localized: "DEFAULT")
         case .absent:
-            return isLargeDataset ? "" : absentFieldText
+            return absentFieldText
         case .unloaded(let byteCount):
-            return isLargeDataset ? "" : unloadedText(byteCount: byteCount)
+            return unloadedText(byteCount: byteCount)
         }
     }
 
@@ -75,26 +74,20 @@ struct DataGridCellContent {
 
 struct DataGridCellState {
     let visualState: RowVisualState
-    let isFocused: Bool
     let isEditable: Bool
-    let isLargeDataset: Bool
     let isCurrentFindMatch: Bool
     let row: Int
     let columnIndex: Int
 
     init(
         visualState: RowVisualState,
-        isFocused: Bool,
         isEditable: Bool,
-        isLargeDataset: Bool,
         isCurrentFindMatch: Bool = false,
         row: Int,
         columnIndex: Int
     ) {
         self.visualState = visualState
-        self.isFocused = isFocused
         self.isEditable = isEditable
-        self.isLargeDataset = isLargeDataset
         self.isCurrentFindMatch = isCurrentFindMatch
         self.row = row
         self.columnIndex = columnIndex
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellKind.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellKind.swift
similarity index 92%
rename from apple/TablePro/Views/Results/Cells/DataGridCellKind.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridCellKind.swift
index 3b1db36881..73b673868e 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridCellKind.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellKind.swift
@@ -72,10 +72,7 @@ enum DataGridCellAccessory: Equatable {
             + reservedTrailingWidth
     }
 
-    var columnWidthReservation: CGFloat {
-        reservedTrailingWidth
-    }
-
+    // The accessory's rect inside a cell whose origin is the cell's own top-left corner.
     func frame(in bounds: NSRect) -> NSRect {
         guard self != .none else { return .zero }
         let size = size
@@ -83,19 +80,14 @@ enum DataGridCellAccessory: Equatable {
         guard bounds.width >= minRequiredWidth else { return .zero }
         return NSRect(
             x: bounds.maxX - DataGridMetrics.cellHorizontalInset - size.width,
-            y: (bounds.height - size.height) / 2,
+            y: bounds.minY + (bounds.height - size.height) / 2,
             width: size.width,
             height: size.height
         )
     }
 
     func availableTextWidth(in bounds: NSRect) -> CGFloat {
-        max(
-            0,
-            bounds.width
-                - 2 * DataGridMetrics.cellHorizontalInset
-                - reservedTrailingWidth
-        )
+        max(0, bounds.width - 2 * DataGridMetrics.cellHorizontalInset - reservedTrailingWidth)
     }
 
     static func reserved(for kind: DataGridCellKind, isEditable: Bool) -> DataGridCellAccessory {
@@ -122,6 +114,8 @@ struct DataGridColumnPresentation: Equatable {
     let kind: DataGridCellKind
     let accessory: DataGridCellAccessory
 
+    static let plain = DataGridColumnPresentation(kind: .text, accessory: .none)
+
     static func resolve(
         columnType: ColumnType?,
         isForeignKey: Bool,
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellPalette.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellPalette.swift
similarity index 82%
rename from apple/TablePro/Views/Results/Cells/DataGridCellPalette.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridCellPalette.swift
index 4808166b56..21d3df7aac 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridCellPalette.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellPalette.swift
@@ -11,6 +11,7 @@ struct DataGridCellPalette: Equatable {
     let regularFont: NSFont
     let italicFont: NSFont
     let mediumFont: NSFont
+    let rowNumberFont: NSFont
     let text: NSColor
     let placeholderText: NSColor
     let booleanTrueText: NSColor
@@ -21,12 +22,12 @@ struct DataGridCellPalette: Equatable {
     let findMatchTint: NSColor
     let findMatchText: NSColor
     let selectionText: NSColor
-    let focusRing: NSColor
 
     init(
         regularFont: NSFont,
         italicFont: NSFont,
         mediumFont: NSFont,
+        rowNumberFont: NSFont = .monospacedDigitSystemFont(ofSize: NSFont.smallSystemFontSize, weight: .regular),
         text: NSColor,
         placeholderText: NSColor,
         booleanTrueText: NSColor,
@@ -36,12 +37,12 @@ struct DataGridCellPalette: Equatable {
         modifiedColumnTint: NSColor,
         findMatchTint: NSColor,
         findMatchText: NSColor = DataGridCellPalette.findMatchTextColor,
-        selectionText: NSColor = .alternateSelectedControlTextColor,
-        focusRing: NSColor = .keyboardFocusIndicatorColor
+        selectionText: NSColor = .alternateSelectedControlTextColor
     ) {
         self.regularFont = regularFont
         self.italicFont = italicFont
         self.mediumFont = mediumFont
+        self.rowNumberFont = rowNumberFont
         self.text = text
         self.placeholderText = placeholderText
         self.booleanTrueText = booleanTrueText
@@ -52,7 +53,6 @@ struct DataGridCellPalette: Equatable {
         self.findMatchTint = findMatchTint
         self.findMatchText = findMatchText
         self.selectionText = selectionText
-        self.focusRing = focusRing
     }
 
     static let placeholder = DataGridCellPalette(
@@ -69,8 +69,7 @@ struct DataGridCellPalette: Equatable {
         findMatchTint: .findHighlightColor
     )
 
-    /// `NSTextFinder` draws its find indicator as a light bubble in every appearance, so the text on
-    /// `findHighlightColor` is the light appearance's text color.
+    // NSTextFinder draws its find indicator as a light bubble in every appearance, so the text on it is light-appearance text.
     static let findMatchTextColor: NSColor = {
         var color = NSColor.textColor
         NSAppearance(named: .aqua)?.performAsCurrentDrawingAppearance {
@@ -86,10 +85,7 @@ struct DataGridCellPalette: Equatable {
 }
 
 extension ThemeScope {
-    /// The row-state tints are dynamic providers, which cost four times a catalog color on every
-    /// fill and `CTLineDraw`, so they are resolved here once in the appearance the grid draws in.
-    /// The catalog colors stay dynamic and resolve at draw time. Fonts are the user's typography,
-    /// not the theme's, so every scope draws in the engine's.
+    // The row-state tints are dynamic providers that cost four times a catalog color per fill, so they resolve once here.
     func dataGridCellPalette(
         in appearance: NSAppearance,
         fonts: DataGridFontCache = ThemeEngine.shared.dataGridFonts
@@ -99,6 +95,7 @@ extension ThemeScope {
             regularFont: fonts.regular,
             italicFont: fonts.italic,
             mediumFont: fonts.medium,
+            rowNumberFont: fonts.rowNumber,
             text: resolved[.gridText],
             placeholderText: resolved[.gridNullValue],
             booleanTrueText: resolved[.gridBoolTrue],
@@ -106,9 +103,7 @@ extension ThemeScope {
             rowNumberText: resolved[.gridRowNumber],
             deletedRowText: Self.resolvedTint(.gridDeletedText, of: resolved, in: appearance),
             modifiedColumnTint: Self.resolvedTint(.gridModified, of: resolved, in: appearance),
-            findMatchTint: .findHighlightColor,
-            selectionText: resolved[.gridSelectionText],
-            focusRing: resolved[.gridFocusBorder]
+            findMatchTint: .findHighlightColor
         )
     }
 
diff --git a/apple/TablePro/Views/DataGrid/Cells/DataGridCellPresenter.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellPresenter.swift
new file mode 100644
index 0000000000..4db4c80598
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellPresenter.swift
@@ -0,0 +1,323 @@
+//
+//  DataGridCellPresenter.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+// Resolves what each drawn cell shows from the model, once per row draw rather than once per cell.
+@MainActor
+final class DataGridCellPresenter {
+    struct Pass {
+        let rows: TableRows
+        let formats: [ValueDisplayFormat?]
+        let selection: GridSelection
+        let findMatch: GridFindState.Match?
+        let isEditable: Bool
+        let checkboxColumns: Set<Int>
+        let palette: DataGridCellPalette
+        let scope: ThemeScope
+        let databaseType: DatabaseType?
+        let showsInvisibleCharacters: Bool
+        let nullDisplayString: String
+    }
+
+    private weak var model: DataGridModel?
+    let registry: DataGridCellRegistry
+    let renderer = DataGridCellRenderer()
+    private let visualIndex = RowVisualIndex()
+    private var visualIndexSource: ObjectIdentifier?
+    private var highlightRuleSet = HighlightRuleSet.empty
+    private var presentations: [Int: DataGridColumnPresentation] = [:]
+
+    init(model: DataGridModel) {
+        self.model = model
+        registry = DataGridCellRegistry(scope: model.themeScope)
+    }
+
+    func adopt(_ model: DataGridModel) {
+        self.model = model
+        presentations.removeAll()
+        visualIndexSource = nil
+        highlightRuleSet = .empty
+    }
+
+    func makePass(in appearance: NSAppearance) -> Pass? {
+        guard let model else { return nil }
+        registry.preparePalette(in: appearance)
+        let rows = model.rows
+        prepareRowState(rows: rows)
+        return Pass(
+            rows: rows,
+            formats: model.store.displayFormats,
+            selection: model.selection,
+            findMatch: model.find.currentMatch,
+            isEditable: model.configuration.isEditable,
+            checkboxColumns: model.configuration.checkboxColumns,
+            palette: registry.palette,
+            scope: model.themeScope,
+            databaseType: model.configuration.traits.databaseType,
+            showsInvisibleCharacters: registry.showsInvisibleCharacters,
+            nullDisplayString: registry.nullDisplayString
+        )
+    }
+
+    // MARK: - Row state
+
+    func rebuildVisualIndex() {
+        visualIndex.rebuild(from: model?.changeState)
+        visualIndexSource = model?.changeState.map { ObjectIdentifier($0) }
+    }
+
+    func updateVisualIndex(for rowIDs: [RowID]) {
+        let changeState = model?.changeState
+        for rowID in rowIDs {
+            visualIndex.updateRow(rowID, from: changeState)
+        }
+    }
+
+    // Highlight rules and the change manager are read at draw time, so a row never paints with a stale tint.
+    func prepareRowState(rows: TableRows) {
+        syncHighlightRules(model?.dataSource?.gridHighlightRules ?? [], rows: rows)
+        syncVisualIndexSource()
+    }
+
+    private func syncVisualIndexSource() {
+        let source = model?.changeState.map { ObjectIdentifier($0) }
+        guard source != visualIndexSource else { return }
+        rebuildVisualIndex()
+    }
+
+    private func syncHighlightRules(_ rules: [HighlightRule], rows: TableRows) {
+        let key = HighlightRuleSet.Key(rules: rules, columns: rows.columns, columnTypes: rows.columnTypes)
+        if highlightRuleSet.key != key {
+            highlightRuleSet = HighlightRuleSet(rules: rules, columns: rows.columns, columnTypes: rows.columnTypes)
+        }
+        guard let display = model?.display, display.highlightRuleSetKey != key else { return }
+        display.highlightRuleSetKey = key
+        display.cache.clearHighlights()
+    }
+
+    func visualState(of row: Row) -> RowVisualState {
+        if let state = model?.dataSource?.gridVisualState(for: row.id) {
+            return state
+        }
+        guard !visualIndex.isEmpty || !highlightRuleSet.isEmpty else { return .empty }
+        return visualIndex.visualState(for: row.id).highlighted(highlight(for: row))
+    }
+
+    private func highlight(for row: Row) -> RowHighlight {
+        guard !highlightRuleSet.isEmpty, let cache = model?.display.cache else { return .none }
+        if let cached = cache.highlight(forID: row.id) { return cached }
+        let resolved = highlightRuleSet.highlight(for: row.values)
+        cache.setHighlight(resolved, forID: row.id)
+        return resolved
+    }
+
+    // MARK: - Column presentation
+
+    // The data indexes whose kind or accessory changed, so their auto widths can grow to fit.
+    @discardableResult
+    func refreshColumnPresentations() -> IndexSet {
+        guard let model else { return [] }
+        let rows = model.rows
+        let configuration = model.configuration
+        var next: [Int: DataGridColumnPresentation] = [:]
+        next.reserveCapacity(rows.columns.count)
+        var changed = IndexSet()
+        for (dataIndex, name) in rows.columns.enumerated() {
+            let type = dataIndex < rows.columnTypes.count ? rows.columnTypes[dataIndex] : nil
+            let presentation = DataGridColumnPresentation.resolve(
+                columnType: type,
+                isForeignKey: rows.columnForeignKeys[name] != nil,
+                isDropdown: configuration.dropdownColumns?.contains(dataIndex) == true,
+                isTypePicker: configuration.typePickerColumns?.contains(dataIndex) == true,
+                isEnumOrSet: Self.picksFromList(type: type, enumValues: rows.columnEnumValues[name]),
+                isEditable: configuration.isEditable,
+                isCheckbox: configuration.checkboxColumns.contains(dataIndex)
+            )
+            next[dataIndex] = presentation
+            if presentations[dataIndex] != presentation {
+                changed.insert(dataIndex)
+            }
+        }
+        presentations = next
+        return changed
+    }
+
+    func presentation(forDataIndex dataIndex: Int) -> DataGridColumnPresentation {
+        presentations[dataIndex] ?? .plain
+    }
+
+    private static func picksFromList(type: ColumnType?, enumValues: [String]?) -> Bool {
+        if type?.supportsElementEditing == true || type?.isVectorType == true { return true }
+        guard let enumValues, !enumValues.isEmpty else { return false }
+        return type?.isJsonType != true && type?.isBlobType != true && type?.isBooleanType != true
+    }
+
+    // Read by the accessibility cell, so a list a pointer can open has a role a screen reader can find.
+    func presentsComboBox(dataIndex: Int) -> Bool {
+        guard let configuration = model?.configuration, configuration.isEditable else { return false }
+        return configuration.dropdownColumns?.contains(dataIndex) == true
+            || configuration.typePickerColumns?.contains(dataIndex) == true
+    }
+
+    // MARK: - Text
+
+    func displayText(of row: Row, dataIndex: Int, type: ColumnType?, pass: Pass) -> String {
+        displayText(of: row, dataIndex: dataIndex, type: type, formats: pass.formats, databaseType: pass.databaseType, columnCount: pass.rows.columns.count)
+    }
+
+    func displayText(
+        of row: Row,
+        dataIndex: Int,
+        type: ColumnType?,
+        formats: [ValueDisplayFormat?],
+        databaseType: DatabaseType?,
+        columnCount: Int
+    ) -> String {
+        guard dataIndex >= 0, dataIndex < row.values.count, let cache = model?.display.cache else { return "" }
+        let existing = cache.box(forID: row.id)
+        if let existing, dataIndex < existing.values.count, let cached = existing.values[dataIndex] {
+            return cached
+        }
+        let rawValue = row.values[dataIndex]
+        let format = dataIndex < formats.count ? formats[dataIndex] : nil
+        let formatted = CellDisplayFormatter.format(
+            rawValue,
+            columnType: type,
+            displayFormat: format,
+            databaseType: databaseType
+        ) ?? rawValue.asText ?? ""
+
+        let neededCount = max(dataIndex + 1, columnCount)
+        let box: RowDisplayBox
+        if let existing {
+            box = existing
+            if box.values.count < neededCount {
+                box.values.append(contentsOf: repeatElement(String?.none, count: neededCount - box.values.count))
+            }
+        } else {
+            box = RowDisplayBox(ContiguousArray<String?>(repeating: nil, count: neededCount))
+        }
+        box.values[dataIndex] = formatted
+        cache.setBox(box, forID: row.id)
+        return formatted
+    }
+
+    // Formats a whole row ahead of the viewport, for the background prewarm.
+    func cacheText(of row: Row, rows: TableRows, formats: [ValueDisplayFormat?], databaseType: DatabaseType?) {
+        guard let cache = model?.display.cache, cache.box(forID: row.id) == nil else { return }
+        let columnCount = rows.columns.count
+        var values = ContiguousArray<String?>(repeating: nil, count: columnCount)
+        for dataIndex in 0..<min(row.values.count, columnCount) {
+            let type = dataIndex < rows.columnTypes.count ? rows.columnTypes[dataIndex] : nil
+            let format = dataIndex < formats.count ? formats[dataIndex] : nil
+            values[dataIndex] = CellDisplayFormatter.format(
+                row.values[dataIndex],
+                columnType: type,
+                displayFormat: format,
+                databaseType: databaseType
+            ) ?? row.values[dataIndex].asText ?? ""
+        }
+        cache.setBox(RowDisplayBox(values), forID: row.id)
+    }
+
+    // MARK: - Appearance
+
+    func appearance(
+        of row: Row,
+        displayRow: Int,
+        column: DataGridColumn,
+        visualState: RowVisualState,
+        pass: Pass,
+        onEmphasizedSelection: Bool
+    ) -> DataGridCellAppearance? {
+        let dataIndex = column.dataIndex
+        guard dataIndex >= 0, dataIndex < row.values.count else { return nil }
+        let rawValue = row.values[dataIndex]
+        let text = displayText(of: row, dataIndex: dataIndex, type: column.type, pass: pass)
+        let isFindMatch = pass.findMatch.map { $0.rowID == row.id && $0.columnID == column.id } ?? false
+
+        return DataGridCellAppearance.resolve(
+            kind: presentation(forDataIndex: dataIndex).kind,
+            content: DataGridCellContent(
+                displayText: text,
+                rawValue: rawValue.asText,
+                placeholder: DataGridCellContent.placeholder(
+                    for: rawValue,
+                    isAbsent: row.isAbsent(dataIndex),
+                    unloadedByteCount: row.unloadedByteCount(dataIndex)
+                )
+            ),
+            state: DataGridCellState(
+                visualState: visualState,
+                isEditable: pass.isEditable,
+                isCurrentFindMatch: isFindMatch,
+                row: displayRow,
+                columnIndex: dataIndex
+            ),
+            palette: pass.palette,
+            nullDisplayString: pass.nullDisplayString,
+            onEmphasizedSelection: onEmphasizedSelection,
+            checkboxMark: checkboxMark(of: row, column: column, checkboxColumns: pass.checkboxColumns),
+            textTone: model?.dataSource?.gridTextTone(for: row.id, column: column),
+            revealsInvisibleCharacters: pass.showsInvisibleCharacters
+        )
+    }
+
+    func checkboxMark(of row: Row, column: DataGridColumn, checkboxColumns: Set<Int>) -> DataGridCheckboxMark? {
+        guard checkboxColumns.contains(column.dataIndex),
+              let isOn = model?.dataSource?.gridCheckboxState(for: row.id, column: column) else { return nil }
+        return isOn ? .checked : .unchecked
+    }
+
+    // A placeholder announces itself by name rather than as the italic marker a sighted reader sees.
+    func accessibilityText(of row: Row, column: DataGridColumn) -> String {
+        guard let model else { return "" }
+        if let spoken = model.dataSource?.gridAccessibilityText(for: row.id, column: column) {
+            return spoken
+        }
+        let dataIndex = column.dataIndex
+        guard dataIndex >= 0, dataIndex < row.values.count else { return "" }
+        let rows = model.rows
+        let text = displayText(
+            of: row,
+            dataIndex: dataIndex,
+            type: column.type,
+            formats: model.store.displayFormats,
+            databaseType: model.configuration.traits.databaseType,
+            columnCount: rows.columns.count
+        )
+        let rawValue = row.values[dataIndex]
+        switch DataGridCellContent.placeholder(
+            for: rawValue,
+            isAbsent: row.isAbsent(dataIndex),
+            unloadedByteCount: row.unloadedByteCount(dataIndex)
+        ) {
+        case .null: return String(localized: "NULL")
+        case .empty: return String(localized: "Empty")
+        case .defaultMarker: return String(localized: "DEFAULT")
+        case .absent: return DataGridCellContent.absentFieldText
+        case .unloaded(let byteCount): return DataGridCellContent.unloadedSpokenText(byteCount: byteCount)
+        case .none: return spokenText(of: text)
+        }
+    }
+
+    // A mark drawn in the cell is read by its name, or VoiceOver says nothing for it.
+    private func spokenText(of text: String) -> String {
+        guard registry.showsInvisibleCharacters else { return text }
+        let revealed = RevealedText(text, marksLineBreaks: true)
+        return revealed.revealsAnyCharacter ? revealed.spokenText : text
+    }
+
+    func pendingChangeDescription(of row: Row, dataIndex: Int) -> String? {
+        DataGridCellTextMark.accessibilityDescription(state: visualState(of: row), columnIndex: dataIndex)
+    }
+
+    func highlightDescription(of row: Row, dataIndex: Int) -> String? {
+        guard let rule = visualState(of: row).drawnHighlightRule(forColumn: dataIndex) else { return nil }
+        return HighlightRuleDescription.condition(of: rule, valueLimit: HighlightRuleDescription.menuValueLimit)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Cells/DataGridCellRegistry.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellRegistry.swift
new file mode 100644
index 0000000000..777417659b
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellRegistry.swift
@@ -0,0 +1,56 @@
+//
+//  DataGridCellRegistry.swift
+//  TablePro
+//
+
+import AppKit
+
+@MainActor
+final class DataGridCellRegistry {
+    private(set) var nullDisplayString: String
+    private(set) var showsInvisibleCharacters: Bool
+    private(set) var palette: DataGridCellPalette
+    private(set) var scope: ThemeScope
+    private var paletteKey: PaletteKey
+
+    private struct PaletteKey: Equatable {
+        let revision: Int
+        let generation: Int
+        let appearance: NSAppearance.Name
+    }
+
+    init(scope: ThemeScope = .live) {
+        self.scope = scope
+        let settings = AppSettingsManager.shared.dataGrid
+        nullDisplayString = settings.nullDisplay
+        showsInvisibleCharacters = settings.showInvisibleCharacters
+        let appearance = NSApp?.effectiveAppearance ?? NSAppearance.currentDrawing()
+        paletteKey = Self.paletteKey(for: appearance)
+        palette = scope.dataGridCellPalette(in: appearance)
+    }
+
+    func reloadSettings(_ settings: DataGridSettings = AppSettingsManager.shared.dataGrid) {
+        nullDisplayString = settings.nullDisplay
+        showsInvisibleCharacters = settings.showInvisibleCharacters
+    }
+
+    // Asked by every row as it draws: the tints resolve in the appearance the row draws in, which only the draw knows.
+    func preparePalette(in appearance: NSAppearance) {
+        let key = Self.paletteKey(for: appearance)
+        guard key != paletteKey else { return }
+        paletteKey = key
+        palette = scope.dataGridCellPalette(in: appearance)
+    }
+
+    // A fixed scope never moves the key, so a new one rebuilds the palette here.
+    func adopt(_ scope: ThemeScope, in appearance: NSAppearance) {
+        self.scope = scope
+        paletteKey = Self.paletteKey(for: appearance)
+        palette = scope.dataGridCellPalette(in: appearance)
+    }
+
+    private static func paletteKey(for appearance: NSAppearance) -> PaletteKey {
+        let change = ThemeEngine.shared.change
+        return PaletteKey(revision: change.revision, generation: change.generation, appearance: appearance.name)
+    }
+}
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellRenderer.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellRenderer.swift
similarity index 75%
rename from apple/TablePro/Views/Results/Cells/DataGridCellRenderer.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridCellRenderer.swift
index b68658d8b7..6928611216 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridCellRenderer.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellRenderer.swift
@@ -7,16 +7,9 @@ import AppKit
 import CoreText
 import TableProTextEngine
 
-/// Draws one data cell into a rect.
-///
-/// The grid draws its cells rather than mounting a view for each, so the drawing has to live apart
-/// from any view. Everything here is a function of the appearance it is handed; the only state is a
-/// bounded cache of laid-out lines, because building a `CTLine` is the expensive part of a cell and
-/// scrolling redraws the same values over and over.
+// The grid draws its cells rather than mounting a view per cell; the only state here is a bounded line cache.
 @MainActor
 final class DataGridCellRenderer {
-    /// A laid-out line depends on nothing but the text and the two attributes it carries, so this is
-    /// the whole identity of a cached line.
     private struct LineKey: Hashable {
         let text: String
         let font: NSFont
@@ -30,12 +23,9 @@ final class DataGridCellRenderer {
         let specialCharacters: SpecialCharacterLine?
     }
 
-    /// A viewport holds a few hundred cells and a scroll reuses them, so this only has to outlive a
-    /// few screens. Cleared wholesale rather than evicted one at a time: the cost of a miss is one
-    /// `CTLine`, and tracking recency would cost more than it saves.
+    // Cleared wholesale rather than evicted one at a time: a miss costs one CTLine.
     private static let lineCacheLimit = 4_096
-    /// Past this many characters a cell can only ever show an ellipsis, and laying out the rest is
-    /// wasted on a value the reader opens the inspector to read anyway.
+    // Past this many characters a cell only ever shows an ellipsis.
     private static let maximumLaidOutCharacters = 300
 
     private var lineCache: [LineKey: LaidOutLine] = [:]
@@ -71,10 +61,18 @@ final class DataGridCellRenderer {
             drawCheckbox(mark, in: rect, controlView: controlView)
         }
         NSGraphicsContext.current?.restoreGraphicsState()
+    }
 
-        if appearance.drawsFocusBorder || appearance.drawsFocusRing {
-            drawCursor(in: rect, color: appearance.focusColor)
-        }
+    func drawRowNumber(_ number: Int, in rect: NSRect, font: NSFont, color: NSColor) {
+        let attributes: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: color]
+        let text = String(number) as NSString
+        let size = text.size(withAttributes: attributes)
+        let inset = DataGridMetrics.cellHorizontalInset
+        let origin = NSPoint(
+            x: max(rect.minX + inset, rect.maxX - inset - size.width),
+            y: rect.midY - size.height / 2
+        )
+        text.draw(at: origin, withAttributes: attributes)
     }
 
     private func drawText(_ appearance: DataGridCellAppearance, in rect: NSRect) {
@@ -114,10 +112,7 @@ final class DataGridCellRenderer {
         context.restoreGState()
     }
 
-    /// Built with the mark's own attribute so `CTLineDraw` draws the line from the font's metrics,
-    /// and so `CTLineCreateTruncatedLine` carries it onto a truncated line and its ellipsis. The
-    /// mark is part of the key because two cells holding the same value in the same font and colour
-    /// are two different drawings once one of them is struck through.
+    // The mark is part of the key: the same value struck through is a different drawing.
     private func line(for text: String, appearance: DataGridCellAppearance) -> LaidOutLine {
         let font = appearance.font
         let key = LineKey(
@@ -169,21 +164,11 @@ final class DataGridCellRenderer {
         context.restoreGState()
     }
 
-    /// Drawn by the system's own checkbox cell, so it matches every other checkbox in the window in
-    /// each appearance and contrast setting rather than approximating one with a symbol.
+    // The system's own checkbox cell, so it matches every other checkbox in each appearance and contrast setting.
     private func drawCheckbox(_ mark: DataGridCheckboxMark, in rect: NSRect, controlView: NSView) {
         let frame = DataGridCheckboxMark.frame(in: rect)
         guard !frame.isEmpty else { return }
         checkboxCell.state = mark == .checked ? .on : .off
         checkboxCell.draw(withFrame: frame, in: controlView)
     }
-
-    /// A mounted cell got its cursor from AppKit's exterior focus ring; a drawn cell has no view to
-    /// hang one on, so it is drawn to the same shape.
-    private func drawCursor(in rect: NSRect, color: NSColor) {
-        let path = NSBezierPath(rect: rect.insetBy(dx: 1, dy: 1))
-        path.lineWidth = 2
-        color.setStroke()
-        path.stroke()
-    }
 }
diff --git a/apple/TablePro/Views/DataGrid/Cells/DataGridCellText.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellText.swift
new file mode 100644
index 0000000000..72b22443c9
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellText.swift
@@ -0,0 +1,77 @@
+//
+//  DataGridCellText.swift
+//  TablePro
+//
+
+import AppKit
+
+extension NSFont {
+    func withTraits(_ traits: NSFontDescriptor.SymbolicTraits) -> NSFont {
+        let descriptor = fontDescriptor.withSymbolicTraits(traits)
+        return NSFont(descriptor: descriptor, size: pointSize) ?? self
+    }
+}
+
+internal extension String {
+    var containsLineBreak: Bool {
+        let nsString = self as NSString
+        let length = nsString.length
+        guard length > 0 else { return false }
+        for index in 0..<length {
+            let character = nsString.character(at: index)
+            if character == 0x0A || character == 0x0D || character == 0x0B || character == 0x0C
+                || character == 0x85 || character == 0x2028 || character == 0x2029 {
+                return true
+            }
+        }
+        return false
+    }
+
+    var sanitizedForCellDisplay: String {
+        flattenedOntoOneLine(keepingLoneCarriageReturns: false)
+    }
+
+    // A CR with no LF after it is usually what is left of a CRLF split on LF, so a cell keeps it for the renderer to mark.
+    var flattenedForCell: String {
+        flattenedOntoOneLine(keepingLoneCarriageReturns: true)
+    }
+
+    // What a cell shows while marks are off: the lone CR reads as the space it always did.
+    var shownWithoutMarks: String {
+        guard utf16.contains(0x0D) else { return self }
+        return replacingOccurrences(of: "\r", with: " ", options: .literal)
+    }
+
+    private func flattenedOntoOneLine(keepingLoneCarriageReturns: Bool) -> String {
+        let nsString = self as NSString
+        let length = nsString.length
+        guard length > 0 else { return self }
+
+        var mutable: NSMutableString?
+        var copiedUpTo = 0
+        for index in 0..<length {
+            let character = nsString.character(at: index)
+            guard character == 0x0A || character == 0x0D || character == 0x0B || character == 0x0C
+                || character == 0x85 || character == 0x2028 || character == 0x2029 else { continue }
+            if character == 0x0D, keepingLoneCarriageReturns,
+               index + 1 >= length || nsString.character(at: index + 1) != 0x0A {
+                continue
+            }
+
+            if mutable == nil {
+                mutable = NSMutableString(capacity: length)
+            }
+            if index > copiedUpTo {
+                mutable?.append(nsString.substring(with: NSRange(location: copiedUpTo, length: index - copiedUpTo)))
+            }
+            mutable?.append(" ")
+            copiedUpTo = index + 1
+        }
+
+        guard let result = mutable else { return self }
+        if copiedUpTo < length {
+            result.append(nsString.substring(with: NSRange(location: copiedUpTo, length: length - copiedUpTo)))
+        }
+        return result as String
+    }
+}
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellTextMark.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridCellTextMark.swift
similarity index 60%
rename from apple/TablePro/Views/Results/Cells/DataGridCellTextMark.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridCellTextMark.swift
index 09576271ee..5521993f3f 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridCellTextMark.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridCellTextMark.swift
@@ -5,23 +5,12 @@
 
 import AppKit
 
-/// The line a pending change draws through or under a cell's own text, the way Pages marks tracked
-/// changes.
-///
-/// The tints alone could not carry this. A selected row paints over them, so a reader who selects
-/// the rows they are about to save loses every mark at once, and a tint says nothing to a reader
-/// who cannot see colour or is using a client that reads the grid rather than looking at it. The
-/// line is drawn in the text's own colour, so it survives selection, Dark Mode, grayscale and
-/// Increase Contrast, and the tints stay as the second cue.
+// Drawn in the text's own color, so the mark survives selection, Dark Mode and Increase Contrast where a tint does not.
 enum DataGridCellTextMark: Equatable {
-    /// A row staged for deletion, struck through as Pages strikes deleted text.
     case struckThrough
-    /// A new row, or an edited cell, underlined as Pages underlines inserted text.
     case underlined
 
-    /// What a pending change makes of a cell, or nil when nothing is staged for it.
-    ///
-    /// A staged delete outranks the rest: the row is going away whatever was typed into it first.
+    // A staged delete outranks the rest: the row is going away whatever was typed into it first.
     static func resolve(state: RowVisualState, columnIndex: Int) -> DataGridCellTextMark? {
         if state.isDeleted { return .struckThrough }
         if state.isInserted { return .underlined }
@@ -29,12 +18,7 @@ enum DataGridCellTextMark: Equatable {
         return state.isModified(columnIndex: columnIndex) ? .underlined : nil
     }
 
-    /// Read by `CTLineDraw` itself, which draws both lines from the font's own metrics. Measured on
-    /// macOS 27: a `CTLine` built from an attributed string carrying `.underlineStyle` or
-    /// `.strikethroughStyle` draws that line, in the run's foreground colour, and
-    /// `CTLineCreateTruncatedLine` carries it onto the truncated line. So the renderer never
-    /// computes a line's position, thickness or width, and a cell that truncates is marked to
-    /// exactly where its text ends.
+    // CTLineDraw draws both lines from the font's metrics and CTLineCreateTruncatedLine carries them onto the ellipsis.
     var attributes: [NSAttributedString.Key: Any] {
         switch self {
         case .struckThrough:
diff --git a/apple/TablePro/Views/DataGrid/Cells/DataGridColumnWidthCalculator.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridColumnWidthCalculator.swift
new file mode 100644
index 0000000000..88021d9cb7
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridColumnWidthCalculator.swift
@@ -0,0 +1,126 @@
+//
+//  DataGridColumnWidthCalculator.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+import TableProTextEngine
+
+@MainActor
+struct DataGridColumnWidthCalculator {
+    private static let minColumnWidth: CGFloat = 60
+    private static let maxColumnWidth: CGFloat = 800
+    private static let minFitToContentWidth: CGFloat = 300
+    private static let fitToContentViewportFraction: CGFloat = 0.5
+    private static let sampleRowCount = 30
+    private static let wideResultSampleRowCount = 10
+    private static let wideResultColumnCount = 50
+    private static let fitToContentValueBudget = 200_000
+    private static let maxMeasureChars = 50
+    private static let headerPadding: CGFloat = 48
+    private static let headerCharWidthRatio: CGFloat = 0.75
+
+    struct Input {
+        let column: DataGridColumn
+        let accessory: DataGridCellAccessory
+        let displayFormat: ValueDisplayFormat?
+    }
+
+    private struct Budget {
+        let cap: CGFloat
+        let measuredCharLimit: Int
+        let sampledRows: Int
+    }
+
+    let rows: TableRows
+    let databaseType: DatabaseType?
+    let nullDisplayString: String
+    let revealsInvisibleCharacters: Bool
+    let fonts: DataGridFontCache
+
+    static func fitToContentCap(availableWidth: CGFloat) -> CGFloat {
+        let proportional = availableWidth * fitToContentViewportFraction
+        return min(max(proportional, minFitToContentWidth), maxColumnWidth)
+    }
+
+    // The first paint samples, because it measures every column before the grid can draw a row.
+    func automaticWidth(_ input: Input) -> CGFloat {
+        let sampled = rows.columns.count > Self.wideResultColumnCount ? Self.wideResultSampleRowCount : Self.sampleRowCount
+        return measure(input, budget: Budget(cap: Self.maxColumnWidth, measuredCharLimit: Self.maxMeasureChars, sampledRows: sampled))
+    }
+
+    // An explicit fit reads the page, bounded across the whole gesture so fitting every column of a wide result stays cheap.
+    func fittedWidth(_ input: Input, availableWidth: CGFloat, fittedColumnCount: Int = 1) -> CGFloat {
+        let cap = Self.fitToContentCap(availableWidth: availableWidth)
+        let charWidth = fonts.monoCharWidth
+        let limit = charWidth > 0 ? Int((cap / charWidth).rounded(.up)) : Self.maxMeasureChars
+        let sampled = max(Self.sampleRowCount, Self.fitToContentValueBudget / max(1, fittedColumnCount))
+        return measure(input, budget: Budget(cap: cap, measuredCharLimit: limit, sampledRows: sampled))
+    }
+
+    // Whole points: NSTableView pixel-aligns a fractional width during layout and reports it as a resize (measured).
+    private func measure(_ input: Input, budget: Budget) -> CGFloat {
+        measuredWidth(input, budget: budget).rounded(.up)
+    }
+
+    private func measuredWidth(_ input: Input, budget: Budget) -> CGFloat {
+        let charWidth = fonts.monoCharWidth
+        let dataIndex = input.column.dataIndex
+        let headerCharCount = (input.column.name as NSString).length
+        var maxWidth = CGFloat(headerCharCount) * charWidth * Self.headerCharWidthRatio + Self.headerPadding
+
+        let totalRows = rows.count
+        let step = max(1, totalRows / max(1, budget.sampledRows))
+
+        for index in stride(from: 0, to: totalRows, by: step) {
+            let rawValue = rows.value(at: index, column: dataIndex)
+            let formatted = CellDisplayFormatter.format(
+                rawValue,
+                columnType: input.column.type,
+                displayFormat: input.displayFormat,
+                databaseType: databaseType
+            ) ?? ""
+            let placeholder = DataGridCellContent.placeholder(
+                for: rawValue,
+                isAbsent: rows.isAbsent(row: index, column: dataIndex),
+                unloadedByteCount: rows.unloadedByteCount(row: index, column: dataIndex)
+            )
+            let value = DataGridCellContent.resolvedDisplayText(
+                formatted,
+                placeholder: placeholder,
+                nullDisplayString: nullDisplayString
+            )
+
+            let charCount = min((value as NSString).length, budget.measuredCharLimit)
+            let markedWidth = revealsInvisibleCharacters && placeholder == nil
+                ? markedWidth(of: value, length: charCount)
+                : nil
+            let textWidth = markedWidth ?? CGFloat(charCount) * charWidth
+            maxWidth = max(maxWidth, textWidth + input.accessory.measurementPadding)
+
+            if maxWidth >= budget.cap {
+                return budget.cap
+            }
+        }
+
+        return min(max(maxWidth, Self.minColumnWidth), budget.cap)
+    }
+
+    // A mark is wider than the character it stands for, so a value holding one is laid out.
+    private func markedWidth(of value: String, length: Int) -> CGFloat? {
+        let text = value as NSString
+        var index = 0
+        while index < length {
+            let unit = text.character(at: index)
+            if unit == 0x0D || SpecialCharacter.mayBeSpecial(unit) { break }
+            index += 1
+        }
+        guard index < length else { return nil }
+        let marked = SpecialCharacterLine(
+            NSAttributedString(string: text.substring(to: length), attributes: [.font: fonts.regular]),
+            style: SpecialCharacterStyle(marksLineBreaks: true)
+        )
+        return CGFloat(CTLineGetTypographicBounds(marked.line, nil, nil, nil))
+    }
+}
diff --git a/apple/TablePro/Views/Results/Cells/DataGridMetrics.swift b/apple/TablePro/Views/DataGrid/Cells/DataGridMetrics.swift
similarity index 68%
rename from apple/TablePro/Views/Results/Cells/DataGridMetrics.swift
rename to apple/TablePro/Views/DataGrid/Cells/DataGridMetrics.swift
index 44a3c5a32c..05091ede89 100644
--- a/apple/TablePro/Views/Results/Cells/DataGridMetrics.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/DataGridMetrics.swift
@@ -11,9 +11,11 @@ enum DataGridMetrics {
     static let rowNumberColumnMinWidth: CGFloat = 40
     static let dataColumnMinWidth: CGFloat = 30
     static let dataColumnMaxWidth: CGFloat = 1_200
-    /// Room the grid scrolls past its last column. Without it the last column's divider sits on the
-    /// viewport's last point, which a resizable window claims for its own edge resize.
+    // Keeps the last column's divider off the viewport edge a resizable window claims for its own resize.
     static let trailingSpace: CGFloat = 40
+    static let frozenDividerThickness: CGFloat = 2
+    // Frozen columns that would leave the rest less than a third of the grid scroll instead.
+    static let maximumFrozenShare: CGFloat = 2.0 / 3.0
 
     // The Row height setting is a floor: a grid font taller than the row would be cut at the cell edge.
     static func rowHeight(_ setting: DataGridRowHeight, font: NSFont) -> CGFloat {
diff --git a/apple/TablePro/Views/Results/RowVisualIndex.swift b/apple/TablePro/Views/DataGrid/Cells/RowVisualIndex.swift
similarity index 71%
rename from apple/TablePro/Views/Results/RowVisualIndex.swift
rename to apple/TablePro/Views/DataGrid/Cells/RowVisualIndex.swift
index 4990b2aafc..140f135bcc 100644
--- a/apple/TablePro/Views/Results/RowVisualIndex.swift
+++ b/apple/TablePro/Views/DataGrid/Cells/RowVisualIndex.swift
@@ -3,7 +3,8 @@
 //  TablePro
 //
 
-import Foundation
+import AppKit
+import TableProTheme
 
 @MainActor
 final class RowVisualIndex {
@@ -19,17 +20,15 @@ final class RowVisualIndex {
         states.removeAll(keepingCapacity: true)
     }
 
-    func rebuild(from changeManager: AnyChangeManager) {
+    func rebuild(from changeManager: AnyChangeManager?) {
         states.removeAll(keepingCapacity: true)
+        guard let changeManager else { return }
 
         let insertedRowIDs = changeManager.insertedRowIDs
         guard changeManager.hasChanges || !insertedRowIDs.isEmpty else { return }
 
         for rowChange in changeManager.rowChanges {
-            states[rowChange.rowID] = Self.makeState(
-                for: rowChange,
-                inserted: insertedRowIDs.contains(rowChange.rowID)
-            )
+            states[rowChange.rowID] = Self.makeState(for: rowChange, inserted: insertedRowIDs.contains(rowChange.rowID))
         }
 
         for rowID in insertedRowIDs where states[rowID] == nil {
@@ -37,7 +36,11 @@ final class RowVisualIndex {
         }
     }
 
-    func updateRow(_ rowID: RowID, from changeManager: AnyChangeManager) {
+    func updateRow(_ rowID: RowID, from changeManager: AnyChangeManager?) {
+        guard let changeManager else {
+            states.removeValue(forKey: rowID)
+            return
+        }
         let isInserted = changeManager.insertedRowIDs.contains(rowID)
 
         if let rowChange = changeManager.rowChanges.first(where: { $0.rowID == rowID }) {
@@ -52,11 +55,7 @@ final class RowVisualIndex {
         }
     }
 
-    private static let insertedState = RowVisualState(
-        isDeleted: false,
-        isInserted: true,
-        modifiedColumns: []
-    )
+    private static let insertedState = RowVisualState(isDeleted: false, isInserted: true, modifiedColumns: [])
 
     private static func makeState(for rowChange: RowChange, inserted: Bool) -> RowVisualState {
         let isDeleted = rowChange.type == .delete
@@ -83,3 +82,12 @@ final class RowVisualIndex {
         }
     }
 }
+
+extension RowVisualState {
+    // The wash a whole row carries, read by both panes so they cannot disagree.
+    @MainActor func tint(in scope: ThemeScope) -> NSColor? {
+        if isDeleted { return scope.resolved[.gridDeleted] }
+        if isInserted { return scope.resolved[.gridInserted] }
+        return highlight.rowColor?.washColor
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridCommandScope.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridCommandScope.swift
new file mode 100644
index 0000000000..f0d312d302
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridCommandScope.swift
@@ -0,0 +1,92 @@
+//
+//  DataGridCommandScope.swift
+//  TablePro
+//
+
+import Foundation
+
+// What a command acts on. A context menu acts on the selection only when the click lands in it, else on the
+// clicked cell or row (NSTableView clickedRow); the selection itself never moves.
+struct DataGridCommandScope: Equatable {
+    let selection: GridSelection
+    // The cell a one-cell command reads: the clicked cell, else the active cell. Nil over the row numbers.
+    let focus: GridCoord?
+    // Opened over the row numbers, so Copy means the rows whatever shape the selection has.
+    let isRowHeader: Bool
+
+    static func current(_ selection: GridSelection) -> DataGridCommandScope {
+        DataGridCommandScope(selection: selection, focus: selection.activeCell, isRowHeader: false)
+    }
+
+    static func contextMenu(
+        selection: GridSelection,
+        row: Int,
+        displayColumn: Int?,
+        columnCount: Int
+    ) -> DataGridCommandScope {
+        guard let displayColumn else {
+            if selection.affectedRows.contains(row) {
+                return DataGridCommandScope(selection: selection, focus: nil, isRowHeader: true)
+            }
+            guard columnCount > 0 else {
+                return DataGridCommandScope(selection: .empty, focus: nil, isRowHeader: true)
+            }
+            let column = min(max(selection.activeCell?.displayColumn ?? 0, 0), columnCount - 1)
+            let cell = GridCoord(row: row, displayColumn: column)
+            let wholeRow = GridSelection(
+                rectangles: [GridRect(rows: row...row, columns: 0...(columnCount - 1))],
+                activeCell: cell,
+                anchor: cell
+            )
+            return DataGridCommandScope(selection: wholeRow, focus: nil, isRowHeader: true)
+        }
+        let clicked = GridCoord(row: row, displayColumn: displayColumn)
+        if selection.contains(clicked) {
+            return DataGridCommandScope(selection: selection, focus: clicked, isRowHeader: false)
+        }
+        return DataGridCommandScope(selection: GridSelectionReducer.single(clicked), focus: clicked, isRowHeader: false)
+    }
+}
+
+// A menu item's scope, held by identity: a reload under an open menu cannot retarget the command.
+struct DataGridMenuContext {
+    let selection: GridSelectionSnapshot
+    let focus: GridSelectionSnapshot.Cell?
+    let isRowHeader: Bool
+    // Whether the menu acts on the grid's own selection, which the selection summary describes.
+    let isCurrentSelection: Bool
+
+    @MainActor
+    init(_ scope: DataGridCommandScope, model: DataGridModel) {
+        let rows = model.rows
+        selection = GridSelectionSnapshot(scope.selection, order: model.order, rows: rows, columns: model.columns)
+        focus = scope.focus.flatMap { coord in
+            guard let rowID = model.rowID(at: coord.row), let column = model.columns.column(at: coord.displayColumn) else {
+                return nil
+            }
+            return GridSelectionSnapshot.Cell(rowID: rowID, columnID: column.id)
+        }
+        isRowHeader = scope.isRowHeader
+        isCurrentSelection = scope.selection == model.selection
+    }
+
+    @MainActor
+    func scope(in model: DataGridModel) -> DataGridCommandScope {
+        let rows = model.rows
+        let resolved = selection.resolved(order: model.order, rows: rows, columns: model.columns)
+            .clamped(rowLimit: model.rowCount, columnLimit: model.columns.count)
+        let focusCoord = focus.flatMap { cell -> GridCoord? in
+            guard let row = model.displayIndex(of: cell.rowID),
+                  let column = model.columns.displayPosition(of: cell.columnID) else { return nil }
+            return GridCoord(row: row, displayColumn: column)
+        }
+        return DataGridCommandScope(selection: resolved, focus: focusCoord, isRowHeader: isRowHeader)
+    }
+}
+
+// A cell a command writes or reads, by identity; row is its display position when the command was resolved.
+struct DataGridCommandCell: Equatable {
+    let rowID: RowID
+    let row: Int
+    let column: DataGridColumn
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+Copy.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+Copy.swift
new file mode 100644
index 0000000000..9cb8f2fdb2
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+Copy.swift
@@ -0,0 +1,381 @@
+//
+//  DataGridCommands+Copy.swift
+//  TablePro
+//
+
+import AppKit
+import os
+import TableProPluginKit
+
+private let copyLogger = Logger(subsystem: "com.TablePro", category: "DataGridCopy")
+
+extension DataGridCommands {
+    var rowCopyFormat: RowCopyFormat {
+        configuration.appliesRowCopyFormat ? AppSettingsManager.shared.dataGrid.rowCopyFormat : .rows
+    }
+
+    func canCopy(_ scope: DataGridCommandScope) -> Bool {
+        !scope.selection.isEmpty && !rowIDs(scope).isEmpty
+    }
+
+    // Copies the cursor's cell when a click selected one row, rows in the Row Copy Format when rows were picked or
+    // several are selected, and a range as typed fields.
+    func copy(_ scope: DataGridCommandScope) {
+        let selection = scope.selection
+        guard !selection.isEmpty else { return }
+        if !scope.isRowHeader, selection.mode == .cursor, selection.affectedRows.count == 1,
+           let focus = scope.focus ?? selection.activeCell, let cell = commandCell(at: focus) {
+            copyCellValue(cell)
+            return
+        }
+        if scope.isRowHeader || isWholeRows(selection) {
+            copyRows(scope, as: rowCopyFormat)
+            return
+        }
+        if selection.uniqueCellCount == 1, let cell = cells(scope).first {
+            copyCellValue(cell)
+            return
+        }
+        copyRange(selection)
+    }
+
+    // MARK: - Rows
+
+    // The ceiling each format's converter already puts on its text, taken first so the paste payload holds the same rows.
+    private func capped(_ rowIDs: [RowID]) -> [RowID] {
+        let limit = RowOperationsManager.maxClipboardRows
+        guard rowIDs.count > limit else { return rowIDs }
+        copyLogger.warning("Clipboard copy truncated: \(rowIDs.count) rows selected, capping at \(limit)")
+        return Array(rowIDs.prefix(limit))
+    }
+
+    var visibleProjection: VisibleColumnProjection {
+        VisibleColumnProjection(indices: model.columns.columns.map(\.dataIndex))
+    }
+
+    func selectedProjection(_ scope: DataGridCommandScope) -> VisibleColumnProjection {
+        VisibleColumnProjection(indices: selectedColumns(scope).map(\.dataIndex))
+    }
+
+    func copyRows(_ scope: DataGridCommandScope, as format: RowCopyFormat) {
+        let ids = rowIDs(scope)
+        guard !ids.isEmpty else { return }
+        guard loader.ensureLoaded(ids, columns: nil, in: model, retry: {
+            // The scope names display positions, so it runs again only while they show the same records.
+            guard rowIDs(scope) == ids else {
+                NSSound.beep()
+                return
+            }
+            copyRows(scope, as: format)
+        }) else { return }
+        switch format {
+        case .rows:
+            // An owner that writes its own pasteboard type (staged SQL, structure definitions) answers first.
+            if model.actions?.gridCopyRows(ids) == true { return }
+            writeTSV(ids, includeHeaders: false)
+        case .rowsWithHeaders:
+            writeTSV(ids, includeHeaders: true)
+        case .json:
+            writeJSON(ids, projection: selectedProjection(scope))
+        case .csv:
+            writeCSV(ids, projection: selectedProjection(scope), includeHeaders: false)
+        case .csvWithHeaders:
+            writeCSV(ids, projection: selectedProjection(scope), includeHeaders: true)
+        case .markdown:
+            writeMarkdown(ids, projection: selectedProjection(scope))
+        }
+    }
+
+    private func copiedRows(_ ids: [RowID]) -> [Row] {
+        let rows = model.rows
+        return capped(ids).compactMap { rows.row(withID: $0) }
+    }
+
+    // Carried by every row copy, so a paste into a grid takes the rows rather than parsing the text.
+    private func rowsPayload(_ rows: [Row], projection: VisibleColumnProjection) -> GridRowsClipboardPayload {
+        let changeState = model.changeState
+        return GridRowsClipboardPayload(
+            columns: projection.columns(model.rows.columns),
+            copying: rows,
+            expressionColumns: rows.map { changeState?.expressionColumns(forRow: $0.id) ?? [] },
+            projection: projection
+        )
+    }
+
+    private func writeTSV(_ ids: [RowID], includeHeaders: Bool) {
+        let copied = copiedRows(ids)
+        guard !copied.isEmpty else { return }
+        let tableRows = model.rows
+        let projection = visibleProjection
+        let columnTypes = projection.columnTypes(tableRows.columnTypes)
+        let columns = projection.columns(tableRows.columns)
+        var lines: [String] = includeHeaders ? [columns.joined(separator: "\t")] : []
+        var htmlRows: [[String]] = []
+        for row in copied {
+            let formatted = Self.formatRowValues(projection.values(Array(row.values)), columnTypes: columnTypes)
+            lines.append(formatted.joined(separator: "\t"))
+            htmlRows.append(formatted)
+        }
+        let html = includeHeaders ? HtmlTableEncoder.encode(rows: htmlRows, headers: columns) : nil
+        ClipboardService.shared.writeRows(
+            tsv: lines.joined(separator: "\n"),
+            html: html,
+            gridRows: rowsPayload(copied, projection: projection)
+        )
+    }
+
+    private func writeJSON(_ ids: [RowID], projection: VisibleColumnProjection) {
+        let copied = copiedRows(ids)
+        let displayIndices = Set(copied.compactMap { model.displayIndex(of: $0.id) })
+        guard !displayIndices.isEmpty else { return }
+        let output = ResultJsonSerializer.serialize(
+            tableRows: model.rows,
+            displayIDs: model.order.filteredIDs,
+            selectedDisplayIndices: displayIndices,
+            columns: projection
+        )
+        guard output.rowCount > 0 else { return }
+        ClipboardService.shared.writeText(output.json, gridRows: rowsPayload(copied, projection: projection))
+    }
+
+    private func writeCSV(_ ids: [RowID], projection: VisibleColumnProjection, includeHeaders: Bool) {
+        let copied = copiedRows(ids)
+        guard !copied.isEmpty else { return }
+        let tableRows = model.rows
+        let converter = CsvRowConverter(
+            columns: projection.columns(tableRows.columns),
+            columnTypes: projection.columnTypes(tableRows.columnTypes)
+        )
+        ClipboardService.shared.writeCsv(
+            converter.generateCsv(rows: copied.map { projection.values(Array($0.values)) }, includeHeaders: includeHeaders),
+            gridRows: rowsPayload(copied, projection: projection)
+        )
+    }
+
+    private func writeMarkdown(_ ids: [RowID], projection: VisibleColumnProjection) {
+        let copied = copiedRows(ids)
+        guard !copied.isEmpty else { return }
+        let tableRows = model.rows
+        let converter = MarkdownTableConverter(
+            columns: projection.columns(tableRows.columns),
+            columnTypes: projection.columnTypes(tableRows.columnTypes)
+        )
+        ClipboardService.shared.writeText(
+            converter.generateMarkdown(rows: copied.map { projection.values(Array($0.values)) }),
+            gridRows: rowsPayload(copied, projection: projection)
+        )
+    }
+
+    static func formatRowValues(_ values: [PluginCellValue], columnTypes: [ColumnType]) -> [String] {
+        values.enumerated().map { index, cell in
+            switch cell {
+            case .null:
+                return "NULL"
+            case .text(let value):
+                let columnType = columnTypes.indices.contains(index) ? columnTypes[index] : nil
+                return BlobFormattingService.shared.formatIfNeeded(value, columnType: columnType, for: .copy)
+            case .bytes(let data):
+                return BlobFormattingService.shared.format(data, for: .copy) ?? ""
+            }
+        }
+    }
+
+    // MARK: - Statements
+
+    // The one column a cell selection covers, else the focus cell's: the clicked one in a menu, the active one elsewhere.
+    func inClauseColumn(_ scope: DataGridCommandScope) -> DataGridColumn? {
+        guard !scope.isRowHeader else { return nil }
+        if !isWholeRows(scope.selection) {
+            let positions = scope.selection.affectedColumns
+            if positions.count == 1, let only = positions.first {
+                return model.columns.column(at: only)
+            }
+        }
+        return scope.focus.flatMap { model.columns.column(at: $0.displayColumn) }
+    }
+
+    func copyRowsAsInClause(_ scope: DataGridCommandScope) {
+        guard let column = inClauseColumn(scope) else { return }
+        let ids = rowIDs(scope)
+        guard !ids.isEmpty else { return }
+        guard loader.ensureLoaded(ids, columns: IndexSet(integer: column.dataIndex), in: model, retry: {
+            guard rowIDs(scope) == ids else {
+                NSSound.beep()
+                return
+            }
+            copyRowsAsInClause(scope)
+        }) else { return }
+        let tableRows = model.rows
+        let values = ids.compactMap { tableRows.row(withID: $0)?[column.dataIndex] }
+        guard !values.isEmpty else { return }
+        // Without an owner's driver the engine's dialect escapes: MySQL and ClickHouse read a backslash as one.
+        let text = model.actions?.gridSQLExporter?.inClause(values: values, column: column)
+            ?? InClauseConverter(
+                columnIndex: 0,
+                columnTypes: [column.type ?? .text(rawType: nil)],
+                escapeStringLiteral: configuration.traits.databaseType
+                    .flatMap { try? resolveSQLDialect(for: $0) }
+                    .map { escapeStringLiteralFromDialect($0) },
+                stringLiteralPrefix: configuration.traits.stringLiteralPrefix
+            ).generateInClause(rows: values.map { [$0] })
+        guard !text.isEmpty else { return }
+        ClipboardService.shared.writeText(text)
+    }
+
+    // The statements leave out the columns the server owns, which only the schema names.
+    func canCopyAsInsert(_ scope: DataGridCommandScope) -> Bool {
+        guard offers(.copyAsSQL), let exporter = model.actions?.gridSQLExporter else { return false }
+        return exporter.canCopyAsInsert(model.rows) && !rowIDs(scope).isEmpty
+    }
+
+    func canCopyAsUpdate(_ scope: DataGridCommandScope) -> Bool {
+        guard canCopyAsInsert(scope), let exporter = model.actions?.gridSQLExporter else { return false }
+        return exporter.canCopyAsUpdate(model.rows)
+    }
+
+    // A copy that produced no statement leaves the clipboard as it was.
+    func copyRowsAsStatements(_ scope: DataGridCommandScope, update: Bool) {
+        guard update ? canCopyAsUpdate(scope) : canCopyAsInsert(scope),
+              let exporter = model.actions?.gridSQLExporter else { return }
+        let ids = rowIDs(scope)
+        guard loader.ensureLoaded(ids, columns: nil, in: model, retry: {
+            guard rowIDs(scope) == ids else {
+                NSSound.beep()
+                return
+            }
+            copyRowsAsStatements(scope, update: update)
+        }) else { return }
+        let columns = selectedColumns(scope)
+        let statements = update
+            ? exporter.updateStatements(for: ids, columns: columns, in: model.rows)
+            : exporter.insertStatements(for: ids, columns: columns, in: model.rows)
+        guard let statements, !statements.isEmpty else { return }
+        ClipboardService.shared.writeText(statements)
+    }
+
+    // MARK: - Cells
+
+    func copyCellValue(_ cell: DataGridCommandCell) {
+        let dataIndex = cell.column.dataIndex
+        guard loader.ensureLoaded([cell.rowID], columns: IndexSet(integer: dataIndex), in: model, retry: {
+            copyCellValue(cell)
+        }) else { return }
+        guard let row = storedRow(cell.rowID), dataIndex < row.values.count else { return }
+        let value = row.values[dataIndex]
+        if model.changeState?.isExpression(rowID: row.id, columnIndex: dataIndex) == true, let sql = value.asText {
+            ClipboardService.shared.writeCells(GridCellsClipboardPayload(text: sql, fields: [[sql]], expressionFields: [0: [0]]))
+            return
+        }
+        let text = cellCopyText(value, column: cell.column)
+        ClipboardService.shared.writeCells(GridCellsClipboardPayload(text: text, fields: [[value.isNull ? nil : text]]))
+    }
+
+    // One cell copies as the cell reads, its display format applied; a format saved before the column changed type is skipped.
+    func cellCopyText(_ value: PluginCellValue, column: DataGridColumn) -> String {
+        let format = model.displayFormat(for: column)
+        let databaseType = configuration.traits.databaseType
+        if case .bytes(let data) = value {
+            return format.flatMap { format in
+                guard format.isApplicable(to: column.type, databaseType: databaseType) else { return nil }
+                return ValueDisplayFormatter.apply(data, format: format, columnType: column.type)
+            }
+                ?? BlobFormattingService.shared.format(data, for: .copy)
+                ?? ""
+        }
+        let text = value.asText ?? "NULL"
+        if let format, format != .raw,
+           format.isApplicable(to: column.type, databaseType: databaseType),
+           let formatted = ValueDisplayFormatter.apply(text, format: format, columnType: column.type) {
+            return formatted
+        }
+        return BlobFormattingService.shared.formatIfNeeded(text, columnType: column.type, for: .copy)
+    }
+
+    // The block in the order the reader sees it, each field typed, NULL kept and staged SQL marked.
+    func copyRange(_ selection: GridSelection) {
+        guard let rect = selection.boundingRectangle else { return }
+        let rowCount = model.rowCount
+        let maxRows = RowOperationsManager.maxClipboardRows
+        let lastRow = min(rect.rows.upperBound, max(0, rowCount - 1), rect.rows.lowerBound + maxRows - 1)
+        let positions = Array(rect.columns).filter { $0 >= 0 && $0 < model.columns.count }
+        guard rect.rows.lowerBound <= lastRow, !positions.isEmpty else { return }
+        let rowRange = rect.rows.lowerBound...lastRow
+        let selectedRowCount = min(rect.rows.upperBound, rowCount - 1) - rect.rows.lowerBound + 1
+        let ids = rowRange.map { model.rowID(at: $0) }
+        let copiedColumns = IndexSet(positions.compactMap { model.columns.dataIndex(atDisplayPosition: $0) })
+        guard loader.ensureLoaded(ids.compactMap { $0 }, columns: copiedColumns, in: model, retry: {
+            // The block names display positions, so it runs again only while they show the same records.
+            guard rowRange.map({ model.rowID(at: $0) }) == ids else {
+                NSSound.beep()
+                return
+            }
+            copyRange(selection)
+        }) else { return }
+
+        let tableRows = model.rows
+        let changeState = model.changeState
+        let isTruncated = selectedRowCount > maxRows
+        if isTruncated {
+            copyLogger.warning("Clipboard copy truncated: \(selectedRowCount) rows selected, capping at \(maxRows)")
+        }
+        var lines: [[String?]] = []
+        lines.reserveCapacity(rowRange.count)
+        var expressionFields: [Int: Set<Int>] = [:]
+        for displayRow in rowRange {
+            guard let row = model.order.row(at: displayRow, in: tableRows) else {
+                lines.append(Array(repeating: "", count: positions.count))
+                continue
+            }
+            let expressions = changeState?.expressionColumns(forRow: row.id) ?? []
+            var fields: [String?] = []
+            fields.reserveCapacity(positions.count)
+            for position in positions {
+                guard selection.contains(row: displayRow, displayColumn: position),
+                      let column = model.columns.column(at: position),
+                      column.dataIndex < row.values.count else {
+                    fields.append("")
+                    continue
+                }
+                let cell = row.values[column.dataIndex]
+                if expressions.contains(column.dataIndex), let sql = cell.asText {
+                    expressionFields[lines.count, default: []].insert(fields.count)
+                    fields.append(sql)
+                    continue
+                }
+                fields.append(RowValueCopyFormatter.copyText(cell: cell, columnType: column.type))
+            }
+            lines.append(fields)
+        }
+
+        var text = lines.map { $0.map { $0 ?? "NULL" }.joined(separator: "\t") }.joined(separator: "\n")
+        if isTruncated {
+            text.append("\n(truncated, showing first \(maxRows) of \(selectedRowCount) rows)")
+        }
+        ClipboardService.shared.writeCells(GridCellsClipboardPayload(
+            text: text,
+            fields: lines,
+            expressionFields: expressionFields.isEmpty ? nil : expressionFields
+        ))
+    }
+
+    // MARK: - Columns
+
+    func copyColumnValues(_ column: DataGridColumn) {
+        let rowCount = min(model.rowCount, PluginRowLimits.emergencyMax)
+        guard rowCount > 0 else { return }
+        let tableRows = model.rows
+        let ids = (0..<rowCount).compactMap { model.order.rowID(at: $0, in: tableRows) }
+        guard loader.ensureLoaded(ids, columns: IndexSet(integer: column.dataIndex), in: model, retry: {
+            copyColumnValues(column)
+        }) else { return }
+        let current = model.rows
+        var lines: [String] = []
+        lines.reserveCapacity(ids.count)
+        for rowID in ids {
+            guard let row = current.row(withID: rowID), column.dataIndex < row.values.count else { continue }
+            lines.append(RowValueCopyFormatter.copyText(cell: row.values[column.dataIndex], columnType: column.type) ?? "NULL")
+        }
+        guard !lines.isEmpty else { return }
+        ClipboardService.shared.writeText(lines.joined(separator: "\n"))
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+FillColumn.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+FillColumn.swift
new file mode 100644
index 0000000000..4859fade6d
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+FillColumn.swift
@@ -0,0 +1,176 @@
+//
+//  DataGridCommands+FillColumn.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+enum FillColumnChoice: Equatable {
+    case value
+    case null
+    case uuid(UUIDVersion)
+}
+
+// A UUID is drawn for each row.
+enum FillColumnContent: Equatable {
+    case value(PluginCellValue, isExpression: Bool = false)
+    case uuid(UUIDVersion, UUIDCellForm)
+}
+
+extension DataGridCommands {
+    // Writable, loaded rows the reader can see; a key column takes no fill, since every row would collide.
+    func canFillColumn(_ column: DataGridColumn) -> Bool {
+        configuration.isEditable
+            && model.rowCount > 0
+            && model.isColumnWritable(column)
+            && !configuration.primaryKeyColumns.contains(column.name)
+    }
+
+    func fillTargetRowIDs() -> [RowID] {
+        guard configuration.isEditable else { return [] }
+        let rows = model.rows
+        return (0..<model.rowCount).compactMap { displayRow in
+            guard let rowID = model.order.rowID(at: displayRow, in: rows), !isRowDeleted(rowID) else { return nil }
+            return rowID
+        }
+    }
+
+    func fillColumnChoices(for column: DataGridColumn) -> [FillColumnChoice] {
+        let rows = model.rows
+        guard rows.columns.indices.contains(column.dataIndex) else { return [.value] }
+        var choices: [FillColumnChoice] = [.value]
+        if rows.columnNullable[column.name] ?? true {
+            choices.append(.null)
+        }
+        if fillUUIDForm(for: column) != nil {
+            choices += [.uuid(.v4), .uuid(.v7)]
+        }
+        return choices
+    }
+
+    // The value is read the way a typed cell is. Nil when the column holds neither the text nor NULL in its place.
+    func fillColumnContent(choice: FillColumnChoice, text: String, column: DataGridColumn) -> FillColumnContent? {
+        switch choice {
+        case .value:
+            return enteredCell(text, column: column).map { FillColumnContent.value($0.value, isExpression: $0.isExpression) }
+        case .null:
+            return .value(.null)
+        case .uuid(let version):
+            return fillUUIDForm(for: column).map { FillColumnContent.uuid(version, $0) }
+        }
+    }
+
+    private func fillUUIDForm(for column: DataGridColumn) -> UUIDCellForm? {
+        setValueContext(for: column, rowIsInserted: false).flatMap { SetValueOptions.uuidForm(for: $0) }
+    }
+
+    // One commit for the whole column; rows that already hold the value are left as they are.
+    func applyFillColumn(_ column: DataGridColumn, content: FillColumnContent) {
+        fill(fillTargetRowIDs(), column: column, content: content)
+    }
+
+    // The retry keeps these rows: a filter changed while values load must not move the fill onto others.
+    private func fill(_ targets: [RowID], column: DataGridColumn, content: FillColumnContent) {
+        guard !targets.isEmpty else { return }
+        guard loader.ensureLoaded(targets, columns: IndexSet(integer: column.dataIndex), in: model, retry: {
+            fill(targets, column: column, content: content)
+        }) else { return }
+        let edits = targets.map { rowID in
+            let staged = Self.fillValue(content)
+            return DataGridCellEdit(rowID: rowID, columnID: column.id, value: .value(staged.value, isExpression: staged.isExpression))
+        }
+        model.commit(edits, actionName: String(localized: "Fill Column"))
+    }
+
+    private static func fillValue(_ content: FillColumnContent) -> StagedCellEntry {
+        switch content {
+        case .value(let value, let isExpression):
+            return (value: value, isExpression: isExpression)
+        case .uuid(let version, let form):
+            return (value: form.value(for: UUIDValueGenerator.shared.make(version)), isExpression: false)
+        }
+    }
+
+    static func fillImpactDescription(rowCount: Int) -> String {
+        if rowCount == 1 {
+            return String(localized: "This sets 1 loaded row. Review and Save to apply.")
+        }
+        return String(
+            format: String(localized: "This sets %lld loaded rows. Review and Save to apply."),
+            Int64(rowCount)
+        )
+    }
+}
+
+// Value, NULL and the UUIDs are radio buttons with one superview and one action, which AppKit groups by itself.
+@MainActor
+final class FillColumnAccessoryView: NSView {
+    private static let width: CGFloat = 260
+    private static let valueRowHeight: CGFloat = 24
+    private static let choiceRowHeight: CGFloat = 22
+
+    private let valueField = NSTextField(frame: .zero)
+    private var radios: [(choice: FillColumnChoice, button: NSButton)] = []
+
+    init(choices: [FillColumnChoice]) {
+        let others = choices.filter { $0 != .value }
+        let height = Self.valueRowHeight + CGFloat(others.count) * Self.choiceRowHeight
+        super.init(frame: NSRect(x: 0, y: 0, width: Self.width, height: height))
+
+        valueField.usesSingleLineMode = true
+        valueField.placeholderString = String(localized: "Value")
+        valueField.setAccessibilityLabel(String(localized: "Value"))
+        addSubview(valueField)
+
+        let valueRowY = height - Self.valueRowHeight
+        guard !others.isEmpty else {
+            valueField.frame = NSRect(x: 0, y: valueRowY, width: Self.width, height: Self.valueRowHeight)
+            return
+        }
+
+        let valueRadio = addRadio(.value, at: valueRowY, rowHeight: Self.valueRowHeight)
+        valueRadio.state = .on
+        let fieldX = valueRadio.frame.maxX + 6
+        valueField.frame = NSRect(x: fieldX, y: valueRowY, width: Self.width - fieldX, height: Self.valueRowHeight)
+        for (index, choice) in others.enumerated() {
+            addRadio(choice, at: valueRowY - CGFloat(index + 1) * Self.choiceRowHeight, rowHeight: Self.choiceRowHeight)
+        }
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    var enteredText: String { valueField.stringValue }
+
+    var choice: FillColumnChoice {
+        radios.first { $0.button.state == .on }?.choice ?? .value
+    }
+
+    var firstResponderView: NSView { valueField }
+
+    @discardableResult
+    private func addRadio(_ choice: FillColumnChoice, at rowY: CGFloat, rowHeight: CGFloat) -> NSButton {
+        let button = NSButton(radioButtonWithTitle: Self.title(for: choice), target: self, action: #selector(choiceChanged))
+        button.sizeToFit()
+        button.frame.origin = NSPoint(x: 0, y: rowY + (rowHeight - button.frame.height) / 2)
+        addSubview(button)
+        radios.append((choice, button))
+        return button
+    }
+
+    private static func title(for choice: FillColumnChoice) -> String {
+        switch choice {
+        case .value: String(localized: "Value")
+        case .null: String(localized: "NULL")
+        case .uuid(.v4): String(localized: "New UUID")
+        case .uuid(.v7): String(localized: "New UUIDv7")
+        }
+    }
+
+    @objc private func choiceChanged() {
+        valueField.isEnabled = choice == .value
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+Paste.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+Paste.swift
new file mode 100644
index 0000000000..36861ef8cf
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+Paste.swift
@@ -0,0 +1,198 @@
+//
+//  DataGridCommands+Paste.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+// The clipboard read as cells: the fields the grid's own copy carries, or the text split into lines and fields.
+// Only the grid's copy can hold a NULL.
+struct DataGridCellPasteBlock: Equatable {
+    // Splitting costs a pass over the whole string and validation asks on every Command-V, so past this the
+    // clipboard is not a cell block and goes to row paste.
+    static let maxLength = 1_000_000
+
+    let lines: [[String?]]
+    let isGridCopy: Bool
+    var expressionFields: [Int: Set<Int>] = [:]
+
+    // The widest line, since an empty line holds one field and may come first.
+    var width: Int { lines.map(\.count).max() ?? 0 }
+
+    var isSingleValue: Bool { lines.count == 1 && lines.first?.count == 1 }
+
+    func isExpression(line: Int, field: Int) -> Bool {
+        expressionFields[line]?.contains(field) == true
+    }
+
+    // Nil when the clipboard holds the grid's own row copy, which row paste reads.
+    @MainActor
+    static func fromClipboard() -> DataGridCellPasteBlock? {
+        let clipboard = ClipboardService.shared
+        guard !clipboard.hasGridRows, let text = clipboard.readText(), !text.isEmpty,
+              (text as NSString).length <= maxLength else { return nil }
+        if let copied = clipboard.readGridCells(), copied.text == text {
+            return DataGridCellPasteBlock(lines: copied.fields, isGridCopy: true, expressionFields: copied.expressionFields ?? [:])
+        }
+        return DataGridCellPasteBlock(lines: pastedLines(text).map { $0.components(separatedBy: "\t") }, isGridCopy: false)
+    }
+
+    // A CRLF copy folds to LF; empty lines at the end are a spreadsheet's trailing breaks, not rows.
+    static func pastedLines(_ text: String) -> [String] {
+        var lines = text.replacingOccurrences(of: "\r\n", with: "\n").components(separatedBy: .newlines)
+        while lines.count > 1, lines.last?.isEmpty == true {
+            lines.removeLast()
+        }
+        return lines
+    }
+
+    // Text from another app has no NULL of its own: a date, number or boolean cannot hold the letters NULL, so there
+    // they paste as NULL; a text column keeps them.
+    static func pastedText(_ field: String, columnType: ColumnType?) -> String? {
+        guard field == "NULL", let columnType, !columnType.hasEmptyValue,
+              columnType.enumValues?.contains(field) != true else { return field }
+        return nil
+    }
+}
+
+extension DataGridCommands {
+    // MARK: - Planning
+
+    // One value over a multi-cell selection fills every cell, as a spreadsheet pastes it.
+    func pasteFillTargets(_ scope: DataGridCommandScope, block: DataGridCellPasteBlock) -> [DataGridCommandCell]? {
+        guard block.isSingleValue else { return nil }
+        let targets = cells(scope)
+        return targets.count > 1 ? targets : nil
+    }
+
+    // Where a block lands, from the focus cell rightwards and down in display order. A block as wide as the result,
+    // line for line, is whole rows and goes to row paste.
+    func pasteAnchor(_ scope: DataGridCommandScope, block: DataGridCellPasteBlock) -> GridCoord? {
+        guard !scope.isRowHeader, let anchor = scope.focus ?? scope.selection.activeCell, !block.lines.isEmpty else {
+            return nil
+        }
+        let dataColumnCount = model.rows.columns.count
+        let rowLines = block.lines.filter { $0 != [""] }
+        if !block.isSingleValue, dataColumnCount > 0, !rowLines.isEmpty,
+           rowLines.allSatisfy({ $0.count == dataColumnCount }) {
+            return nil
+        }
+        guard anchor.row >= 0, anchor.row < model.rowCount,
+              anchor.displayColumn >= 0, anchor.displayColumn < model.columns.count else { return nil }
+        return anchor
+    }
+
+    func canPaste(_ scope: DataGridCommandScope) -> Bool {
+        guard configuration.isEditable else { return false }
+        if offers(.pasteRows), model.actions?.gridCanPasteRows() == true { return true }
+        guard let block = DataGridCellPasteBlock.fromClipboard() else { return false }
+        return pasteFillTargets(scope, block: block) != nil || pasteAnchor(scope, block: block) != nil
+    }
+
+    // Menu and keyboard take this one path: fill the selection, else a block at the focus cell, else row paste.
+    func paste(_ scope: DataGridCommandScope) {
+        guard configuration.isEditable else { return }
+        if let block = DataGridCellPasteBlock.fromClipboard() {
+            if let targets = pasteFillTargets(scope, block: block) {
+                pasteFill(block, into: targets, scope: scope)
+                return
+            }
+            if let anchor = pasteAnchor(scope, block: block) {
+                pasteBlock(block, at: anchor, scope: scope)
+                return
+            }
+        }
+        guard offers(.pasteRows), model.actions?.gridCanPasteRows() == true else { return }
+        model.actions?.gridPasteRows()
+    }
+
+    // MARK: - Writing
+
+    private func pasteFill(_ block: DataGridCellPasteBlock, into targets: [DataGridCommandCell], scope: DataGridCommandScope) {
+        let columns = IndexSet(targets.map(\.column.dataIndex))
+        // The retry keeps these targets and this block: a filter or a new clipboard while values load must not move them.
+        guard loader.ensureLoaded(targets.map(\.rowID), columns: columns, in: model, retry: {
+            pasteFill(block, into: targets, scope: scope)
+        }) else { return }
+        let field = block.lines.first?.first ?? nil
+        let isExpression = block.isExpression(line: 0, field: 0)
+        applyEntry(to: targets, actionName: String(localized: "Paste Cells")) { column in
+            pastedEntry(field, of: block, isExpression: isExpression, column: column)
+        }
+    }
+
+    private func pasteBlock(_ block: DataGridCellPasteBlock, at anchor: GridCoord, scope: DataGridCommandScope) {
+        let maxRow = min(anchor.row + block.lines.count, model.rowCount)
+        let maxColumn = min(anchor.displayColumn + block.width, model.columns.count)
+        guard anchor.row < maxRow, anchor.displayColumn < maxColumn else { return }
+
+        var edits: [DataGridCellEdit] = []
+        var refused = false
+        for (lineIndex, fields) in block.lines.enumerated() {
+            let targetRow = anchor.row + lineIndex
+            guard targetRow < maxRow else { break }
+            guard let rowID = model.rowID(at: targetRow), !isRowDeleted(rowID) else { continue }
+            for (fieldIndex, field) in fields.enumerated() {
+                let position = anchor.displayColumn + fieldIndex
+                guard position < maxColumn else { break }
+                guard let column = model.columns.column(at: position) else { continue }
+                guard let entry = pastedEntry(
+                    field,
+                    of: block,
+                    isExpression: block.isExpression(line: lineIndex, field: fieldIndex),
+                    column: column
+                ) else {
+                    refused = true
+                    continue
+                }
+                edits.append(DataGridCellEdit(
+                    rowID: rowID,
+                    columnID: column.id,
+                    value: .value(entry.value, isExpression: entry.isExpression)
+                ))
+            }
+        }
+        commitPasted(edits, refused: refused)
+    }
+
+    // Targets are fixed by identity before any value loads, so the retry writes the cells the paste first named.
+    private func commitPasted(_ edits: [DataGridCellEdit], refused: Bool) {
+        var rowIDs: [RowID] = []
+        var seen = Set<RowID>()
+        for edit in edits where seen.insert(edit.rowID).inserted {
+            rowIDs.append(edit.rowID)
+        }
+        let columns = IndexSet(edits.compactMap { model.columns.column(id: $0.columnID)?.dataIndex })
+        guard loader.ensureLoaded(rowIDs, columns: columns, in: model, retry: {
+            commitPasted(edits, refused: refused)
+        }) else { return }
+        if !edits.isEmpty {
+            model.commit(edits, actionName: String(localized: "Paste Cells"))
+        }
+        if refused {
+            NSSound.beep()
+        }
+    }
+
+    // The grid's copy says which fields were SQL; any other field is text however it reads. Text from another app is
+    // read the way a typed cell is.
+    func pastedEntry(
+        _ field: String?,
+        of block: DataGridCellPasteBlock,
+        isExpression: Bool,
+        column: DataGridColumn
+    ) -> StagedCellEntry? {
+        let rows = model.rows
+        guard block.isGridCopy else {
+            let text = field.flatMap {
+                DataGridCellPasteBlock.pastedText($0, columnType: rows.editingColumnType(at: column.dataIndex))
+            }
+            return enteredCell(text, column: column)
+        }
+        if isExpression, let field {
+            return (value: .text(field), isExpression: true)
+        }
+        return rows.enteredValue(field, forColumn: column.dataIndex).map { (value: $0, isExpression: false) }
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+SetValue.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+SetValue.swift
new file mode 100644
index 0000000000..cc2d571948
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands+SetValue.swift
@@ -0,0 +1,240 @@
+//
+//  DataGridCommands+SetValue.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+extension DataGridCommands {
+    // Any cell's commands, so a selection over a date and a UUID column offers both kinds, in menu order.
+    func setValueCommands(for cells: [DataGridCommandCell]) -> [SetValueCommand] {
+        var resolver = DataGridSetValueResolver(commands: self)
+        var seen: Set<SetValueCommand> = []
+        var offered: [SetValueCommand] = []
+        for cell in cells {
+            for command in resolver.commands(for: cell) ?? [] where seen.insert(command).inserted {
+                offered.append(command)
+            }
+        }
+        return offered.enumerated()
+            .sorted { (Self.menuRank($0.element), $0.offset) < (Self.menuRank($1.element), $1.offset) }
+            .map { $0.element }
+    }
+
+    func isSetValueOffered(_ command: SetValueCommand, for cells: [DataGridCommandCell]) -> Bool {
+        var resolver = DataGridSetValueResolver(commands: self)
+        return cells.contains { resolver.commands(for: $0)?.contains(command) == true }
+    }
+
+    // A cell that does not take the command, such as NULL on a NOT NULL column or a deleted row, is skipped.
+    func applySetValue(_ command: SetValueCommand, to cells: [DataGridCommandCell]) {
+        guard !cells.isEmpty else { return }
+        let columns = IndexSet(cells.map(\.column.dataIndex))
+        guard loader.ensureLoaded(cells.map(\.rowID), columns: columns, in: model, retry: {
+            applySetValue(command, to: cells)
+        }) else { return }
+        var resolver = DataGridSetValueResolver(commands: self)
+        var edits: [DataGridCellEdit] = []
+        for cell in cells {
+            guard let context = resolver.context(for: cell),
+                  resolver.commands(for: cell)?.contains(command) == true,
+                  let staged = Self.stagedValue(for: command, context: context) else { continue }
+            edits.append(DataGridCellEdit(
+                rowID: cell.rowID,
+                columnID: cell.column.id,
+                value: .value(staged.value, isExpression: staged.isExpression)
+            ))
+        }
+        guard !edits.isEmpty else { return }
+        model.commit(edits, actionName: Self.undoActionName(for: command))
+    }
+
+    func setValueContext(for column: DataGridColumn, rowIsInserted: Bool) -> SetValueContext? {
+        let rows = model.rows
+        let dataIndex = column.dataIndex
+        guard rows.columns.indices.contains(dataIndex) else { return nil }
+        let name = rows.columns[dataIndex]
+        let format = model.displayFormat(for: column)
+        return SetValueContext(
+            columnType: rows.editingColumnType(at: dataIndex),
+            isNullable: rows.columnNullable[name] ?? true,
+            serverAssignsValue: rows.serverAssignsValue(forColumn: name),
+            isForeignKey: rows.columnForeignKeys[name] != nil,
+            isWritable: model.isColumnWritable(column),
+            displayFormat: format,
+            sampleText: format == .uuid ? Self.sampleText(ofColumn: dataIndex, in: rows) : nil,
+            declaredType: rows.declaredType(at: dataIndex),
+            databaseType: configuration.traits.databaseType ?? Self.unknownDatabaseType,
+            rowIsInserted: rowIsInserted,
+            writer: writerSupport
+        )
+    }
+
+    // A grid with no engine named gets nothing the vocabulary keys by engine.
+    private static let unknownDatabaseType = DatabaseType(rawValue: "")
+
+    // A MySQL CHAR(32) result has no length, so its values are the one sign it takes the compact UUID form.
+    private static func sampleText(ofColumn dataIndex: Int, in rows: TableRows) -> String? {
+        for row in rows.rows where dataIndex < row.values.count {
+            guard let text = row.values[dataIndex].asText,
+                  !text.isEmpty, text != PluginCellValue.defaultMarkerText else { continue }
+            return text
+        }
+        return nil
+    }
+
+    static func stagedValue(for command: SetValueCommand, context: SetValueContext) -> StagedCellEntry? {
+        switch command {
+        case .empty:
+            return (value: .text(""), isExpression: false)
+        case .null:
+            return (value: .null, isExpression: false)
+        case .defaultValue:
+            return (value: .text(PluginCellValue.defaultMarkerText), isExpression: false)
+        case .expression(let expression):
+            return (value: .text(expression.sql), isExpression: true)
+        case .uuid(let version):
+            guard let form = SetValueOptions.uuidForm(for: context) else { return nil }
+            return (value: form.value(for: UUIDValueGenerator.shared.make(version)), isExpression: false)
+        }
+    }
+
+    static func undoActionName(for command: SetValueCommand) -> String {
+        guard case .uuid = command else { return String(localized: "Set Value") }
+        return SetValueOptions.title(for: command)
+    }
+
+    // Placeholders, then the engine's functions, then UUIDs.
+    static func menuGroup(_ command: SetValueCommand) -> Int {
+        switch command {
+        case .empty, .null, .defaultValue: 0
+        case .expression: 1
+        case .uuid: 2
+        }
+    }
+
+    private static func menuRank(_ command: SetValueCommand) -> Int {
+        switch command {
+        case .empty: 0
+        case .null: 1
+        case .defaultValue: 2
+        case .expression: 3
+        case .uuid(.v4): 4
+        case .uuid(.v7): 5
+        }
+    }
+
+    // MARK: - Set Cells to Value
+
+    func isSetCellsToValueOffered(for cells: [DataGridCommandCell]) -> Bool {
+        cells.contains { typingCanEdit($0) }
+    }
+
+    func applyEnteredText(_ text: String, to cells: [DataGridCommandCell]) {
+        applyEntry(to: cells, actionName: String(localized: "Set Cells to Value")) { column in
+            enteredCell(text, column: column)
+        }
+    }
+
+    static func setCellsToValueImpact(cells: Int, targets: Int) -> String {
+        if cells < targets {
+            return String(
+                format: String(localized: "This sets %1$lld of %2$lld cells. The others cannot be edited."),
+                Int64(cells),
+                Int64(targets)
+            )
+        }
+        if cells == 1 {
+            return String(localized: "This sets 1 cell.")
+        }
+        return String(format: String(localized: "This sets %lld cells."), Int64(cells))
+    }
+
+    // MARK: - Remove Field
+
+    // Only an engine that tells a missing field from NULL, on a cell that still has a field to remove.
+    func canRemoveField(_ cell: DataGridCommandCell) -> Bool {
+        guard configuration.traits.supportsFieldRemoval, model.isColumnWritable(cell.column), !isRowDeleted(cell.rowID),
+              let row = storedRow(cell.rowID) else { return false }
+        return cell.column.dataIndex < row.values.count && !row.isAbsent(cell.column.dataIndex)
+    }
+
+    func removeField(_ cell: DataGridCommandCell) {
+        guard canRemoveField(cell) else { return }
+        model.commit(
+            [DataGridCellEdit(rowID: cell.rowID, columnID: cell.column.id, value: .removeField)],
+            actionName: String(localized: "Remove Field")
+        )
+    }
+}
+
+// The records a Set Cells to Value sheet was opened over. A load that lands while the sheet is up can move or replace
+// them, so the write finds the same records holding the same values, or is dropped.
+@MainActor
+struct DataGridCellRecords {
+    private let cells: [(rowID: RowID, columnID: DataGridColumnID)]
+    private let rows: [RowID: Row]
+
+    init(_ cells: [DataGridCommandCell], in model: DataGridModel) {
+        let tableRows = model.rows
+        var rows: [RowID: Row] = [:]
+        for cell in cells {
+            rows[cell.rowID] = tableRows.row(withID: cell.rowID)
+        }
+        self.cells = cells.map { (rowID: $0.rowID, columnID: $0.column.id) }
+        self.rows = rows
+    }
+
+    func current(in model: DataGridModel) -> [DataGridCommandCell]? {
+        let tableRows = model.rows
+        var resolved: [DataGridCommandCell] = []
+        resolved.reserveCapacity(cells.count)
+        for cell in cells {
+            guard let row = tableRows.row(withID: cell.rowID), row == rows[cell.rowID],
+                  let displayRow = model.displayIndex(of: cell.rowID),
+                  let column = model.columns.column(id: cell.columnID) else { return nil }
+            resolved.append(DataGridCommandCell(rowID: cell.rowID, row: displayRow, column: column))
+        }
+        return resolved
+    }
+}
+
+// A context depends only on the column and whether the row is new, so a tall selection resolves a few, not one per cell.
+@MainActor
+struct DataGridSetValueResolver {
+    private struct Key: Hashable {
+        let columnID: DataGridColumnID
+        let rowIsInserted: Bool
+    }
+
+    private let source: DataGridCommands
+    private let insertedRowIDs: Set<RowID>
+    private let deletedRowIDs: Set<RowID>
+    private var resolved: [Key: (context: SetValueContext, commands: [SetValueCommand])?] = [:]
+
+    init(commands: DataGridCommands) {
+        source = commands
+        insertedRowIDs = commands.model.changeState?.insertedRowIDs ?? []
+        deletedRowIDs = commands.model.changeState?.deletedRowIDs ?? []
+    }
+
+    mutating func context(for cell: DataGridCommandCell) -> SetValueContext? {
+        options(for: cell)?.context
+    }
+
+    mutating func commands(for cell: DataGridCommandCell) -> [SetValueCommand]? {
+        options(for: cell)?.commands
+    }
+
+    private mutating func options(for cell: DataGridCommandCell) -> (context: SetValueContext, commands: [SetValueCommand])? {
+        guard !deletedRowIDs.contains(cell.rowID) else { return nil }
+        let key = Key(columnID: cell.column.id, rowIsInserted: insertedRowIDs.contains(cell.rowID))
+        if let cached = resolved[key] { return cached }
+        let options = source
+            .setValueContext(for: cell.column, rowIsInserted: key.rowIsInserted)
+            .map { (context: $0, commands: SetValueOptions.commands(for: $0)) }
+        resolved[key] = .some(options)
+        return options
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridCommands.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands.swift
new file mode 100644
index 0000000000..b0d3cb2177
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridCommands.swift
@@ -0,0 +1,217 @@
+//
+//  DataGridCommands.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+typealias StagedCellEntry = (value: PluginCellValue, isExpression: Bool)
+
+// Copy, paste, Set Value, Fill Column and the row commands, over the model. Every multi-cell edit is one
+// model.commit, so the owner records one undo step named for the command.
+@MainActor
+struct DataGridCommands {
+    let model: DataGridModel
+    let loader: DataGridValueLoader
+
+    init(model: DataGridModel, loader: DataGridValueLoader = DataGridValueLoader()) {
+        self.model = model
+        self.loader = loader
+    }
+
+    var configuration: DataGridConfiguration { model.configuration }
+
+    func offers(_ command: DataGridCommand) -> Bool {
+        configuration.commands.contains(command)
+    }
+
+    // MARK: - Targets
+
+    // Rows the user picked or the row a click selected, as opposed to a range of cells of any width.
+    func isWholeRows(_ selection: GridSelection) -> Bool {
+        !selection.isEmpty && selection.isRows
+    }
+
+    func commandCell(at coord: GridCoord) -> DataGridCommandCell? {
+        guard coord.row >= 0, coord.row < model.rowCount,
+              let rowID = model.rowID(at: coord.row),
+              let column = model.columns.column(at: coord.displayColumn) else { return nil }
+        return DataGridCommandCell(rowID: rowID, row: coord.row, column: column)
+    }
+
+    func rowIDs(_ scope: DataGridCommandScope) -> [RowID] {
+        let rowCount = model.rowCount
+        let rows = scope.selection.affectedRows.filteredIndexSet { $0 >= 0 && $0 < rowCount }
+        return model.order.rowIDs(atDisplayIndexes: rows, in: model.rows)
+    }
+
+    // The cells Set Value, Set Cells to Value and a one-value paste write. Whole rows take the focus column on each.
+    func cells(_ scope: DataGridCommandScope) -> [DataGridCommandCell] {
+        let selection = scope.selection
+        guard !selection.isEmpty, !scope.isRowHeader else { return [] }
+        let rows = model.rows
+        let rowCount = model.rowCount
+        let columns = model.columns
+        if isWholeRows(selection) {
+            guard let focus = scope.focus, let column = columns.column(at: focus.displayColumn) else { return [] }
+            return selection.affectedRows.compactMap { row in
+                guard row < rowCount, let rowID = model.order.rowID(at: row, in: rows) else { return nil }
+                return DataGridCommandCell(rowID: rowID, row: row, column: column)
+            }
+        }
+        var cells: [DataGridCommandCell] = []
+        for row in selection.affectedRows where row >= 0 && row < rowCount {
+            guard let rowID = model.order.rowID(at: row, in: rows) else { continue }
+            for position in selection.columns(in: row) {
+                guard let column = columns.column(at: position) else { continue }
+                cells.append(DataGridCommandCell(rowID: rowID, row: row, column: column))
+            }
+        }
+        return cells
+    }
+
+    func focusCell(_ scope: DataGridCommandScope) -> DataGridCommandCell? {
+        guard let focus = scope.focus,
+              let rowID = model.rowID(at: focus.row),
+              let column = model.columns.column(at: focus.displayColumn) else { return nil }
+        return DataGridCommandCell(rowID: rowID, row: focus.row, column: column)
+    }
+
+    // The scope's columns in display order. Whole rows, the row numbers and one clicked cell take every presented column.
+    func selectedColumns(_ scope: DataGridCommandScope) -> [DataGridColumn] {
+        let selection = scope.selection
+        guard !scope.isRowHeader, !isWholeRows(selection), selection.uniqueCellCount > 1 else { return model.columns.columns }
+        let picked = selection.affectedColumns.compactMap { model.columns.column(at: $0) }
+        return picked.isEmpty ? model.columns.columns : picked
+    }
+
+    func storedRow(_ rowID: RowID) -> Row? {
+        model.rows.row(withID: rowID)
+    }
+
+    func isRowDeleted(_ rowID: RowID) -> Bool {
+        model.changeState?.isRowDeleted(rowID) == true
+    }
+
+    // MARK: - Rows
+
+    func canDelete(_ scope: DataGridCommandScope) -> Bool {
+        offers(.deleteRows) && !scope.selection.isEmpty && !rowIDs(scope).isEmpty
+    }
+
+    func deleteRows(_ scope: DataGridCommandScope) {
+        guard offers(.deleteRows) else { return }
+        let ids = rowIDs(scope)
+        guard !ids.isEmpty else { return }
+        model.actions?.gridDeleteRows(ids)
+    }
+
+    func deletedRowIDs(_ scope: DataGridCommandScope) -> [RowID] {
+        rowIDs(scope).filter { isRowDeleted($0) }
+    }
+
+    // MARK: - Entered text
+
+    // Read the way a typed cell is: a function the engine runs there is SQL, an emptied date, number or boolean is NULL.
+    // Nil when the column holds neither the text nor NULL in its place.
+    func enteredCell(_ text: String?, column: DataGridColumn) -> StagedCellEntry? {
+        let rows = model.rows
+        if let text,
+           let databaseType = configuration.traits.databaseType,
+           let typed = CellEntry.typed(
+               text,
+               columnType: rows.editingColumnType(at: column.dataIndex),
+               databaseType: databaseType,
+               writer: writerSupport
+           ) {
+            return typed
+        }
+        return rows.enteredValue(text, forColumn: column.dataIndex).map { (value: $0, isExpression: false) }
+    }
+
+    var writerSupport: CellWriterSupport {
+        model.changeState?.cellWriterSupport ?? configuration.traits.cellWriterSupport
+    }
+
+    // One commit for every cell. The entry is read once per column; a column that refuses it keeps its cells and beeps.
+    @discardableResult
+    func applyEntry(
+        to cells: [DataGridCommandCell],
+        actionName: String,
+        entry: (DataGridColumn) -> StagedCellEntry?
+    ) -> Bool {
+        guard !cells.isEmpty else { return false }
+        var entries: [DataGridColumnID: StagedCellEntry?] = [:]
+        var edits: [DataGridCellEdit] = []
+        var refused = false
+        for cell in cells where !isRowDeleted(cell.rowID) {
+            let resolved: StagedCellEntry?
+            if let cached = entries[cell.column.id] {
+                resolved = cached
+            } else {
+                resolved = entry(cell.column)
+                entries[cell.column.id] = .some(resolved)
+            }
+            guard let resolved else {
+                refused = true
+                continue
+            }
+            edits.append(DataGridCellEdit(
+                rowID: cell.rowID,
+                columnID: cell.column.id,
+                value: .value(resolved.value, isExpression: resolved.isExpression)
+            ))
+        }
+        if refused {
+            NSSound.beep()
+        }
+        guard !edits.isEmpty else { return false }
+        return model.commit(edits, actionName: actionName)
+    }
+
+    // What typing could edit: a read-only or server-owned column, a deleted row, a value not loaded and a binary value stay out.
+    func typingCanEdit(_ cell: DataGridCommandCell) -> Bool {
+        guard configuration.isEditable, model.isColumnWritable(cell.column), !isRowDeleted(cell.rowID),
+              let row = storedRow(cell.rowID) else { return false }
+        let dataIndex = cell.column.dataIndex
+        guard dataIndex < row.values.count, row.unloadedByteCount(dataIndex) == nil else { return false }
+        if cell.column.type?.isBlobType == true { return false }
+        return row.values[dataIndex].asBytes == nil
+    }
+}
+
+// Loads the values a page left on the server before a command reads them, then runs the command again once.
+@MainActor
+final class DataGridValueLoader {
+    private var isRetrying = false
+
+    func ensureLoaded(
+        _ rowIDs: [RowID],
+        columns: IndexSet?,
+        in model: DataGridModel,
+        retry: @escaping @MainActor () -> Void
+    ) -> Bool {
+        let rows = model.rows
+        let pending = rowIDs.filter { rowID in
+            guard let row = rows.row(withID: rowID) else { return false }
+            return row.unloadedColumns.keys.contains { columns?.contains($0) ?? true }
+        }
+        guard !pending.isEmpty else { return true }
+        // A retry that still finds a value missing would load forever.
+        guard !isRetrying, let actions = model.actions, model.configuration.commands.contains(.loadUnloadedValues) else {
+            NSSound.beep()
+            return false
+        }
+        actions.gridLoadUnloadedValues(rowIDs: pending, columns: columns) { [weak self] loaded in
+            guard loaded else {
+                NSSound.beep()
+                return
+            }
+            self?.isRetrying = true
+            retry()
+            self?.isRetrying = false
+        }
+        return false
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+CommandResponders.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+CommandResponders.swift
new file mode 100644
index 0000000000..18f493be25
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+CommandResponders.swift
@@ -0,0 +1,195 @@
+//
+//  DataGridViewController+CommandResponders.swift
+//  TablePro
+//
+
+import AppKit
+
+// The focused grid answers the Copy Special and Set Value commands itself, so they work in every window (interaction 8).
+extension DataGridViewController: GridCopyCommandResponding {
+    func copyCellValue(_ sender: Any?) {
+        let commands = gridCommands
+        guard let cell = commands.focusCell(commandScope(for: sender)) else { return }
+        commands.copyCellValue(cell)
+    }
+
+    func copyRowsAsCsv(_ sender: Any?) {
+        copyRows(sender, as: .csv)
+    }
+
+    func copyRowsAsCsvWithHeaders(_ sender: Any?) {
+        copyRows(sender, as: .csvWithHeaders)
+    }
+
+    func copyRowsAsMarkdown(_ sender: Any?) {
+        copyRows(sender, as: .markdown)
+    }
+
+    func copyRowsAsInClause(_ sender: Any?) {
+        guard model.configuration.appliesRowCopyFormat else { return }
+        gridCommands.copyRowsAsInClause(commandScope(for: sender))
+    }
+
+    func copyRowsAsInsertStatements(_ sender: Any?) {
+        guard model.configuration.appliesRowCopyFormat else { return }
+        gridCommands.copyRowsAsStatements(commandScope(for: sender), update: false)
+    }
+
+    func copyRowsAsUpdateStatements(_ sender: Any?) {
+        guard model.configuration.appliesRowCopyFormat else { return }
+        gridCommands.copyRowsAsStatements(commandScope(for: sender), update: true)
+    }
+
+    // Structure grids list definitions, so only Copy Rows, which their owner answers, applies to them.
+    private func copyRows(_ sender: Any?, as format: RowCopyFormat) {
+        guard format == .rows || model.configuration.appliesRowCopyFormat else { return }
+        gridCommands.copyRows(commandScope(for: sender), as: format)
+    }
+}
+
+extension DataGridViewController: GridRowCopyCommandResponding {
+    func copySelectedRows(_ sender: Any?) {
+        copyRows(sender, as: .rows)
+    }
+
+    func copyRowsWithHeaders(_ sender: Any?) {
+        copyRows(sender, as: .rowsWithHeaders)
+    }
+
+    func copyRowsAsJson(_ sender: Any?) {
+        copyRows(sender, as: .json)
+    }
+}
+
+extension DataGridViewController: SetValueCommandResponding {
+    func setValueEmpty(_ sender: Any?) {
+        applySetValue(.empty, sender: sender)
+    }
+
+    func setValueNull(_ sender: Any?) {
+        applySetValue(.null, sender: sender)
+    }
+
+    func setValueDefault(_ sender: Any?) {
+        applySetValue(.defaultValue, sender: sender)
+    }
+
+    func generateUUIDv4(_ sender: Any?) {
+        applySetValue(.uuid(.v4), sender: sender)
+    }
+
+    func generateUUIDv7(_ sender: Any?) {
+        applySetValue(.uuid(.v7), sender: sender)
+    }
+
+    // A window with its own command (a whole data file) runs it instead; the sheet otherwise names how many cells it sets.
+    func setCellsToValue(_ sender: Any?) {
+        let commands = gridCommands
+        let targets = commands.cells(commandScope(for: sender))
+        guard !targets.isEmpty, commitCellEditing() else { return }
+        if model.actions?.gridSetCellsToValue(targets.map { (rowID: $0.rowID, column: $0.column) }) == true { return }
+        let cells = targets.filter { commands.typingCanEdit($0) }
+        guard !cells.isEmpty, let window = view.window else { return }
+        let records = DataGridCellRecords(cells, in: model)
+        SetCellsToValuePrompt.present(
+            informative: DataGridCommands.setCellsToValueImpact(cells: cells.count, targets: targets.count),
+            window: window
+        ) { [weak self] text in
+            guard let self, let text else { return }
+            guard let current = records.current(in: self.model) else {
+                NSSound.beep()
+                return
+            }
+            let commands = self.gridCommands
+            commands.applyEnteredText(text, to: current.filter { commands.typingCanEdit($0) })
+        }
+    }
+
+    private func applySetValue(_ command: SetValueCommand, sender: Any?) {
+        let commands = gridCommands
+        let cells = commands.cells(commandScope(for: sender))
+        guard !cells.isEmpty, commitCellEditing() else { return }
+        commands.applySetValue(command, to: cells)
+    }
+
+    static func setValueCommand(for action: Selector) -> SetValueCommand? {
+        switch action {
+        case #selector(SetValueCommandResponding.setValueEmpty(_:)): SetValueCommand.empty
+        case #selector(SetValueCommandResponding.setValueNull(_:)): SetValueCommand.null
+        case #selector(SetValueCommandResponding.setValueDefault(_:)): SetValueCommand.defaultValue
+        case #selector(SetValueCommandResponding.generateUUIDv4(_:)): SetValueCommand.uuid(.v4)
+        case #selector(SetValueCommandResponding.generateUUIDv7(_:)): SetValueCommand.uuid(.v7)
+        default: nil
+        }
+    }
+}
+
+// The focused grid opens its own find bar, so Find reaches a query result, a Structure list or any other grid
+// before the window hands the command to its editor.
+extension DataGridViewController {
+    @objc func performFind(_ sender: Any?) {
+        model.showFind()
+    }
+
+    @objc func performFindAndReplace(_ sender: Any?) {
+        model.showFind(replace: true)
+    }
+
+    @objc func useSelectionForFind(_ sender: Any?) {
+        model.useSelectionForFind()
+    }
+
+    @objc func findNext(_ sender: Any?) {
+        model.findNext()
+    }
+
+    @objc func findPrevious(_ sender: Any?) {
+        model.findPrevious()
+    }
+
+    func validateFindCommand(_ item: NSValidatedUserInterfaceItem) -> Bool? {
+        switch item.action {
+        case #selector(performFind(_:)), #selector(performFindAndReplace(_:)):
+            true
+        case #selector(useSelectionForFind(_:)):
+            model.selection.activeCell != nil
+        case #selector(findNext(_:)), #selector(findPrevious(_:)):
+            model.find.isVisible && model.hasFindTerm
+        default:
+            nil
+        }
+    }
+}
+
+extension DataGridViewController {
+    // A key column takes no fill; the sheet says how many loaded rows it sets.
+    func presentFillColumn(for column: DataGridColumn) {
+        let commands = gridCommands
+        guard commands.canFillColumn(column), let window = view.window, commitCellEditing() else { return }
+        let rowCount = commands.fillTargetRowIDs().count
+        guard rowCount > 0 else { return }
+        let accessory = FillColumnAccessoryView(choices: commands.fillColumnChoices(for: column))
+        let alert = NSAlert()
+        alert.messageText = String(format: String(localized: "Fill column \"%@\""), column.name)
+        alert.informativeText = DataGridCommands.fillImpactDescription(rowCount: rowCount)
+        alert.accessoryView = accessory
+        alert.addButton(withTitle: String(localized: "Fill"))
+        alert.addButton(withTitle: String(localized: "Cancel"))
+        alert.window.initialFirstResponder = accessory.firstResponderView
+        let columnID = column.id
+        alert.beginSheetModal(for: window) { [weak self] response in
+            guard response == .alertFirstButtonReturn, let self,
+                  let current = self.model.columns.column(id: columnID) else { return }
+            let commands = self.gridCommands
+            guard let content = commands.fillColumnContent(
+                choice: accessory.choice,
+                text: accessory.enteredText,
+                column: current
+            ) else {
+                NSSound.beep()
+                return
+            }
+            commands.applyFillColumn(current, content: content)
+        }
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+HeaderMenu.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+HeaderMenu.swift
new file mode 100644
index 0000000000..1b2d3456ff
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+HeaderMenu.swift
@@ -0,0 +1,268 @@
+//
+//  DataGridViewController+HeaderMenu.swift
+//  TablePro
+//
+
+import AppKit
+
+struct DataGridDisplayFormatChoice {
+    let columnID: DataGridColumnID
+    let format: ValueDisplayFormat
+}
+
+extension DataGridViewController {
+    func buildHeaderMenu(for column: DataGridColumn) -> NSMenu? {
+        guard let position = model.columns.displayPosition(of: column.id) else { return nil }
+        let commands = gridCommands
+        let configuration = model.configuration
+        let columnID = column.id
+        var groups: [[NSMenuItem]] = []
+
+        if configuration.supportsColumnSort {
+            var sort = [
+                menuItem(String(localized: "Sort Ascending"), #selector(sortAscendingFromMenu(_:)), columnID),
+                menuItem(String(localized: "Sort Descending"), #selector(sortDescendingFromMenu(_:)), columnID),
+            ]
+            if model.store.sortState.isSorting {
+                sort.append(menuItem(String(localized: "Don't Sort"), #selector(clearSortFromMenu(_:)), nil))
+            }
+            groups.append(sort)
+        }
+
+        var columnItems: [NSMenuItem] = []
+        if model.rowCount > 0 {
+            columnItems.append(menuItem(String(localized: "Select Column"), #selector(selectColumnFromMenu(_:)), columnID))
+        }
+        columnItems.append(menuItem(String(localized: "Copy Column Name"), #selector(copyColumnNameFromMenu(_:)), columnID))
+        if model.rowCount > 0 {
+            columnItems.append(menuItem(String(localized: "Copy Column Values"), #selector(copyColumnValuesFromMenu(_:)), columnID))
+        }
+        if commands.canFillColumn(column) {
+            columnItems.append(menuItem(String(localized: "Fill Column…"), #selector(fillColumnFromMenu(_:)), columnID))
+        }
+        if commands.offers(.filterWithColumn) {
+            columnItems.append(menuItem(String(localized: "Filter with column"), #selector(filterWithColumnFromMenu(_:)), columnID))
+        }
+        if offersValueFilter {
+            let filter = model.store.valueFilter
+            columnItems.append(menuItem(String(localized: "Filter Values…"), #selector(filterValuesFromMenu(_:)), columnID))
+            if filter.isActive(column: column.dataIndex) {
+                columnItems.append(menuItem(String(localized: "Clear Value Filter"), #selector(clearValueFilterFromMenu(_:)), columnID))
+            }
+            if filter.isActive {
+                columnItems.append(menuItem(String(localized: "Clear All Value Filters"), #selector(clearAllValueFiltersFromMenu(_:)), nil))
+            }
+        }
+        if commands.offers(.highlightValues), let highlight = model.actions?.gridHighlightValuesMenuItem(for: column) {
+            columnItems.append(highlight)
+        }
+        if commands.offers(.displayAs), let displayAs = displayAsItem(for: column) {
+            columnItems.append(displayAs)
+        }
+        groups.append(columnItems)
+
+        groups.append([
+            menuItem(String(localized: "Size to Fit"), #selector(sizeColumnToFitFromMenu(_:)), columnID),
+            menuItem(String(localized: "Size All Columns to Fit"), #selector(sizeAllColumnsToFitFromMenu(_:)), nil),
+        ])
+
+        if commands.offers(.hideColumns) {
+            var visibility = [menuItem(String(localized: "Hide Column"), #selector(hideColumnFromMenu(_:)), columnID)]
+            if !model.store.columnLayout.hiddenColumns.isEmpty {
+                visibility.append(menuItem(String(localized: "Show All Columns"), #selector(showAllColumnsFromMenu(_:)), nil))
+            }
+            groups.append(visibility)
+        }
+
+        if commands.offers(.freezeColumns) {
+            groups.append(freezeItems(position: position, columnID: columnID))
+        }
+
+        groups.append(model.actions?.gridColumnMenuItems(for: column) ?? [])
+        return Self.menu(groups: groups)
+    }
+
+    var offersValueFilter: Bool {
+        gridCommands.offers(.valueFilter) && model.configuration.supportsValueFilter
+    }
+
+    private func displayAsItem(for column: DataGridColumn) -> NSMenuItem? {
+        let formats = ValueDisplayFormat.applicableFormats(for: column.type, databaseType: model.configuration.traits.databaseType)
+        guard formats.count > 1 else { return nil }
+        let current = model.displayFormat(for: column) ?? .raw
+        let submenu = NSMenu()
+        for format in formats {
+            let item = menuItem(
+                format.displayName,
+                #selector(setDisplayFormatFromMenu(_:)),
+                DataGridDisplayFormatChoice(columnID: column.id, format: format)
+            )
+            item.state = format == current ? .on : .off
+            submenu.addItem(item)
+        }
+        let item = NSMenuItem(title: String(localized: "Display As"), action: nil, keyEquivalent: "")
+        item.submenu = submenu
+        return item
+    }
+
+    // Refused, with the reason, when the frozen run would leave too little of the grid to scroll.
+    private func freezeItems(position: Int, columnID: DataGridColumnID) -> [NSMenuItem] {
+        var items: [NSMenuItem] = []
+        let frozenCount = model.columns.frozenCount
+        if frozenCount != position + 1 {
+            let fits = canFreezeColumns(throughDisplayPosition: position)
+            let item = menuItem(
+                String(localized: "Freeze Up to This Column"),
+                fits ? #selector(freezeColumnsFromMenu(_:)) : nil,
+                columnID
+            )
+            if !fits {
+                item.toolTip = String(localized: "These columns would leave too little room to scroll the rest.")
+            }
+            items.append(item)
+        }
+        if frozenCount > 0 {
+            items.append(menuItem(String(localized: "Unfreeze Columns"), #selector(unfreezeColumnsFromMenu(_:)), nil))
+        }
+        return items
+    }
+
+    // MARK: - Actions
+
+    static let headerMenuActions: Set<Selector> = [
+        #selector(DataGridViewController.sortAscendingFromMenu(_:)),
+        #selector(DataGridViewController.sortDescendingFromMenu(_:)),
+        #selector(DataGridViewController.clearSortFromMenu(_:)),
+        #selector(DataGridViewController.selectColumnFromMenu(_:)),
+        #selector(DataGridViewController.copyColumnNameFromMenu(_:)),
+        #selector(DataGridViewController.copyColumnValuesFromMenu(_:)),
+        #selector(DataGridViewController.fillColumnFromMenu(_:)),
+        #selector(DataGridViewController.filterWithColumnFromMenu(_:)),
+        #selector(DataGridViewController.filterValuesFromMenu(_:)),
+        #selector(DataGridViewController.clearValueFilterFromMenu(_:)),
+        #selector(DataGridViewController.clearAllValueFiltersFromMenu(_:)),
+        #selector(DataGridViewController.setDisplayFormatFromMenu(_:)),
+        #selector(DataGridViewController.sizeColumnToFitFromMenu(_:)),
+        #selector(DataGridViewController.sizeAllColumnsToFitFromMenu(_:)),
+        #selector(DataGridViewController.hideColumnFromMenu(_:)),
+        #selector(DataGridViewController.showAllColumnsFromMenu(_:)),
+        #selector(DataGridViewController.freezeColumnsFromMenu(_:)),
+        #selector(DataGridViewController.unfreezeColumnsFromMenu(_:)),
+    ]
+
+    // The column the item was built for, if the result still presents it.
+    private func menuColumn(_ sender: Any?) -> DataGridColumn? {
+        guard let id = (sender as? NSMenuItem)?.representedObject as? DataGridColumnID else { return nil }
+        return model.columns.column(id: id)
+    }
+
+    @objc func sortAscendingFromMenu(_ sender: Any?) {
+        sort(menuColumn(sender), direction: .ascending)
+    }
+
+    @objc func sortDescendingFromMenu(_ sender: Any?) {
+        sort(menuColumn(sender), direction: .descending)
+    }
+
+    // Replaces the whole sort, stamped as the user's so the app default never writes over it.
+    private func sort(_ column: DataGridColumn?, direction: SortDirection) {
+        guard let column, model.configuration.supportsColumnSort else { return }
+        model.setSort(SortState(
+            columns: [SortColumn(columnIndex: column.dataIndex, direction: direction, columnName: column.name)],
+            source: .user
+        ))
+    }
+
+    // The user's own empty sort, which keeps the app default from coming back on the next load.
+    @objc func clearSortFromMenu(_ sender: Any?) {
+        model.setSort(SortState(columns: [], source: .user))
+    }
+
+    // Focuses the grid too, so the Copy that usually follows acts on the column.
+    @objc func selectColumnFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender),
+              let position = model.columns.displayPosition(of: column.id),
+              model.rowCount > 0 else { return }
+        model.setSelection(GridSelection.column(position, totalRows: model.rowCount))
+        mirrorSelection()
+        focus()
+    }
+
+    @objc func copyColumnNameFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        ClipboardService.shared.writeText(column.name)
+    }
+
+    @objc func copyColumnValuesFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        gridCommands.copyColumnValues(column)
+    }
+
+    @objc func fillColumnFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        presentFillColumn(for: column)
+    }
+
+    @objc func filterWithColumnFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        model.actions?.gridFilterWithColumn(column)
+    }
+
+    @objc func filterValuesFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        presentValueFilter(for: column)
+    }
+
+    @objc func clearValueFilterFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        applyValueFilter(nil, to: column)
+    }
+
+    @objc func clearAllValueFiltersFromMenu(_ sender: Any?) {
+        clearAllValueFilters()
+    }
+
+    // Only a value filter can renumber rows on a format change, so only then does the owner confirm it.
+    @objc func setDisplayFormatFromMenu(_ sender: Any?) {
+        guard let choice = (sender as? NSMenuItem)?.representedObject as? DataGridDisplayFormatChoice,
+              model.columns.column(id: choice.columnID) != nil else { return }
+        let apply: @MainActor () -> Void = { [weak self] in
+            guard let self, let column = self.model.columns.column(id: choice.columnID) else { return }
+            self.model.setDisplayFormat(choice.format, for: column)
+        }
+        guard model.store.valueFilter.isActive, let actions = model.actions else {
+            apply()
+            return
+        }
+        actions.gridConfirmDisplayOrderChange(then: apply)
+    }
+
+    @objc func sizeColumnToFitFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        sizeColumnToFit(column)
+    }
+
+    @objc func sizeAllColumnsToFitFromMenu(_ sender: Any?) {
+        sizeAllColumnsToFit()
+    }
+
+    @objc func hideColumnFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender) else { return }
+        model.actions?.gridHideColumn(column)
+    }
+
+    @objc func showAllColumnsFromMenu(_ sender: Any?) {
+        model.actions?.gridShowAllColumns()
+    }
+
+    @objc func freezeColumnsFromMenu(_ sender: Any?) {
+        guard let column = menuColumn(sender),
+              let position = model.columns.displayPosition(of: column.id),
+              canFreezeColumns(throughDisplayPosition: position) else { return }
+        model.updateColumnLayout { $0.frozenColumnCount = position + 1 }
+    }
+
+    @objc func unfreezeColumnsFromMenu(_ sender: Any?) {
+        model.updateColumnLayout { $0.frozenColumnCount = 0 }
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+RowDrag.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+RowDrag.swift
new file mode 100644
index 0000000000..e36468b966
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+RowDrag.swift
@@ -0,0 +1,34 @@
+//
+//  DataGridViewController+RowDrag.swift
+//  TablePro
+//
+
+import AppKit
+
+extension DataGridViewController {
+    // Dropped in another app a row is a copy, as tab-separated text and an HTML table; the reorder type rides along
+    // only where a reorder can run.
+    func rowDragPasteboardItem(forRow row: Int) -> NSPasteboardItem? {
+        guard let rowModel = model.row(at: row) else { return nil }
+        let rows = model.rows
+        let projection = gridCommands.visibleProjection
+        let formatted = DataGridCommands.formatRowValues(
+            projection.values(Array(rowModel.values)),
+            columnTypes: projection.columnTypes(rows.columnTypes)
+        )
+        let item = NSPasteboardItem()
+        if model.configuration.rowReorder.isEnabled {
+            item.setString(String(row), forType: Self.rowDragType)
+        }
+        item.setString(formatted.joined(separator: "\t"), forType: .string)
+        item.setString(HtmlTableEncoder.encode(rows: [formatted], headers: projection.columns(rows.columns)), forType: .html)
+        return item
+    }
+
+    // A press on the number of a selected row lifts the rows; a press anywhere else selects. Structure reorders from any row.
+    func canDragRows(fromRowNumberAt row: Int) -> Bool {
+        if model.configuration.rowReorder.isEnabled { return true }
+        let selection = model.selection
+        return gridCommands.isWholeRows(selection) && selection.affectedRows.contains(row)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+RowMenu.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+RowMenu.swift
new file mode 100644
index 0000000000..5b754272d6
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+RowMenu.swift
@@ -0,0 +1,320 @@
+//
+//  DataGridViewController+RowMenu.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+struct DataGridSetValueChoice {
+    let context: DataGridMenuContext
+    let command: SetValueCommand
+}
+
+extension DataGridViewController {
+    // Unavailable items are left out; Copy and Paste stay, dimmed when they do not apply (HIG context menus).
+    func buildRowMenu(row: Int, displayColumn: Int?) -> NSMenu? {
+        guard row >= 0, row < model.rowCount, let rowID = model.rowID(at: row) else { return nil }
+        let commands = gridCommands
+        let scope = DataGridCommandScope.contextMenu(
+            selection: model.selection,
+            row: row,
+            displayColumn: displayColumn,
+            columnCount: model.columns.count
+        )
+        let context = DataGridMenuContext(scope, model: model)
+
+        if commands.isRowDeleted(rowID), commands.offers(.undoDelete) {
+            return Self.menu(groups: [[menuItem(String(localized: "Undo Delete"), #selector(undoDeleteFromMenu(_:)), context)]])
+        }
+
+        let cell = displayColumn == nil ? nil : commands.focusCell(scope)
+        var groups: [[NSMenuItem]] = []
+        groups.append(copyItems(scope: scope, context: context, cell: cell))
+        groups.append(resultItems(context: context, cell: cell))
+        if let cell {
+            groups.append(foreignKeyItems(cell: cell, context: context))
+            groups.append(valueItems(scope: scope, context: context, cell: cell))
+        }
+        groups.append(exportItems(context: context))
+        groups.append(model.actions?.gridRowMenuItems(for: commands.rowIDs(scope), clickedRow: rowID) ?? [])
+        groups.append(rowItems(context: context))
+        return Self.menu(groups: groups)
+    }
+
+    static func menu(groups: [[NSMenuItem]]) -> NSMenu? {
+        let filled = groups.filter { !$0.isEmpty }
+        guard !filled.isEmpty else { return nil }
+        let menu = NSMenu()
+        for (index, group) in filled.enumerated() {
+            if index > 0 {
+                menu.addItem(.separator())
+            }
+            group.forEach(menu.addItem)
+        }
+        return menu
+    }
+
+    func menuItem(_ title: String, _ action: Selector?, _ represented: Any?) -> NSMenuItem {
+        let item = NSMenuItem(title: title, action: action, keyEquivalent: "")
+        item.target = self
+        item.representedObject = represented
+        return item
+    }
+
+    // MARK: - Groups
+
+    private func copyItems(scope: DataGridCommandScope, context: DataGridMenuContext, cell: DataGridCommandCell?) -> [NSMenuItem] {
+        var items = [menuItem(String(localized: "Copy"), #selector(copy(_:)), context)]
+        if cell != nil {
+            items.append(menuItem(String(localized: "Copy Cell Value"), #selector(GridCopyCommandResponding.copyCellValue(_:)), context))
+        }
+        if model.configuration.appliesRowCopyFormat {
+            items.append(copyAsItem(scope: scope, context: context, includesInClause: cell != nil))
+        }
+        if context.isCurrentSelection, let numbers = selectionSummaryTracker.currentSummary?.numbers {
+            for figure in [SelectionSummaryFigures.Figure.sum, .average] {
+                guard let text = SelectionSummaryFigures.copyText(figure, of: numbers) else { continue }
+                items.append(menuItem(figure.copyTitle, #selector(copySummaryFigureFromMenu(_:)), text))
+            }
+        }
+        if model.configuration.isEditable {
+            items.append(menuItem(String(localized: "Paste"), #selector(paste(_:)), context))
+        }
+        return items
+    }
+
+    private func copyAsItem(scope: DataGridCommandScope, context: DataGridMenuContext, includesInClause: Bool) -> NSMenuItem {
+        let commands = gridCommands
+        let submenu = NSMenu()
+        let formats: [(String, Selector)] = [
+            (String(localized: "Rows"), #selector(GridRowCopyCommandResponding.copySelectedRows(_:))),
+            (String(localized: "With Headers"), #selector(GridRowCopyCommandResponding.copyRowsWithHeaders(_:))),
+            (String(localized: "JSON"), #selector(GridRowCopyCommandResponding.copyRowsAsJson(_:))),
+            (String(localized: "CSV"), #selector(GridCopyCommandResponding.copyRowsAsCsv(_:))),
+            (String(localized: "CSV with Headers"), #selector(GridCopyCommandResponding.copyRowsAsCsvWithHeaders(_:))),
+            (String(localized: "Markdown"), #selector(GridCopyCommandResponding.copyRowsAsMarkdown(_:))),
+        ]
+        for (title, action) in formats {
+            submenu.addItem(menuItem(title, action, context))
+        }
+        if includesInClause, commands.inClauseColumn(scope) != nil {
+            submenu.addItem(menuItem(String(localized: "IN Clause"), #selector(GridCopyCommandResponding.copyRowsAsInClause(_:)), context))
+        }
+        if commands.canCopyAsInsert(scope) {
+            submenu.addItem(.separator())
+            submenu.addItem(menuItem(
+                String(localized: "INSERT Statement(s)"),
+                #selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:)),
+                context
+            ))
+            if commands.canCopyAsUpdate(scope) {
+                submenu.addItem(menuItem(
+                    String(localized: "UPDATE Statement(s)"),
+                    #selector(GridCopyCommandResponding.copyRowsAsUpdateStatements(_:)),
+                    context
+                ))
+            }
+        }
+        let item = NSMenuItem(title: String(localized: "Copy as"), action: nil, keyEquivalent: "")
+        item.submenu = submenu
+        return item
+    }
+
+    private func resultItems(context: DataGridMenuContext, cell: DataGridCommandCell?) -> [NSMenuItem] {
+        var items: [NSMenuItem] = []
+        if gridCommands.offers(.showRowsAsJSON) {
+            items.append(menuItem(String(localized: "Show Row as JSON"), #selector(showRowsAsJSONFromMenu(_:)), context))
+        }
+        if let cell {
+            items += model.actions?.gridCellMenuItems(for: cell.rowID, column: cell.column) ?? []
+        }
+        return items
+    }
+
+    // Choosing a value is offered on an empty cell too, where it is needed most; previewing and following need a value.
+    private func foreignKeyItems(cell: DataGridCommandCell, context: DataGridMenuContext) -> [NSMenuItem] {
+        let commands = gridCommands
+        let rows = model.rows
+        guard let info = rows.columnForeignKeys[cell.column.name], let row = rows.row(withID: cell.rowID),
+              cell.column.dataIndex < row.values.count else { return [] }
+        let hasValue = row.values[cell.column.dataIndex].asText?.isEmpty == false
+        let canChoose = commands.typingCanEdit(cell)
+            && !ForeignKeyConstraintSpan.isMultiColumn(info, among: rows.columnForeignKeys)
+        var items: [NSMenuItem] = []
+        if canChoose {
+            items.append(menuItem(
+                String(format: String(localized: "Choose %@ Row…"), info.referencedTable),
+                #selector(chooseForeignKeyRowFromMenu(_:)),
+                context
+            ))
+        }
+        guard hasValue, commands.offers(.navigateForeignKey) else { return items }
+        items.append(menuItem(String(localized: "Preview Referenced Row"), #selector(previewForeignKeyFromMenu(_:)), context))
+        items.append(menuItem(
+            String(format: String(localized: "Open %@"), info.referencedTable),
+            #selector(openForeignKeyFromMenu(_:)),
+            context
+        ))
+        items.append(menuItem(
+            String(format: String(localized: "Open %@ in New Tab"), info.referencedTable),
+            #selector(openForeignKeyInNewTabFromMenu(_:)),
+            context
+        ))
+        return items
+    }
+
+    private func valueItems(scope: DataGridCommandScope, context: DataGridMenuContext, cell: DataGridCommandCell) -> [NSMenuItem] {
+        guard model.configuration.isEditable else { return [] }
+        let commands = gridCommands
+        let targets = commands.cells(scope)
+        let submenu = NSMenu()
+        var lastGroup: Int?
+        for command in commands.setValueCommands(for: targets) {
+            let group = DataGridCommands.menuGroup(command)
+            if let lastGroup, lastGroup != group {
+                submenu.addItem(.separator())
+            }
+            lastGroup = group
+            submenu.addItem(menuItem(
+                SetValueOptions.title(for: command),
+                #selector(applySetValueFromMenu(_:)),
+                DataGridSetValueChoice(context: context, command: command)
+            ))
+        }
+        if commands.isSetCellsToValueOffered(for: targets) {
+            if !submenu.items.isEmpty {
+                submenu.addItem(.separator())
+            }
+            submenu.addItem(menuItem(
+                String(localized: "Set Cells to Value…"),
+                #selector(SetValueCommandResponding.setCellsToValue(_:)),
+                context
+            ))
+        }
+        var items: [NSMenuItem] = []
+        if !submenu.items.isEmpty {
+            let setValue = NSMenuItem(title: String(localized: "Set Value"), action: nil, keyEquivalent: "")
+            setValue.submenu = submenu
+            items.append(setValue)
+        }
+        if commands.canRemoveField(cell) {
+            items.append(menuItem(String(localized: "Remove Field"), #selector(removeFieldFromMenu(_:)), context))
+        }
+        return items
+    }
+
+    private func exportItems(context: DataGridMenuContext) -> [NSMenuItem] {
+        var items: [NSMenuItem] = []
+        if gridCommands.offers(.exportResults) {
+            items.append(menuItem(String(localized: "Export Results…"), #selector(exportResultsFromMenu(_:)), context))
+        }
+        if gridCommands.offers(.clearResults) {
+            items.append(menuItem(String(localized: "Clear Results"), #selector(clearResultsFromMenu(_:)), context))
+        }
+        return items
+    }
+
+    private func rowItems(context: DataGridMenuContext) -> [NSMenuItem] {
+        var items: [NSMenuItem] = []
+        if gridCommands.offers(.duplicateRows) {
+            items.append(menuItem(String(localized: "Duplicate"), #selector(duplicateRowsFromMenu(_:)), context))
+        }
+        if gridCommands.offers(.deleteRows) {
+            items.append(menuItem(String(localized: "Delete"), #selector(delete(_:)), context))
+        }
+        return items
+    }
+
+    // MARK: - Actions
+
+    private static let rowMenuActions: Set<Selector> = [
+        #selector(DataGridViewController.undoDeleteFromMenu(_:)),
+        #selector(DataGridViewController.showRowsAsJSONFromMenu(_:)),
+        #selector(DataGridViewController.chooseForeignKeyRowFromMenu(_:)),
+        #selector(DataGridViewController.previewForeignKeyFromMenu(_:)),
+        #selector(DataGridViewController.openForeignKeyFromMenu(_:)),
+        #selector(DataGridViewController.openForeignKeyInNewTabFromMenu(_:)),
+        #selector(DataGridViewController.applySetValueFromMenu(_:)),
+        #selector(DataGridViewController.removeFieldFromMenu(_:)),
+        #selector(DataGridViewController.exportResultsFromMenu(_:)),
+        #selector(DataGridViewController.clearResultsFromMenu(_:)),
+        #selector(DataGridViewController.duplicateRowsFromMenu(_:)),
+        #selector(DataGridViewController.copySummaryFigureFromMenu(_:)),
+    ]
+
+    static let contextMenuActions = rowMenuActions.union(headerMenuActions)
+
+    @objc func undoDeleteFromMenu(_ sender: Any?) {
+        let ids = gridCommands.deletedRowIDs(commandScope(for: sender))
+        guard !ids.isEmpty else { return }
+        model.actions?.gridUndoDelete(ids)
+    }
+
+    @objc func showRowsAsJSONFromMenu(_ sender: Any?) {
+        model.actions?.gridShowRowsAsJSON(gridCommands.rowIDs(commandScope(for: sender)))
+    }
+
+    @objc func duplicateRowsFromMenu(_ sender: Any?) {
+        let ids = gridCommands.rowIDs(commandScope(for: sender))
+        guard !ids.isEmpty, commitCellEditing() else { return }
+        model.actions?.gridDuplicateRows(ids)
+    }
+
+    @objc func exportResultsFromMenu(_ sender: Any?) {
+        model.actions?.gridExportResults()
+    }
+
+    @objc func clearResultsFromMenu(_ sender: Any?) {
+        model.actions?.gridClearResults()
+    }
+
+    @objc func copySummaryFigureFromMenu(_ sender: Any?) {
+        guard let text = (sender as? NSMenuItem)?.representedObject as? String else { return }
+        ClipboardService.shared.writeText(text)
+    }
+
+    @objc func applySetValueFromMenu(_ sender: Any?) {
+        guard let choice = (sender as? NSMenuItem)?.representedObject as? DataGridSetValueChoice,
+              commitCellEditing() else { return }
+        let commands = gridCommands
+        commands.applySetValue(choice.command, to: commands.cells(choice.context.scope(in: model)))
+    }
+
+    @objc func removeFieldFromMenu(_ sender: Any?) {
+        let commands = gridCommands
+        guard let cell = commands.focusCell(commandScope(for: sender)), commitCellEditing() else { return }
+        commands.removeField(cell)
+    }
+
+    @objc func chooseForeignKeyRowFromMenu(_ sender: Any?) {
+        guard let focus = commandScope(for: sender).focus else { return }
+        chooseForeignKeyRow(at: focus)
+    }
+
+    // The preview follows the active cell, so the clicked cell becomes it first.
+    @objc func previewForeignKeyFromMenu(_ sender: Any?) {
+        guard let focus = commandScope(for: sender).focus else { return }
+        if model.selection.activeCell != focus || model.selection.hasMultipleCells {
+            model.selectCell(focus)
+            mirrorSelection()
+        }
+        toggleForeignKeyPreview()
+    }
+
+    @objc func openForeignKeyFromMenu(_ sender: Any?) {
+        openForeignKey(from: sender, intent: .follow)
+    }
+
+    @objc func openForeignKeyInNewTabFromMenu(_ sender: Any?) {
+        openForeignKey(from: sender, intent: .newTab)
+    }
+
+    private func openForeignKey(from sender: Any?, intent: ReferenceOpenIntent) {
+        guard let cell = gridCommands.focusCell(commandScope(for: sender)) else { return }
+        let rows = model.rows
+        guard let info = rows.columnForeignKeys[cell.column.name],
+              let value = rows.row(withID: cell.rowID)?[cell.column.dataIndex].asText, !value.isEmpty else { return }
+        model.actions?.gridNavigateForeignKey(value: value, info: info, intent: intent)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+ValueFilter.swift b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+ValueFilter.swift
new file mode 100644
index 0000000000..b4124734ad
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Commands/DataGridViewController+ValueFilter.swift
@@ -0,0 +1,117 @@
+//
+//  DataGridViewController+ValueFilter.swift
+//  TablePro
+//
+
+import AppKit
+import SwiftUI
+import TableProPluginKit
+
+extension DataGridCommands {
+    // Every loaded value as the cell shows it, which is what a value filter stores and matches; NULL first.
+    func distinctValues(for column: DataGridColumn) -> [ColumnDistinctValue] {
+        let rows = model.rows
+        let dataIndex = column.dataIndex
+        guard dataIndex >= 0, dataIndex < rows.columns.count else { return [] }
+        let format = model.displayFormat(for: column)
+        let databaseType = configuration.traits.databaseType
+        var counts: [String: Int] = [:]
+        var order: [String] = []
+        var nullCount = 0
+        for row in rows.rows {
+            guard dataIndex < row.values.count else { continue }
+            let raw = row.values[dataIndex]
+            if case .null = raw {
+                nullCount += 1
+                continue
+            }
+            let display = GridDisplayOrderResolver.displayValue(
+                raw,
+                columnType: column.type,
+                displayFormat: format,
+                databaseType: databaseType
+            )
+            if counts[display] == nil {
+                order.append(display)
+            }
+            counts[display, default: 0] += 1
+        }
+        var values = order
+            .sorted { $0.localizedStandardCompare($1) == .orderedAscending }
+            .map { ColumnDistinctValue(display: $0, isNull: false, count: counts[$0] ?? 0) }
+        if nullCount > 0 {
+            values.insert(ColumnDistinctValue(display: "", isNull: true, count: nullCount), at: 0)
+        }
+        return values
+    }
+}
+
+extension DataGridViewController {
+    // Opened from the header menu, and from an active filter's funnel; values still on the server load first.
+    func presentValueFilter(for column: DataGridColumn) {
+        guard offersValueFilter else { return }
+        let rows = model.rows
+        let dataIndex = column.dataIndex
+        let unloaded = rows.rows.filter { $0.unloadedByteCount(dataIndex) != nil }.map(\.id)
+        let columnID = column.id
+        guard menuState.loader.ensureLoaded(unloaded, columns: IndexSet(integer: dataIndex), in: model, retry: { [weak self] in
+            guard let self, let current = self.model.columns.column(id: columnID) else { return }
+            self.presentValueFilter(for: current)
+        }) else { return }
+        guard let anchor = model.anchor(for: column) else { return }
+
+        let values = gridCommands.distinctValues(for: column)
+        let initialFilter = model.store.valueFilter.filter(forColumn: dataIndex)
+        dismissValueFilterPopover()
+        menuState.valueFilterPopover = PopoverPresenter.show(
+            relativeTo: anchor.rect,
+            of: anchor.view,
+            preferredEdge: .maxY
+        ) { [weak self] dismiss in
+            ColumnValueFilterPopover(
+                columnName: column.name,
+                values: values,
+                loadedRowCount: rows.count,
+                initialFilter: initialFilter,
+                // A change closes the popover once applied, in followRowChangesWithPopovers; declining the alert keeps the picks.
+                onApply: { filter in
+                    guard let self, let current = self.model.columns.column(id: columnID) else {
+                        dismiss()
+                        return
+                    }
+                    if !self.applyValueFilter(filter, to: current) {
+                        dismiss()
+                    }
+                },
+                onCancel: dismiss
+            )
+        }
+    }
+
+    func dismissValueFilterPopover() {
+        guard let popover = menuState.valueFilterPopover else { return }
+        menuState.valueFilterPopover = nil
+        popover.close()
+    }
+
+    // The model asks the owner to confirm before a change that would drop pending edits; no change asks nothing.
+    @discardableResult
+    func applyValueFilter(_ filter: ColumnValueFilter?, to column: DataGridColumn) -> Bool {
+        var state = model.store.valueFilter
+        if let filter {
+            state.set(filter, columnName: column.name, forColumn: column.dataIndex)
+        } else {
+            state.clear(column: column.dataIndex)
+        }
+        guard state != model.store.valueFilter else { return false }
+        model.setValueFilter(state)
+        return true
+    }
+
+    func clearAllValueFilters() {
+        var state = model.store.valueFilter
+        guard state.isActive else { return }
+        state.clearAll()
+        model.setValueFilter(state)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridAccessibilityCellView.swift b/apple/TablePro/Views/DataGrid/DataGridAccessibilityCellView.swift
new file mode 100644
index 0000000000..71e665d3b0
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridAccessibilityCellView.swift
@@ -0,0 +1,242 @@
+//
+//  DataGridAccessibilityCellView.swift
+//  TablePro
+//
+
+import AppKit
+
+// The first question an assistive client asks is the only sign one is attached: NSWorkspace reports VoiceOver alone.
+// One-way and process-wide, since nothing reports a client detaching either.
+@MainActor
+internal enum DataGridAccessibility {
+    internal static let didActivateNotification = Notification.Name("com.TablePro.DataGridAccessibilityDidActivate")
+
+    // Settable so a test can drive both shapes.
+    internal static var isActive = false
+
+    internal static func markActive() {
+        guard !isActive else { return }
+        isActive = true
+        NotificationCenter.default.post(name: didActivateNotification, object: nil)
+    }
+}
+
+// NSTableView builds its AXCell tree from cell views only (probe P6), so while a client is attached each on-screen
+// cell of the main table mounts one of these. It draws nothing and takes no clicks.
+@MainActor
+final class DataGridAccessibilityCellView: NSTableCellView {
+    static let reuseIdentifier = NSUserInterfaceItemIdentifier("data-grid-cell")
+
+    private weak var controller: DataGridViewController?
+    private weak var table: NSTableView?
+    private var slot: DataGridPane.Slot = .rowNumber
+    private var seededRow = 0
+
+    func configure(controller: DataGridViewController, table: NSTableView, row: Int, slot: DataGridPane.Slot) {
+        self.controller = controller
+        self.table = table
+        self.slot = slot
+        seededRow = row
+        identifier = Self.reuseIdentifier
+        setAccessibilityIdentifier(Self.reuseIdentifier.rawValue)
+    }
+
+    // Asked of the table rather than remembered: an insert or remove moves a mounted view without asking again.
+    private var row: Int {
+        guard let table else { return seededRow }
+        let resolved = table.row(for: self)
+        return resolved >= 0 ? resolved : seededRow
+    }
+
+    private var column: (model: DataGridColumn, position: Int)? {
+        guard case .data(let id) = slot,
+              let columns = controller?.model.columns,
+              let position = columns.displayPosition(of: id),
+              let column = columns.column(at: position) else { return nil }
+        return (column, position)
+    }
+
+    private var rowModel: Row? {
+        controller?.model.row(at: row)
+    }
+
+    // The row number the reader sees, page offset included.
+    private var shownRowNumber: Int {
+        (controller?.model.dataSource?.gridRowNumberOffset ?? 0) + row + 1
+    }
+
+    override func hitTest(_ point: NSPoint) -> NSView? { nil }
+
+    override func accessibilityRowIndexRange() -> NSRange {
+        NSRange(location: row, length: 1)
+    }
+
+    // A frozen column's cell is read where the frozen pane shows it, not at its home scrolled off to the left.
+    override func accessibilityFrame() -> NSRect {
+        guard let controller, let table, let window = table.window, let column,
+              column.position < controller.effectiveFrozenCount else { return super.accessibilityFrame() }
+        let offset = controller.main.scrollView.contentView.bounds.minX
+        let shown = table.convert(bounds, from: self).offsetBy(dx: offset, dy: 0)
+        return window.convertToScreen(table.convert(shown, to: nil))
+    }
+
+    override func isAccessibilityElement() -> Bool { true }
+
+    // A cell with a list beside its text is a combo box, which is what NSComboBoxCell publishes.
+    override func accessibilityRole() -> NSAccessibility.Role? {
+        guard let column, let rowModel, let controller else { return .staticText }
+        if checkboxMark(row: rowModel, column: column.model) != nil { return .checkBox }
+        return controller.presenter.presentsComboBox(dataIndex: column.model.dataIndex) ? .comboBox : .staticText
+    }
+
+    override func accessibilityValue() -> Any? {
+        guard let column, let rowModel else { return String(shownRowNumber) }
+        if let mark = checkboxMark(row: rowModel, column: column.model) {
+            return NSNumber(value: mark == .checked)
+        }
+        return controller?.presenter.accessibilityText(of: rowModel, column: column.model) ?? ""
+    }
+
+    override func accessibilityPerformPress() -> Bool {
+        guard let controller, let column, let rowModel,
+              controller.toggleCheckbox(rowID: rowModel.id, column: column.model, displayRow: row) else { return false }
+        NSAccessibility.post(element: self, notification: .valueChanged)
+        return true
+    }
+
+    // Whole sentences per combination, so a translator can order the parts; the pending change reads first.
+    override func accessibilityLabel() -> String? {
+        let rowNumber = shownRowNumber
+        guard let controller, let column, let rowModel else {
+            return String(format: String(localized: "Row %d"), rowNumber)
+        }
+        let presenter = controller.presenter
+        let text = presenter.accessibilityText(of: rowModel, column: column.model)
+        let columnNumber = column.position + 1
+        let pendingChange = presenter.pendingChangeDescription(of: rowModel, dataIndex: column.model.dataIndex)
+        let highlight = presenter.highlightDescription(of: rowModel, dataIndex: column.model.dataIndex)
+        if let pendingChange, let highlight {
+            return String(
+                format: String(localized: "Row %d, column %d: %@, %@, highlighted where %@"),
+                rowNumber, columnNumber, text, pendingChange, highlight
+            )
+        }
+        if let pendingChange {
+            return String(format: String(localized: "Row %d, column %d: %@, %@"), rowNumber, columnNumber, text, pendingChange)
+        }
+        if let highlight {
+            return String(
+                format: String(localized: "Row %d, column %d: %@, highlighted where %@"),
+                rowNumber, columnNumber, text, highlight
+            )
+        }
+        return String(format: String(localized: "Row %d, column %d: %@"), rowNumber, columnNumber, text)
+    }
+
+    private func checkboxMark(row: Row, column: DataGridColumn) -> DataGridCheckboxMark? {
+        guard let controller else { return nil }
+        return controller.presenter.checkboxMark(of: row, column: column, checkboxColumns: controller.model.configuration.checkboxColumns)
+    }
+}
+
+extension DataGridViewController {
+    // Only the viewport mounts: walking the tree prepares every row, and 9,000 views behind a 1,000-row page
+    // starved the main thread (#2392).
+    func mountsAccessibilityCell(forRow row: Int) -> Bool {
+        let table = main.tableView
+        return NSLocationInRange(row, table.rows(in: table.visibleRect))
+    }
+
+    func accessibilityCellView(for tableColumn: NSTableColumn, row: Int) -> NSView {
+        let table = main.tableView
+        let cell = (table.makeView(withIdentifier: DataGridAccessibilityCellView.reuseIdentifier, owner: nil)
+            as? DataGridAccessibilityCellView) ?? DataGridAccessibilityCellView()
+        let slot: DataGridPane.Slot = main.columnID(of: tableColumn).map { .data($0) } ?? .rowNumber
+        cell.configure(controller: self, table: table, row: row, slot: slot)
+        return cell
+    }
+
+    // A row prepared off screen was answered with no view and is never asked again, so revealed rows reload.
+    func remountAccessibilityCells(force: Bool = false) {
+        guard DataGridAccessibility.isActive, !isEditingCell else { return }
+        let table = main.tableView
+        let visible = table.rows(in: table.visibleRect)
+        guard visible.length > 0, force || !NSEqualRanges(visible, accessibilityMountedRows) else { return }
+        let upperBound = min(visible.location + visible.length, table.numberOfRows)
+        guard visible.location >= 0, upperBound > visible.location, table.numberOfColumns > 0 else { return }
+        accessibilityMountedRows = visible
+        table.reloadData(
+            forRowIndexes: IndexSet(integersIn: visible.location..<upperBound),
+            columnIndexes: IndexSet(integersIn: 0..<table.numberOfColumns)
+        )
+    }
+
+    // Clamped to the visible rows: AppKit would otherwise ask for every cell of a million-row selection.
+    func accessibilitySelectedCells() -> [Any]? {
+        let table = main.tableView
+        let selection = model.selection
+        guard !selection.isEmpty else { return [] }
+        let visible = table.rows(in: table.visibleRect)
+        guard visible.length > 0 else { return [] }
+        var cells: [Any] = []
+        for rectangle in selection.rectangles {
+            for row in rectangle.rows where NSLocationInRange(row, visible) {
+                for position in rectangle.columns {
+                    guard let index = main.tableIndex(forDisplayPosition: position, columns: model.columns),
+                          let cell = table.view(atColumn: index, row: row, makeIfNecessary: false) as? DataGridAccessibilityCellView
+                    else { continue }
+                    cells.append(cell)
+                }
+            }
+        }
+        return cells
+    }
+
+    func postSelectionAccessibility(from previous: GridSelection, to current: GridSelection) {
+        guard DataGridAccessibility.isActive else { return }
+        let table = main.tableView
+        if current.hasMultipleCells || previous.hasMultipleCells {
+            NSAccessibility.post(
+                element: table,
+                notification: .announcementRequested,
+                userInfo: [
+                    .announcement: Self.accessibilityAnnouncement(for: current),
+                    .priority: NSAccessibilityPriorityLevel.medium.rawValue,
+                ]
+            )
+        }
+        NSAccessibility.post(element: table, notification: .selectedCellsChanged)
+        guard let active = current.activeCell, active != previous.activeCell,
+              let index = main.tableIndex(forDisplayPosition: active.displayColumn, columns: model.columns),
+              active.row < table.numberOfRows,
+              let cell = table.view(atColumn: index, row: active.row, makeIfNecessary: false) as? DataGridAccessibilityCellView
+        else { return }
+        NSAccessibility.post(element: cell, notification: .focusedUIElementChanged)
+    }
+
+    static func accessibilityAnnouncement(for selection: GridSelection) -> String {
+        guard selection.hasMultipleCells, let rect = selection.boundingRectangle else {
+            return String(localized: "Cell selection cleared")
+        }
+        return String(
+            format: String(localized: "%d cells selected, rows %d to %d, columns %d to %d"),
+            selection.uniqueCellCount,
+            rect.rows.lowerBound + 1,
+            rect.rows.upperBound + 1,
+            rect.columns.lowerBound + 1,
+            rect.columns.upperBound + 1
+        )
+    }
+
+    // The frozen pane is hidden from accessibility, so a point over it answers with the main table's own cell.
+    func accessibilityElement(atFrozenPanePoint point: NSPoint) -> NSView? {
+        let frozenTable = frozen.tableView
+        let row = frozenTable.row(at: point)
+        let column = frozenTable.column(at: point)
+        guard row >= 0, column >= 0 else { return nil }
+        DataGridAccessibility.markActive()
+        let table = main.tableView
+        return table.view(atColumn: column, row: row, makeIfNecessary: false)
+            ?? table.rowView(atRow: row, makeIfNecessary: false)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridContainerView.swift b/apple/TablePro/Views/DataGrid/DataGridContainerView.swift
new file mode 100644
index 0000000000..836a407943
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridContainerView.swift
@@ -0,0 +1,185 @@
+//
+//  DataGridContainerView.swift
+//  TablePro
+//
+
+import AppKit
+
+// Two tables scrolled in step, per Apple's "Synchronizing Scroll Views": NSTableView has no per-column freeze.
+@MainActor
+final class DataGridContainerView: NSView {
+    let main = DataGridPane(kind: .main)
+    let frozen = DataGridPane(kind: .frozen)
+    weak var controller: DataGridViewController?
+
+    private(set) var gridHasFocus = false
+    private var isSyncingScroll = false
+    private var firstResponderObservation: NSKeyValueObservation?
+    private var windowObservers: [NSObjectProtocol] = []
+    private var scrollObservers: [NSObjectProtocol] = []
+
+    var frozenPaneWidth: CGFloat = 0 {
+        didSet {
+            guard frozenPaneWidth != oldValue else { return }
+            layoutFrozenPane()
+        }
+    }
+
+    var panes: [DataGridPane] { [main, frozen] }
+
+    init() {
+        super.init(frame: .zero)
+        addSubview(main.scrollView)
+        addSubview(frozen.scrollView)
+        frozen.scrollView.isHidden = true
+        frozen.scrollView.wheelTarget = main.scrollView
+        main.scrollView.onTile = { [weak self] in self?.layoutFrozenPane() }
+        observeScrolling()
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override var isFlipped: Bool { true }
+
+    override func setFrameSize(_ newSize: NSSize) {
+        super.setFrameSize(newSize)
+        needsLayout = true
+    }
+
+    override func layout() {
+        super.layout()
+        if main.scrollView.frame != bounds {
+            main.scrollView.frame = bounds
+        }
+        controller?.containerDidLayout()
+        layoutFrozenPane()
+    }
+
+    // Under legacy scrollers the frozen pane stops above the main pane's horizontal scroller, so both clips are one height.
+    func layoutFrozenPane() {
+        let width = min(frozenPaneWidth, bounds.width)
+        frozen.scrollView.isHidden = width <= 0
+        guard width > 0 else { return }
+        let height = max(0, bounds.height - main.scrollView.legacyHorizontalScrollerHeight)
+        let frame = NSRect(x: 0, y: 0, width: width, height: height)
+        if frozen.scrollView.frame != frame {
+            frozen.scrollView.frame = frame
+        }
+        syncVertical(from: main.scrollView, to: frozen.scrollView)
+    }
+
+    func pane(of tableView: NSTableView) -> DataGridPane? {
+        if tableView === main.tableView { return main }
+        if tableView === frozen.tableView { return frozen }
+        return nil
+    }
+
+    func pane(_ kind: DataGridPane.Kind) -> DataGridPane {
+        kind == .main ? main : frozen
+    }
+
+    // The pane under a point in this view's coordinates.
+    func pane(at point: NSPoint) -> DataGridPane {
+        if !frozen.scrollView.isHidden, frozen.scrollView.frame.contains(point) {
+            return frozen
+        }
+        return main
+    }
+
+    // MARK: - Vertical sync
+
+    private func observeScrolling() {
+        let center = NotificationCenter.default
+        let mainClip = main.scrollView.contentView
+        let frozenClip = frozen.scrollView.contentView
+        scrollObservers = [
+            center.addObserver(forName: NSView.boundsDidChangeNotification, object: mainClip, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated {
+                    guard let self else { return }
+                    self.syncVertical(from: self.main.scrollView, to: self.frozen.scrollView)
+                    self.controller?.mainViewportDidMove()
+                }
+            },
+            center.addObserver(forName: NSView.boundsDidChangeNotification, object: frozenClip, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated {
+                    guard let self else { return }
+                    self.syncVertical(from: self.frozen.scrollView, to: self.main.scrollView)
+                }
+            },
+            center.addObserver(forName: NSScroller.preferredScrollerStyleDidChangeNotification, object: nil, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated { self?.needsLayout = true }
+            },
+        ]
+    }
+
+    // clipView.scroll(to:) is right here: only y moves, so the header clip, which follows x, never drifts.
+    private func syncVertical(from source: NSScrollView, to target: NSScrollView) {
+        guard !isSyncingScroll, !target.isHidden || target === main.scrollView else { return }
+        let y = source.contentView.bounds.origin.y
+        let clip = target.contentView
+        guard clip.bounds.origin.y != y else { return }
+        isSyncingScroll = true
+        clip.scroll(to: NSPoint(x: clip.bounds.origin.x, y: y))
+        target.reflectScrolledClipView(clip)
+        isSyncingScroll = false
+    }
+
+    func tearDown() {
+        scrollObservers.forEach(NotificationCenter.default.removeObserver)
+        scrollObservers.removeAll()
+        stopObservingWindow()
+    }
+
+    // MARK: - Focus
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+        stopObservingWindow()
+        guard let window else {
+            refreshFocus()
+            return
+        }
+        for name in [NSWindow.didBecomeKeyNotification, NSWindow.didResignKeyNotification] {
+            windowObservers.append(NotificationCenter.default.addObserver(forName: name, object: window, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated { self?.refreshFocus() }
+            })
+        }
+        // AppKit posts no first-responder notification but does notify KVO by hand.
+        firstResponderObservation = window.observe(\.firstResponder, options: [.initial, .new]) { [weak self] _, _ in
+            MainActor.assumeIsolated { self?.refreshFocus() }
+        }
+        controller?.containerDidMoveToWindow()
+    }
+
+    private func stopObservingWindow() {
+        windowObservers.forEach(NotificationCenter.default.removeObserver)
+        windowObservers.removeAll()
+        firstResponderObservation = nil
+    }
+
+    // The main table or a field editor inside either pane holds focus, in the key window.
+    func refreshFocus() {
+        let hasFocus: Bool
+        if let window, window.isKeyWindow, let responder = window.firstResponder as? NSView {
+            hasFocus = responder === main.tableView || responder.isDescendant(of: self)
+        } else {
+            hasFocus = false
+        }
+        guard hasFocus != gridHasFocus else { return }
+        gridHasFocus = hasFocus
+        controller?.gridFocusDidChange()
+    }
+
+    // MARK: - Accessibility
+
+    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
+        guard let window, !frozen.scrollView.isHidden else { return super.accessibilityHitTest(point) }
+        let local = convert(window.convertPoint(fromScreen: point), from: nil)
+        guard frozen.scrollView.frame.contains(local) else { return super.accessibilityHitTest(point) }
+        return controller?.accessibilityElement(atFrozenPanePoint: frozen.tableView.convert(local, from: self))
+            ?? super.accessibilityHitTest(point)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridFindBar.swift b/apple/TablePro/Views/DataGrid/DataGridFindBar.swift
new file mode 100644
index 0000000000..4e5f950bc2
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridFindBar.swift
@@ -0,0 +1,281 @@
+import AppKit
+import Combine
+import SwiftUI
+
+struct DataGridFindBar: View {
+    private struct Capabilities: Equatable {
+        var canReplace = false
+        var offersSearchAllRows = false
+    }
+
+    let model: DataGridModel
+    @ObservedObject private var find: GridFindState
+    @State private var capabilities = Capabilities()
+    @State private var pendingSearch: Task<Void, Never>?
+    @State private var status: String?
+    @State private var focusRequest = 0
+
+    init(model: DataGridModel) {
+        self.model = model
+        _find = ObservedObject(wrappedValue: model.find)
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            VStack(alignment: .leading, spacing: 6) {
+                findRow
+                if find.showsReplace, capabilities.canReplace {
+                    replaceRow
+                }
+            }
+            .padding(.horizontal, 12)
+            .padding(.vertical, 6)
+            Divider()
+        }
+        // The search field clears on the first Escape and hands the second on, which closes the bar.
+        .onExitCommand { model.hideFind() }
+        // Find while the bar is already open moves focus back to its field.
+        .onReceive(find.$isVisible.dropFirst()) { isVisible in
+            if isVisible { focusRequest += 1 }
+        }
+        // Configuration changes bump this revision; the bar observes nothing else on the model.
+        .onReceive(model.$editabilityRevision) { _ in
+            capabilities = Capabilities(canReplace: model.canReplaceInFind, offersSearchAllRows: model.offersSearchAllRows)
+        }
+    }
+
+    // MARK: - Rows
+
+    private var findRow: some View {
+        HStack(spacing: 8) {
+            // A SwiftUI field's @FocusState set as the bar appears never reaches the window's first responder here (CI).
+            NativeSearchField(
+                text: termBinding,
+                placeholder: String(localized: "Find"),
+                onSubmit: { step(forward: NSApp.currentEvent?.modifierFlags.contains(.shift) != true) },
+                focusOnAppear: true,
+                focusTrigger: focusRequest,
+                accessibilityIdentifier: "grid-find-field"
+            )
+            .frame(minWidth: 160, maxWidth: 320)
+
+            optionsMenu
+
+            ControlGroup {
+                Button {
+                    step(forward: false)
+                } label: {
+                    Label(String(localized: "Previous match"), systemImage: "chevron.left")
+                }
+                .help(String(localized: "Previous match"))
+                .accessibilityIdentifier("grid-find-previous")
+
+                Button {
+                    step(forward: true)
+                } label: {
+                    Label(String(localized: "Next match"), systemImage: "chevron.right")
+                }
+                .help(String(localized: "Next match"))
+                .accessibilityIdentifier("grid-find-next")
+            }
+            .controlGroupStyle(.navigation)
+            .labelStyle(.iconOnly)
+            .fixedSize()
+            .disabled(find.matches.isEmpty)
+
+            Text(counterText)
+                .font(.callout)
+                .foregroundStyle(find.problem == nil || status != nil ? Color.secondary : Color(nsColor: .systemRed))
+                .monospacedDigit()
+                .lineLimit(1)
+                .accessibilityLabel(counterText)
+                .accessibilityIdentifier("grid-find-count")
+
+            scopeButton
+
+            Spacer(minLength: 8)
+
+            if showsSearchAllRows {
+                Button(String(localized: "Search All Rows")) { model.searchAllRows() }
+                    .accessibilityIdentifier("grid-find-search-all-rows")
+            }
+
+            if capabilities.canReplace {
+                Toggle(String(localized: "Replace"), isOn: $find.showsReplace)
+                    .toggleStyle(.checkbox)
+                    .accessibilityIdentifier("grid-find-replace-toggle")
+            }
+
+            Button(String(localized: "Done")) { model.hideFind() }
+                .accessibilityIdentifier("grid-find-done")
+        }
+    }
+
+    private var replaceRow: some View {
+        HStack(spacing: 8) {
+            TextField(String(localized: "Replace with"), text: $find.replacement)
+                .textFieldStyle(.roundedBorder)
+                .frame(minWidth: 160, maxWidth: 320)
+                .accessibilityLabel(String(localized: "Replace with"))
+                .accessibilityIdentifier("grid-replace-field")
+
+            Button(String(localized: "Replace")) { replaceCurrent() }
+                .disabled(!model.canReplaceCurrentFindMatch)
+                .accessibilityIdentifier("grid-replace")
+
+            Button(String(localized: "Replace All")) { replaceAll() }
+                .disabled(find.matches.isEmpty || find.problem != nil)
+                .accessibilityIdentifier("grid-replace-all")
+
+            Spacer()
+        }
+    }
+
+    private var optionsMenu: some View {
+        Menu {
+            Toggle(String(localized: "Match Case"), isOn: option(\.matchesCase))
+            Toggle(String(localized: "Whole Words"), isOn: option(\.matchesWholeWord))
+            Toggle(String(localized: "Regular Expression"), isOn: option(\.usesRegularExpression))
+            Divider()
+            Picker(String(localized: "Search In"), selection: scopeBinding) {
+                Text(String(localized: "All Columns")).tag(DataGridColumnID?.none)
+                ForEach(model.columns.columns, id: \.id) { column in
+                    Text(column.name).tag(DataGridColumnID?.some(column.id))
+                }
+            }
+        } label: {
+            Label(String(localized: "Find Options"), systemImage: "slider.horizontal.3")
+        }
+        .menuStyle(.button)
+        .buttonStyle(.borderless)
+        .menuIndicator(.hidden)
+        .labelStyle(.iconOnly)
+        .fixedSize()
+        .help(String(localized: "Find Options"))
+        .accessibilityLabel(String(localized: "Find Options"))
+        .accessibilityIdentifier("grid-find-options")
+    }
+
+    @ViewBuilder
+    private var scopeButton: some View {
+        if let scope = find.options.columnScope, let column = model.columns.column(id: scope) {
+            Button {
+                setScope(nil)
+            } label: {
+                Label(String(format: String(localized: "In column %@"), column.name), systemImage: "xmark.circle.fill")
+            }
+            .buttonStyle(.borderless)
+            .help(String(localized: "Search every column"))
+        }
+    }
+
+    // MARK: - State
+
+    private var counterText: String {
+        if let status { return status }
+        if let problem = find.problem { return problem }
+        guard model.hasFindTerm else { return "" }
+        // A search that refreshes keeps showing the count it is about to replace.
+        if find.matches.isEmpty {
+            if find.isSearching { return String(localized: "Searching…") }
+            if find.searchStopped { return String(localized: "Search stopped") }
+        }
+        return FindCounterText.text(
+            matchCount: find.matches.count,
+            currentIndex: find.currentIndex,
+            scope: model.findCoversPageOnly ? .pageOfMore : .allRowsLoaded
+        )
+    }
+
+    // Only when this page has no match, so the bar stays short while matches are on screen.
+    private var showsSearchAllRows: Bool {
+        capabilities.offersSearchAllRows && model.searchAllRowsKeepsTheOptions && model.hasFindTerm
+            && find.problem == nil && find.matches.isEmpty
+    }
+
+    // Use Selection for Find searches on its own, so only typing goes through the delay.
+    private var termBinding: Binding<String> {
+        Binding(
+            get: { find.term },
+            set: { newValue in
+                guard newValue != find.term else { return }
+                find.term = newValue
+                status = nil
+                scheduleSearch()
+            }
+        )
+    }
+
+    private var scopeBinding: Binding<DataGridColumnID?> {
+        Binding(
+            get: { find.options.columnScope },
+            set: { setScope($0) }
+        )
+    }
+
+    private func option(_ keyPath: WritableKeyPath<GridFindState.Options, Bool>) -> Binding<Bool> {
+        Binding(
+            get: { find.options[keyPath: keyPath] },
+            set: { newValue in
+                find.options[keyPath: keyPath] = newValue
+                searchNow()
+            }
+        )
+    }
+
+    // MARK: - Actions
+
+    private func setScope(_ scope: DataGridColumnID?) {
+        find.options.columnScope = scope
+        searchNow()
+    }
+
+    // One scan per pause in typing, not per key: a wide page is hundreds of thousands of cells.
+    private func scheduleSearch() {
+        pendingSearch?.cancel()
+        pendingSearch = Task { @MainActor in
+            try? await Task.sleep(for: .milliseconds(120))
+            guard !Task.isCancelled else { return }
+            pendingSearch = nil
+            model.findQueryDidChange()
+        }
+    }
+
+    private func searchNow() {
+        pendingSearch?.cancel()
+        pendingSearch = nil
+        status = nil
+        model.findQueryDidChange()
+    }
+
+    // A search still waiting on the delay already lands on the first match from the cursor.
+    private func step(forward: Bool) {
+        status = nil
+        if pendingSearch != nil {
+            searchNow()
+            if forward { return }
+        }
+        if forward {
+            model.findNext()
+        } else {
+            model.findPrevious()
+        }
+    }
+
+    private func replaceCurrent() {
+        if pendingSearch != nil {
+            searchNow()
+        }
+        status = nil
+        model.replaceCurrentMatch()
+    }
+
+    // A dataset finder reports its outcome in its own window, so nothing comes back here.
+    private func replaceAll() {
+        pendingSearch?.cancel()
+        pendingSearch = nil
+        status = nil
+        guard let outcome = model.replaceAllMatches() else { return }
+        status = GridFindEngine.replacementMessage(replacements: outcome.replacements, cells: outcome.cells)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridHeaderView.swift b/apple/TablePro/Views/DataGrid/DataGridHeaderView.swift
new file mode 100644
index 0000000000..c2812f2e9e
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridHeaderView.swift
@@ -0,0 +1,33 @@
+//
+//  DataGridHeaderView.swift
+//  TablePro
+//
+
+import AppKit
+
+// The stock header. It overrides only the menu, resolved from the event, and the per-step repaint drawn cells need.
+@MainActor
+final class DataGridHeaderView: NSTableHeaderView {
+    var paneKind: DataGridPane.Kind = .main
+    private var bodyFollowsColumnDrag = false
+
+    private var controller: DataGridViewController? {
+        (tableView as? DataGridTableView)?.controller
+    }
+
+    override func menu(for event: NSEvent) -> NSMenu? {
+        guard let tableView else { return nil }
+        let index = column(at: convert(event.locationInWindow, from: nil))
+        guard index >= 0, index < tableView.tableColumns.count else { return nil }
+        return controller?.headerMenu(forTableColumn: tableView.tableColumns[index], in: paneKind)
+    }
+
+    // AppKit redraws the header on every step of a resize or reorder drag but posts the column notifications only at mouse-up.
+    override func viewWillDraw() {
+        super.viewWillDraw()
+        let isDragging = resizedColumn >= 0 || draggedColumn >= 0
+        guard isDragging || bodyFollowsColumnDrag else { return }
+        bodyFollowsColumnDrag = isDragging
+        controller?.headerGeometryDidStep(in: paneKind)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridModel+ColumnGeometry.swift b/apple/TablePro/Views/DataGrid/DataGridModel+ColumnGeometry.swift
new file mode 100644
index 0000000000..fbc39d7465
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridModel+ColumnGeometry.swift
@@ -0,0 +1,27 @@
+//
+//  DataGridModel+ColumnGeometry.swift
+//  TablePro
+//
+
+import Foundation
+
+extension DataGridModel {
+    // A resize, move or size-to-fit the user made in the grid. Widths given here are the user's, so they are recorded as
+    // owned; the order splices into the stored one so a hidden column keeps its slot.
+    func columnGeometryDidChange(widths: [String: CGFloat], order: [String]?) {
+        guard !widths.isEmpty || order != nil else { return }
+        updateColumnLayout { layout in
+            var captured = layout
+            captured.columnWidths.merge(widths) { _, new in new }
+            if !widths.isEmpty {
+                var owned = captured.columnContentWidths ?? [:]
+                owned.merge(widths) { _, new in new }
+                captured.columnContentWidths = owned
+            }
+            if let order {
+                captured.columnOrder = order
+            }
+            layout.applyGeometry(from: captured)
+        }
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridPane.swift b/apple/TablePro/Views/DataGrid/DataGridPane.swift
new file mode 100644
index 0000000000..a604d916f9
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridPane.swift
@@ -0,0 +1,196 @@
+//
+//  DataGridPane.swift
+//  TablePro
+//
+
+import AppKit
+
+// One table of the grid: the main pane holds every column, the frozen pane the row numbers and frozen columns laid over it.
+@MainActor
+final class DataGridPane {
+    enum Kind {
+        case main
+        case frozen
+    }
+
+    enum Slot: Equatable {
+        case rowNumber
+        case data(DataGridColumnID)
+    }
+
+    static let rowNumberIdentifier = NSUserInterfaceItemIdentifier("DataGrid.rowNumber")
+
+    let kind: Kind
+    let scrollView: DataGridScrollView
+    let tableView: DataGridTableView
+    let headerView: DataGridHeaderView
+
+    private var columnsByID: [DataGridColumnID: NSTableColumn] = [:]
+    private var idByIdentifier: [NSUserInterfaceItemIdentifier: DataGridColumnID] = [:]
+    private var rowNumberColumn: NSTableColumn?
+    private var slotsByTableIndex: [Slot]?
+    private var tableIndexByDisplayPosition: [Int: Int]?
+
+    init(kind: Kind) {
+        let table = DataGridTableView(frame: .zero)
+        table.paneKind = kind
+        Self.configure(table, kind: kind)
+        // Read after the style is set: the stock header's height follows the table style.
+        let header = DataGridHeaderView(frame: table.headerView?.frame ?? NSRect(x: 0, y: 0, width: 0, height: 28))
+        header.paneKind = kind
+        table.headerView = header
+        if kind == .frozen {
+            table.cornerView = nil
+        }
+        let scroll = DataGridScrollView(kind: kind)
+        scroll.documentView = table
+        self.kind = kind
+        tableView = table
+        headerView = header
+        scrollView = scroll
+    }
+
+    private static func configure(_ tableView: DataGridTableView, kind: Kind) {
+        tableView.style = .plain
+        tableView.wantsLayer = true
+        tableView.layerContentsRedrawPolicy = .onSetNeedsDisplay
+        tableView.allowsMultipleSelection = true
+        tableView.allowsEmptySelection = true
+        tableView.allowsColumnSelection = false
+        tableView.allowsColumnReordering = true
+        tableView.allowsColumnResizing = true
+        tableView.allowsTypeSelect = kind == .main
+        tableView.columnAutoresizingStyle = .noColumnAutoresizing
+        tableView.gridStyleMask = []
+        tableView.intercellSpacing = NSSize(width: 1, height: 0)
+        tableView.rowSizeStyle = .custom
+        tableView.usesAutomaticRowHeights = false
+        switch kind {
+        case .main:
+            tableView.setAccessibilityIdentifier("data-grid")
+            tableView.setAccessibilityLabel(String(localized: "Data grid"))
+            tableView.setAccessibilityRole(.table)
+        case .frozen:
+            tableView.setAccessibilityIdentifier("data-grid-frozen")
+            tableView.setAccessibilityElement(false)
+            tableView.verticalMotionCanBeginDrag = false
+        }
+    }
+
+    var isMain: Bool { kind == .main }
+
+    // MARK: - Columns
+
+    func columnID(of column: NSTableColumn) -> DataGridColumnID? {
+        idByIdentifier[column.identifier]
+    }
+
+    func isRowNumber(_ column: NSTableColumn) -> Bool {
+        column.identifier == Self.rowNumberIdentifier
+    }
+
+    func tableColumn(for id: DataGridColumnID) -> NSTableColumn? {
+        columnsByID[id]
+    }
+
+    var hasRowNumberColumn: Bool {
+        tableView.tableColumns.first.map(isRowNumber) ?? false
+    }
+
+    var rowNumberTableColumn: NSTableColumn? {
+        hasRowNumberColumn ? tableView.tableColumns.first : nil
+    }
+
+    // Reuses the NSTableColumn each column already had, so a re-run of the same result does not flicker (#951).
+    func pooledColumn(for id: DataGridColumnID) -> NSTableColumn {
+        if let existing = columnsByID[id] { return existing }
+        let identifier = NSUserInterfaceItemIdentifier("DataGrid.column.\(id.stringValue)")
+        let column = NSTableColumn(identifier: identifier)
+        column.minWidth = DataGridMetrics.dataColumnMinWidth
+        column.maxWidth = DataGridMetrics.dataColumnMaxWidth
+        column.resizingMask = .userResizingMask
+        columnsByID[id] = column
+        idByIdentifier[identifier] = id
+        return column
+    }
+
+    func pooledRowNumberColumn() -> NSTableColumn {
+        if let rowNumberColumn { return rowNumberColumn }
+        let column = NSTableColumn(identifier: Self.rowNumberIdentifier)
+        column.title = "#"
+        column.isEditable = false
+        column.resizingMask = []
+        let headerCell = column.headerCell
+        headerCell.alignment = .right
+        headerCell.setAccessibilityLabel(String(localized: "Row number"))
+        rowNumberColumn = column
+        return column
+    }
+
+    func forgetColumns(except kept: Set<DataGridColumnID>) {
+        for (id, column) in columnsByID where !kept.contains(id) {
+            columnsByID.removeValue(forKey: id)
+            idByIdentifier.removeValue(forKey: column.identifier)
+        }
+    }
+
+    // MARK: - Slots
+
+    func invalidateSlots() {
+        slotsByTableIndex = nil
+        tableIndexByDisplayPosition = nil
+    }
+
+    // Read by every drawn cell, so it is built once per layout and rebuilt only when a column moves.
+    func slot(atTableIndex index: Int, columns: DataGridColumnSet) -> Slot? {
+        let slots = resolvedSlots(columns: columns)
+        guard index >= 0, index < slots.count else { return nil }
+        return slots[index]
+    }
+
+    func tableIndex(forDisplayPosition position: Int, columns: DataGridColumnSet) -> Int? {
+        if tableIndexByDisplayPosition == nil {
+            rebuildSlots(columns: columns)
+        }
+        return tableIndexByDisplayPosition?[position]
+    }
+
+    private func resolvedSlots(columns: DataGridColumnSet) -> [Slot] {
+        if let slotsByTableIndex { return slotsByTableIndex }
+        rebuildSlots(columns: columns)
+        return slotsByTableIndex ?? []
+    }
+
+    private func rebuildSlots(columns: DataGridColumnSet) {
+        var slots: [Slot] = []
+        var positions: [Int: Int] = [:]
+        slots.reserveCapacity(tableView.tableColumns.count)
+        for (index, column) in tableView.tableColumns.enumerated() {
+            if isRowNumber(column) {
+                slots.append(.rowNumber)
+            } else if let id = idByIdentifier[column.identifier] {
+                slots.append(.data(id))
+                if let position = columns.displayPosition(of: id) {
+                    positions[position] = index
+                }
+            } else {
+                slots.append(.rowNumber)
+            }
+        }
+        slotsByTableIndex = slots
+        tableIndexByDisplayPosition = positions
+    }
+
+    // The display positions this pane shows, in its own column order.
+    func displayPositions(columns: DataGridColumnSet) -> [Int] {
+        resolvedSlots(columns: columns).compactMap { slot in
+            guard case .data(let id) = slot else { return nil }
+            return columns.displayPosition(of: id)
+        }
+    }
+
+    var columnsWidth: CGFloat {
+        guard let last = tableView.tableColumns.indices.last else { return 0 }
+        return tableView.rect(ofColumn: last).maxX
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridRowView.swift b/apple/TablePro/Views/DataGrid/DataGridRowView.swift
new file mode 100644
index 0000000000..11175a1b10
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridRowView.swift
@@ -0,0 +1,162 @@
+//
+//  DataGridRowView.swift
+//  TablePro
+//
+
+import AppKit
+
+// Draws its pane's cells: NSTableView mounts a view for every column of every prepared row, which at 200 columns
+// costs 45 ms a frame against 1.5 ms drawn (probe P1).
+@MainActor
+final class DataGridRowView: NSTableRowView {
+    weak var controller: DataGridViewController?
+    weak var gridTable: DataGridTableView?
+
+    private let contentView = DataGridRowContentView()
+
+    // The selection mixes AppKit's row emphasis with the grid's own focus rule, so both panes agree (probe P7, critic M4).
+    override var isEmphasized: Bool {
+        get { super.isEmphasized }
+        set {
+            let resolved = controller?.gridHasFocus ?? newValue
+            guard resolved != super.isEmphasized else { return }
+            super.isEmphasized = resolved
+            redrawCells()
+        }
+    }
+
+    override var isSelected: Bool {
+        didSet {
+            guard isSelected != oldValue else { return }
+            redrawCells()
+        }
+    }
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+        wantsLayer = true
+        layerContentsRedrawPolicy = .onSetNeedsDisplay
+        canDrawSubviewsIntoLayer = true
+        contentView.rowView = self
+        contentView.autoresizingMask = [.width, .height]
+        contentView.frame = bounds
+        addSubview(contentView)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func makeBackingLayer() -> CALayer {
+        let layer = super.makeBackingLayer()
+        layer.actions = Self.disabledLayerActions
+        return layer
+    }
+
+    private static let disabledLayerActions: [String: any CAAction] = [
+        "position": NSNull(),
+        "bounds": NSNull(),
+        "frame": NSNull(),
+        "contents": NSNull(),
+        "hidden": NSNull(),
+    ]
+
+    // Asked of the table rather than remembered: insertRows and removeRows move a row view without asking for it again.
+    var rowIndex: Int {
+        gridTable?.row(for: self) ?? -1
+    }
+
+    func redrawCells() {
+        needsDisplay = true
+        contentView.needsDisplay = true
+    }
+
+    func redrawCells(inTableRect rect: NSRect) {
+        guard let gridTable else {
+            redrawCells()
+            return
+        }
+        let local = convert(rect, from: gridTable)
+        let band = NSRect(x: local.minX, y: bounds.minY, width: local.width, height: bounds.height)
+        setNeedsDisplay(band)
+        contentView.setNeedsDisplay(band)
+    }
+
+    // MARK: - Drawing
+
+    override func drawBackground(in dirtyRect: NSRect) {
+        guard let controller, let gridTable else {
+            super.drawBackground(in: dirtyRect)
+            return
+        }
+        let row = rowIndex
+        let scope = controller.model.themeScope
+        DataGridBodyChrome.fillRowBackground(dirtyRect, row: row, of: gridTable, scope: scope)
+        if let tint = controller.rowTint(forRow: row) {
+            tint.setFill()
+            bounds.intersection(dirtyRect).fill(using: .sourceOver)
+        }
+    }
+
+    override func drawSelection(in dirtyRect: NSRect) {
+        guard isSelected, let controller, let gridTable else { return }
+        let row = rowIndex
+        let color: NSColor = isEmphasized ? .selectedContentBackgroundColor : .unemphasizedSelectedContentBackgroundColor
+        color.setFill()
+        for rect in controller.selectionRects(forRow: row, in: gridTable, within: convert(dirtyRect, to: gridTable)) {
+            let local = convert(rect, from: gridTable)
+            let band = NSRect(x: local.minX, y: bounds.minY, width: local.width, height: bounds.height)
+            band.intersection(dirtyRect).fill()
+        }
+    }
+
+    fileprivate func drawContent(in dirtyRect: NSRect, of view: NSView) {
+        guard let controller, let gridTable else { return }
+        controller.drawCells(ofRow: rowIndex, in: dirtyRect, of: view, table: gridTable, isEmphasized: isEmphasized)
+    }
+
+    // MARK: - Hit testing
+
+    // Data cells have no views, so a press goes to the table; a mounted edit field still takes its own clicks.
+    override func hitTest(_ point: NSPoint) -> NSView? {
+        let hit = super.hitTest(point)
+        return hit === self || hit === contentView ? nil : hit
+    }
+
+    // MARK: - Accessibility
+
+    override func accessibilityRole() -> NSAccessibility.Role? { .row }
+
+    // The row answers for every point no cell covers, so a client never lands on a view outside the tree.
+    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
+        DataGridAccessibility.markActive()
+        guard let window else { return super.accessibilityHitTest(point) }
+        let local = convert(window.convertPoint(fromScreen: point), from: nil)
+        for subview in subviews where subview !== contentView && subview.frame.contains(local) {
+            if let hit = subview.accessibilityHitTest(point) { return hit }
+        }
+        return bounds.contains(local) ? self : nil
+    }
+}
+
+// Its own view so the cells land after the row's background and selection, one view per row whatever the column count.
+@MainActor
+final class DataGridRowContentView: NSView {
+    weak var rowView: DataGridRowView?
+
+    override var isFlipped: Bool { true }
+    override var allowsVibrancy: Bool { false }
+
+    override func isAccessibilityElement() -> Bool { false }
+
+    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
+        rowView?.accessibilityHitTest(point) ?? super.accessibilityHitTest(point)
+    }
+
+    override func hitTest(_ point: NSPoint) -> NSView? { nil }
+
+    override func draw(_ dirtyRect: NSRect) {
+        rowView?.drawContent(in: dirtyRect, of: self)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridScrollView.swift b/apple/TablePro/Views/DataGrid/DataGridScrollView.swift
new file mode 100644
index 0000000000..99afcdf289
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridScrollView.swift
@@ -0,0 +1,63 @@
+//
+//  DataGridScrollView.swift
+//  TablePro
+//
+
+import AppKit
+
+@MainActor
+final class DataGridScrollView: NSScrollView {
+    let paneKind: DataGridPane.Kind
+    var onTile: (() -> Void)?
+    // The frozen pane hands every wheel event to the main pane, so one momentum engine moves both.
+    weak var wheelTarget: NSScrollView?
+
+    init(kind: DataGridPane.Kind) {
+        paneKind = kind
+        super.init(frame: .zero)
+        borderType = .noBorder
+        autohidesScrollers = true
+        contentView.wantsLayer = true
+        contentView.layerContentsRedrawPolicy = .onSetNeedsDisplay
+        contentView.postsBoundsChangedNotifications = true
+        switch kind {
+        case .main:
+            hasVerticalScroller = true
+            hasHorizontalScroller = true
+        case .frozen:
+            hasVerticalScroller = false
+            hasHorizontalScroller = false
+            horizontalScrollElasticity = .none
+            setAccessibilityElement(false)
+        }
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func tile() {
+        super.tile()
+        onTile?()
+    }
+
+    override func scrollWheel(with event: NSEvent) {
+        guard let wheelTarget else {
+            super.scrollWheel(with: event)
+            return
+        }
+        wheelTarget.scrollWheel(with: event)
+    }
+
+    // The frozen pane repeats cells the main table already publishes, so VoiceOver sees one table.
+    override func accessibilityChildren() -> [Any]? {
+        paneKind == .frozen ? [] : super.accessibilityChildren()
+    }
+
+    var legacyHorizontalScrollerHeight: CGFloat {
+        guard scrollerStyle == .legacy, hasHorizontalScroller,
+              let scroller = horizontalScroller, !scroller.isHidden else { return 0 }
+        return scroller.frame.height
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridTableView.swift b/apple/TablePro/Views/DataGrid/DataGridTableView.swift
new file mode 100644
index 0000000000..d1edf45a3e
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridTableView.swift
@@ -0,0 +1,283 @@
+//
+//  DataGridTableView.swift
+//  TablePro
+//
+
+import AppKit
+
+// One class for both panes. Behavior comes from NSResponder actions the standard key bindings produce, never key codes.
+@MainActor
+final class DataGridTableView: NSTableView {
+    weak var controller: DataGridViewController?
+    var paneKind: DataGridPane.Kind = .main
+
+    private static let chordModifiers: NSEvent.ModifierFlags = [.command, .shift, .option, .control]
+
+    // The main table is the grid's one first responder; a press in the frozen pane hands focus to it.
+    override var acceptsFirstResponder: Bool {
+        paneKind == .main
+    }
+
+    // MARK: - Drawing
+
+    override func drawBackground(inClipRect clipRect: NSRect) {
+        let scope = controller?.model.themeScope ?? .live
+        DataGridBodyChrome.drawTableBackground(in: clipRect, of: self, scope: scope)
+        let lastRowBottom = numberOfRows > 0 ? rect(ofRow: numberOfRows - 1).maxY : bounds.minY
+        let belowRows = clipRect.intersection(NSRect(x: clipRect.minX, y: lastRowBottom, width: clipRect.width, height: bounds.height))
+        guard !belowRows.isEmpty else { return }
+        DataGridBodyChrome.drawColumnSeparators(in: belowRows, of: self, tableView: self)
+        if paneKind == .frozen {
+            controller?.drawFrozenPaneEdge(in: belowRows, of: self)
+        }
+    }
+
+    // AppKit sizes the table to its columns; widening the proposed frame keeps the header and rows over the trailing space.
+    override func setFrameSize(_ newSize: NSSize) {
+        guard paneKind == .main, let last = tableColumns.indices.last else {
+            super.setFrameSize(newSize)
+            return
+        }
+        let trailingExtent = rect(ofColumn: last).maxX + DataGridMetrics.trailingSpace
+        super.setFrameSize(NSSize(width: max(newSize.width, trailingExtent), height: newSize.height))
+    }
+
+    // AppKit reorders tableColumns on each pass of a header drag but posts columnDidMove only at mouse-up.
+    override func moveColumn(_ oldIndex: Int, toColumn newIndex: Int) {
+        super.moveColumn(oldIndex, toColumn: newIndex)
+        controller?.tableDidMoveColumn(self)
+    }
+
+    // A revealed column must never park under the frozen pane, so the rect widens leftward by its width.
+    override func scrollToVisible(_ rect: NSRect) -> Bool {
+        guard paneKind == .main, let controller else { return super.scrollToVisible(rect) }
+        return super.scrollToVisible(controller.revealRect(for: rect, in: self))
+    }
+
+    // MARK: - Keyboard
+
+    override func keyDown(with event: NSEvent) {
+        guard paneKind == .main, let controller else {
+            super.keyDown(with: event)
+            return
+        }
+        if controller.handleGridKey(event) { return }
+        if routesThroughKeyBindings(event) {
+            interpretKeyEvents([event])
+            return
+        }
+        super.keyDown(with: event)
+    }
+
+    // NSTableView.keyDown never calls interpretKeyEvents and leaves these keys unanswered (probe P3).
+    private func routesThroughKeyBindings(_ event: NSEvent) -> Bool {
+        guard let specialKey = event.specialKey else { return false }
+        let modifiers = event.modifierFlags.intersection(Self.chordModifiers)
+        switch specialKey {
+        case .tab, .backTab:
+            // Control-Tab leaves the table through the key view loop.
+            return !modifiers.contains(.control)
+        case .carriageReturn, .newline, .enter, .delete, .deleteForward, .leftArrow, .rightArrow:
+            return true
+        case .upArrow, .downArrow:
+            return modifiers.contains(.shift) && controller?.selectionIsCellRange == true
+        default:
+            return false
+        }
+    }
+
+    override func moveLeft(_ sender: Any?) {
+        controller?.moveSelection(.left, extending: false, toEdge: false)
+    }
+
+    override func moveRight(_ sender: Any?) {
+        controller?.moveSelection(.right, extending: false, toEdge: false)
+    }
+
+    override func moveWordLeft(_ sender: Any?) {
+        controller?.moveSelection(.left, extending: false, toEdge: false)
+    }
+
+    override func moveWordRight(_ sender: Any?) {
+        controller?.moveSelection(.right, extending: false, toEdge: false)
+    }
+
+    override func moveLeftAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.left, extending: true, toEdge: false)
+    }
+
+    override func moveRightAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.right, extending: true, toEdge: false)
+    }
+
+    override func moveWordLeftAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.left, extending: true, toEdge: false)
+    }
+
+    override func moveWordRightAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.right, extending: true, toEdge: false)
+    }
+
+    override func moveUpAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.up, extending: true, toEdge: false)
+    }
+
+    override func moveDownAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.down, extending: true, toEdge: false)
+    }
+
+    override func moveToBeginningOfDocumentAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.up, extending: true, toEdge: true)
+    }
+
+    override func moveToEndOfDocumentAndModifySelection(_ sender: Any?) {
+        controller?.moveSelection(.down, extending: true, toEdge: true)
+    }
+
+    override func moveToBeginningOfLine(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: false, extending: false)
+    }
+
+    override func moveToEndOfLine(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: true, extending: false)
+    }
+
+    override func moveToLeftEndOfLine(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: false, extending: false)
+    }
+
+    override func moveToRightEndOfLine(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: true, extending: false)
+    }
+
+    override func moveToBeginningOfLineAndModifySelection(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: false, extending: true)
+    }
+
+    override func moveToEndOfLineAndModifySelection(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: true, extending: true)
+    }
+
+    override func moveToLeftEndOfLineAndModifySelection(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: false, extending: true)
+    }
+
+    override func moveToRightEndOfLineAndModifySelection(_ sender: Any?) {
+        controller?.moveToColumnEdge(last: true, extending: true)
+    }
+
+    override func insertTab(_ sender: Any?) {
+        guard controller?.tabToCell(forward: true) == true else {
+            window?.selectKeyView(following: self)
+            return
+        }
+    }
+
+    override func insertBacktab(_ sender: Any?) {
+        guard controller?.tabToCell(forward: false) == true else {
+            window?.selectKeyView(preceding: self)
+            return
+        }
+    }
+
+    override func insertNewline(_ sender: Any?) {
+        controller?.beginEditingActiveCell()
+    }
+
+    override func cancelOperation(_ sender: Any?) {
+        guard controller?.cancelSelection() == true else {
+            super.cancelOperation(sender)
+            return
+        }
+    }
+
+    override func deleteBackward(_ sender: Any?) {
+        controller?.performDeleteCommand()
+    }
+
+    override func deleteForward(_ sender: Any?) {
+        controller?.performDeleteCommand()
+    }
+
+    override func selectAll(_ sender: Any?) {
+        controller?.performSelectAll(sender)
+    }
+
+    override func validateUserInterfaceItem(_ item: NSValidatedUserInterfaceItem) -> Bool {
+        if let action = item.action,
+           let enabled = FontSizeZoom.dataGrid.enablement(action, typography: AppSettingsManager.shared.typography) {
+            return enabled
+        }
+        if item.action == #selector(selectAll(_:)) {
+            return controller?.validateGridCommand(item) ?? false
+        }
+        return super.validateUserInterfaceItem(item)
+    }
+
+    // MARK: - Mouse
+
+    override func mouseDown(with event: NSEvent) {
+        guard let controller else {
+            super.mouseDown(with: event)
+            return
+        }
+        controller.tableMouseDown(self, with: event)
+    }
+
+    // The controller hands a press back here when AppKit's own tracking is wanted, for a row reorder drag.
+    func performNativeMouseDown(with event: NSEvent) {
+        super.mouseDown(with: event)
+    }
+
+    override func canDragRows(with rowIndexes: IndexSet, at mouseDownPoint: NSPoint) -> Bool {
+        guard paneKind == .frozen, let controller else { return false }
+        let column = column(at: mouseDownPoint)
+        let row = row(at: mouseDownPoint)
+        guard column >= 0, column < tableColumns.count, row >= 0,
+              tableColumns[column].identifier == DataGridPane.rowNumberIdentifier,
+              controller.canDragRows(fromRowNumberAt: row) else { return false }
+        return super.canDragRows(with: rowIndexes, at: mouseDownPoint)
+    }
+
+    // MARK: - Accessibility
+
+    override func accessibilityChildren() -> [Any]? {
+        guard paneKind == .main else { return [] }
+        DataGridAccessibility.markActive()
+        return super.accessibilityChildren()
+    }
+
+    override func accessibilityCell(forColumn column: Int, row: Int) -> Any? {
+        guard paneKind == .main else { return nil }
+        DataGridAccessibility.markActive()
+        return view(atColumn: column, row: row, makeIfNecessary: false) as? DataGridAccessibilityCellView
+            ?? super.accessibilityCell(forColumn: column, row: row)
+    }
+
+    override func accessibilitySelectedCells() -> [Any]? {
+        guard paneKind == .main else { return [] }
+        return controller?.accessibilitySelectedCells() ?? super.accessibilitySelectedCells()
+    }
+
+    // A point inside a row but outside every column resolves to the row, not the table, so the row stays reachable there.
+    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
+        DataGridAccessibility.markActive()
+        guard let window else { return super.accessibilityHitTest(point) }
+        let local = convert(window.convertPoint(fromScreen: point), from: nil)
+        let index = row(at: local)
+        guard index >= 0, let rowView = rowView(atRow: index, makeIfNecessary: false) else {
+            return super.accessibilityHitTest(point)
+        }
+        return rowView.accessibilityHitTest(point) ?? rowView
+    }
+}
+
+extension DataGridTableView: ZoomCommandResponding {
+    @objc func zoomIn(_ sender: Any?) {
+        FontSizeZoom.dataGrid.zoom(by: 1)
+    }
+
+    @objc func zoomOut(_ sender: Any?) {
+        FontSizeZoom.dataGrid.zoom(by: -1)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridView.swift b/apple/TablePro/Views/DataGrid/DataGridView.swift
new file mode 100644
index 0000000000..1ed325eb32
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridView.swift
@@ -0,0 +1,51 @@
+//
+//  DataGridView.swift
+//  TablePro
+//
+
+import AppKit
+import SwiftUI
+
+struct DataGridView: View {
+    @ObservedObject var model: DataGridModel
+
+    init(model: DataGridModel) {
+        self.model = model
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            DataGridFindBarSlot(model: model, find: model.find)
+            DataGridRepresentable(model: model)
+        }
+    }
+}
+
+// Observes the find state alone, so typing in the find field never re-renders the grid.
+private struct DataGridFindBarSlot: View {
+    let model: DataGridModel
+    @ObservedObject var find: GridFindState
+
+    var body: some View {
+        if find.isVisible {
+            DataGridFindBar(model: model)
+        }
+    }
+}
+
+struct DataGridRepresentable: NSViewControllerRepresentable {
+    let model: DataGridModel
+
+    func makeNSViewController(context: Context) -> DataGridViewController {
+        DataGridViewController(model: model)
+    }
+
+    func updateNSViewController(_ controller: DataGridViewController, context: Context) {
+        controller.adopt(model)
+    }
+
+    // Commits an open edit before the grid goes, which covers a result-mode switch with no tab change.
+    static func dismantleNSViewController(_ controller: DataGridViewController, coordinator: ()) {
+        controller.dismantle()
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+Changes.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+Changes.swift
new file mode 100644
index 0000000000..ab5f2b8bd8
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+Changes.swift
@@ -0,0 +1,306 @@
+//
+//  DataGridViewController+Changes.swift
+//  TablePro
+//
+
+import AppKit
+
+extension DataGridViewController {
+    // Drawn rows repaint through needsDisplay; reloadData(forRowIndexes:columnIndexes:) only mounts and unmounts a
+    // cell view, because reloading an edited row ends the edit (probe P1d, P2).
+    func apply(_ change: DataGridChange) {
+        editingWillApply(change)
+        // AppKit adjusts and announces its own selection on an insert or removal; the model's selection is the one that counts.
+        isMirroringSelection = true
+        switch change {
+        case .reload:
+            reloadAll()
+            applyStagedViewport()
+        case .columnsChanged:
+            columnsDidChange()
+        case .rowsInserted(let indexes):
+            insertRows(indexes)
+        case .rowsRemoved(let indexes):
+            removeRows(indexes)
+        case .rowsUpdated(let rows, let columns):
+            updateRows(rows, columns: columns)
+        }
+        // A moved row view keeps its layer's pixels, and its number and stripe come from the index it now holds.
+        redrawRows(change.movedRows(rowCount: model.rowCount))
+        isMirroringSelection = false
+        mirrorSelection()
+        editingDidApply(change)
+        selectionDidMove()
+        selectionSummaryTracker.dataDidChange()
+    }
+
+    func configurationDidChange() {
+        applyTableSettings()
+        let changed = presenter.refreshColumnPresentations()
+        reconcileColumns(widening: changed)
+        applyRowNumberWidth()
+        syncSortIndicators()
+        redrawVisibleRows()
+    }
+
+    // MARK: - Structural changes
+
+    func reloadAll() {
+        presenter.rebuildVisualIndex()
+        let changed = presenter.refreshColumnPresentations()
+        reconcileColumns(widening: changed)
+        applyRowNumberWidth()
+        for pane in panes {
+            pane.tableView.reloadData()
+        }
+        accessibilityMountedRows = NSRange(location: 0, length: 0)
+        drawnSelection = model.selection
+        // A view-based reloadData() drops the selection without telling anyone (probe P2), so it is written back.
+        mirrorSelection()
+        updateHighlightedColumns(model.selection)
+        syncSortIndicators()
+        startBackgroundPrewarm()
+    }
+
+    private func columnsDidChange() {
+        presenter.rebuildVisualIndex()
+        let changed = presenter.refreshColumnPresentations()
+        reconcileColumns(widening: changed)
+        applyRowNumberWidth()
+        drawnSelection = model.selection
+        updateHighlightedColumns(model.selection)
+        syncSortIndicators()
+        redrawVisibleRows()
+        remountAccessibilityCells(force: true)
+    }
+
+    // Both panes take the same insert in one call, so their document heights never differ.
+    private func insertRows(_ indexes: IndexSet) {
+        let target = model.rowCount
+        guard !indexes.isEmpty,
+              panes.allSatisfy({ $0.tableView.numberOfRows + indexes.count == target }) else {
+            reloadAll()
+            return
+        }
+        presenter.rebuildVisualIndex()
+        for pane in panes {
+            pane.tableView.insertRows(at: indexes, withAnimation: [])
+        }
+        applyRowNumberWidth()
+        startBackgroundPrewarm()
+    }
+
+    private func removeRows(_ indexes: IndexSet) {
+        let target = model.rowCount
+        guard !indexes.isEmpty,
+              panes.allSatisfy({ $0.tableView.numberOfRows - indexes.count == target }) else {
+            reloadAll()
+            return
+        }
+        presenter.rebuildVisualIndex()
+        for pane in panes {
+            pane.tableView.removeRows(at: indexes, withAnimation: [])
+        }
+        applyRowNumberWidth()
+    }
+
+    private func updateRows(_ rows: IndexSet, columns displayColumns: IndexSet?) {
+        let wholeRows = refreshRowState(rows, columns: displayColumns)
+        for pane in panes {
+            let table = pane.tableView
+            let rects = (displayColumns ?? []).compactMap {
+                pane.tableIndex(forDisplayPosition: $0, columns: model.columns).map(table.rect(ofColumn:))
+            }
+            table.enumerateAvailableRowViews { rowView, row in
+                guard rows.contains(row), let rowView = rowView as? DataGridRowView else { return }
+                if wholeRows.contains(row) {
+                    rowView.redrawCells()
+                } else {
+                    rects.forEach(rowView.redrawCells(inTableRect:))
+                }
+            }
+        }
+    }
+
+    // Updates the rows' pending marks and answers which drawn rows repaint whole: a row tint and the row number span
+    // both panes, so only a row whose tint cannot have changed keeps to the changed columns.
+    func refreshRowState(_ rows: IndexSet, columns displayColumns: IndexSet?) -> IndexSet {
+        let current = model.rows
+        let drawn = rowsWithViews(in: rows)
+        let tintsBefore = drawn.map { rowTint(forRow: $0) }
+        presenter.updateVisualIndex(for: rows.compactMap { model.order.rowID(at: $0, in: current) })
+        // The model drops a changed row's cached highlight before this runs, so a row rule's old wash is not known.
+        guard displayColumns != nil, !hasRowHighlightRules else { return drawn }
+        var retinted = IndexSet()
+        for (row, before) in zip(drawn, tintsBefore) where rowTint(forRow: row) != before {
+            retinted.insert(row)
+        }
+        return retinted
+    }
+
+    private var hasRowHighlightRules: Bool {
+        model.dataSource?.gridHighlightRules.contains { $0.isEnabled && $0.target == .row } ?? false
+    }
+
+    private func rowsWithViews(in rows: IndexSet) -> IndexSet {
+        var drawn = IndexSet()
+        for pane in panes {
+            pane.tableView.enumerateAvailableRowViews { _, row in
+                if rows.contains(row) {
+                    drawn.insert(row)
+                }
+            }
+        }
+        return drawn
+    }
+
+    // MARK: - Geometry
+
+    // The setting is a floor under the grid font's line height; both panes take it in one call.
+    func applyRowHeight() {
+        let height = DataGridMetrics.rowHeight(
+            AppSettingsManager.shared.dataGrid.rowHeight,
+            font: ThemeEngine.shared.dataGridFonts.regular
+        )
+        guard panes.contains(where: { $0.tableView.rowHeight != height }) else { return }
+        keepingFirstVisibleRow {
+            for pane in panes {
+                pane.tableView.rowHeight = height
+                pane.tableView.tile()
+            }
+        }
+    }
+
+    // The clip view keeps its offset in points, so a new row height would otherwise bring other rows into view.
+    private func keepingFirstVisibleRow(_ change: () -> Void) {
+        let table = main.tableView
+        guard let sample = viewportSample(), table.rowHeight > 0 else {
+            change()
+            return
+        }
+        let previousHeight = table.rowHeight
+        change()
+        let offset = sample.offset * table.rowHeight / previousHeight
+        let rowOrigin = table.rect(ofRow: sample.row).minY
+        let x = main.scrollView.contentView.bounds.origin.x
+        table.scroll(NSPoint(x: x, y: rowOrigin + offset - headerInset))
+    }
+
+    var headerInset: CGFloat {
+        main.scrollView.contentView.contentInsets.top
+    }
+
+    func viewportSample() -> (row: Int, offset: CGFloat)? {
+        let table = main.tableView
+        guard table.numberOfRows > 0 else { return nil }
+        var visible = table.visibleRect
+        visible.origin.y += headerInset
+        visible.size.height = max(0, visible.height - headerInset)
+        let rows = table.rows(in: visible)
+        guard rows.length > 0, rows.location < table.numberOfRows else { return nil }
+        let offset = visible.minY - table.rect(ofRow: rows.location).minY
+        return (rows.location, max(0, offset))
+    }
+
+    // MARK: - Viewport anchor
+
+    func saveViewportAnchor() {
+        guard let sample = viewportSample(), let rowID = model.rowID(at: sample.row) else { return }
+        model.store.viewportAnchor = GridViewportPlacement(
+            firstVisibleRow: rowID,
+            firstVisibleOffset: sample.offset,
+            selectedRows: [],
+            revealsSelection: false
+        )
+    }
+
+    // A placement is one-shot: staged by the owner before a reload, or saved here on the way out.
+    func applyStagedViewport() {
+        guard let placement = model.store.viewportAnchor else { return }
+        guard main.scrollView.contentView.bounds.height > 0 else {
+            needsViewportRestore = true
+            return
+        }
+        model.store.viewportAnchor = nil
+        let table = main.tableView
+        let x = main.scrollView.contentView.bounds.origin.x
+        if let rowID = placement.firstVisibleRow,
+           let row = model.displayIndex(of: rowID),
+           row < table.numberOfRows {
+            table.scroll(NSPoint(x: x, y: table.rect(ofRow: row).minY + placement.firstVisibleOffset - headerInset))
+        } else {
+            table.scroll(NSPoint(x: x, y: -headerInset))
+        }
+        guard !placement.selectedRows.isEmpty else { return }
+        // Selecting publishes the model, which a SwiftUI update or layout pass refuses, so it runs on the next turn.
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.model.mountedView === self else { return }
+            self.model.selectRows(placement.selectedRows)
+            guard placement.revealsSelection, let row = self.model.selection.affectedRows.first else { return }
+            self.reveal(row: row, displayColumn: nil)
+        }
+    }
+
+    // MARK: - Prewarm
+
+    // Formats ±250 rows around the viewport in 2 ms slices, paused during live scroll, so a row draw is a cache hit.
+    func startBackgroundPrewarm() {
+        prewarmResumeTask?.cancel()
+        prewarmResumeTask = nil
+        prewarmTask?.cancel()
+        prewarmTask = Task { @MainActor [weak self] in
+            await self?.runBackgroundPrewarm()
+        }
+    }
+
+    func pausePrewarm() {
+        prewarmResumeTask?.cancel()
+        prewarmResumeTask = nil
+        prewarmTask?.cancel()
+        prewarmTask = nil
+    }
+
+    func schedulePrewarmResume() {
+        prewarmResumeTask?.cancel()
+        prewarmResumeTask = Task { @MainActor [weak self] in
+            try? await Task.sleep(for: .milliseconds(300))
+            guard !Task.isCancelled, let self else { return }
+            self.startBackgroundPrewarm()
+        }
+    }
+
+    private func runBackgroundPrewarm() async {
+        var nextIndex: Int?
+        let budget = Duration.milliseconds(2)
+        while !Task.isCancelled {
+            let rows = model.rows
+            let order = model.order
+            let formats = model.store.displayFormats
+            let databaseType = model.configuration.traits.databaseType
+            let visible = main.tableView.rows(in: main.tableView.visibleRect)
+            let window = DataGridPrewarmWindow.rows(
+                around: max(0, visible.location)..<max(0, visible.location + visible.length),
+                displayCount: order.count(in: rows)
+            )
+            var index = max(nextIndex ?? window.lowerBound, window.lowerBound)
+            guard index < window.upperBound else { return }
+
+            let deadline = ContinuousClock.now.advanced(by: budget)
+            while index < window.upperBound {
+                if Task.isCancelled { return }
+                if let row = order.row(at: index, in: rows) {
+                    presenter.cacheText(of: row, rows: rows, formats: formats, databaseType: databaseType)
+                }
+                index += 1
+                if ContinuousClock.now >= deadline { break }
+            }
+            nextIndex = index
+            await Task.yield()
+        }
+    }
+
+    func mainViewportDidMove() {
+        remountAccessibilityCells()
+        schedulePrewarmResume()
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+Columns.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+Columns.swift
new file mode 100644
index 0000000000..d2374ad33b
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+Columns.swift
@@ -0,0 +1,388 @@
+//
+//  DataGridViewController+Columns.swift
+//  TablePro
+//
+
+import AppKit
+
+extension DataGridViewController {
+    // Builds both panes' column lists from the model. Never culls a column with isHidden: each write costs
+    // O(attached columns), and seconds at 500 columns with mounted views (probe section 5).
+    func reconcileColumns(widening changedPresentations: IndexSet = []) {
+        isRebuildingColumns = true
+        defer { isRebuildingColumns = false }
+
+        let columns = model.columns
+        let ids = Set(columns.columns.map(\.id))
+        // A new result measures every column again; hiding, showing, moving or freezing keeps the widths the reader sees.
+        let rows = model.rows
+        let resultIDs = DataGridColumnSet.columnIDs(for: rows.columns)
+        // Widths measured over a result whose rows had not landed yet were the headings' alone.
+        if resultIDs != resultColumnIDs || (!rows.rows.isEmpty && !knownWidthsSawRows) {
+            resultColumnIDs = resultIDs
+            knownWidths.removeAll()
+            savedWidthIDs.removeAll()
+        }
+        knownWidthsSawRows = !rows.rows.isEmpty
+        let layout = model.store.columnLayout
+        let calculator = widthCalculator()
+        var desired: [NSTableColumn] = []
+        if model.configuration.showRowNumbers {
+            desired.append(main.pooledRowNumberColumn())
+        }
+        var nextSaved = Set<DataGridColumnID>()
+        for column in columns.columns {
+            let tableColumn = main.pooledColumn(for: column.id)
+            let width: CGFloat
+            if let saved = layout.columnWidths[column.name], keepsSavedWidth(of: column, in: layout) {
+                width = saved
+                nextSaved.insert(column.id)
+            } else if let known = knownWidths[column.id], !savedWidthIDs.contains(column.id) {
+                // Metadata that reveals an accessory arrives after the rows; an auto width only grows to fit it.
+                width = changedPresentations.contains(column.dataIndex)
+                    ? max(known, calculator.automaticWidth(widthInput(for: column)))
+                    : known
+            } else {
+                width = calculator.automaticWidth(widthInput(for: column))
+            }
+            configure(tableColumn, as: column, width: width)
+            knownWidths[column.id] = tableColumn.width
+            desired.append(tableColumn)
+        }
+        apply(desired, to: main)
+        main.forgetColumns(except: ids)
+        savedWidthIDs = nextSaved
+        updateFrozenPane()
+        refreshHeaders()
+    }
+
+    // A width saved before accessories reserved room, and never set by the user, is measured again.
+    private func keepsSavedWidth(of column: DataGridColumn, in layout: ColumnLayoutState) -> Bool {
+        if layout.columnContentWidths?[column.name] != nil { return true }
+        return presenter.presentation(forDataIndex: column.dataIndex).accessory == .none
+    }
+
+    // The frozen pane shows the row numbers and the frozen columns that fit in two thirds of the grid.
+    func updateFrozenPane() {
+        let wasRebuilding = isRebuildingColumns
+        isRebuildingColumns = true
+        defer { isRebuildingColumns = wasRebuilding }
+
+        sizeRowNumberColumns()
+        let count = resolveEffectiveFrozenCount()
+        effectiveFrozenCount = count
+        let frozenColumns = Array(model.columns.columns.prefix(count))
+        var desired: [NSTableColumn] = []
+        if model.configuration.showRowNumbers {
+            desired.append(frozen.pooledRowNumberColumn())
+        }
+        for column in frozenColumns {
+            let tableColumn = frozen.pooledColumn(for: column.id)
+            configure(tableColumn, as: column, width: main.tableColumn(for: column.id)?.width ?? DataGridMetrics.dataColumnMinWidth)
+            desired.append(tableColumn)
+        }
+        apply(desired, to: frozen)
+        frozen.forgetColumns(except: Set(frozenColumns.map(\.id)))
+        applyRowNumberWidth()
+        container.frozenPaneWidth = desired.isEmpty ? 0 : frozen.columnsWidth
+    }
+
+    func resolveEffectiveFrozenCount() -> Int {
+        let requested = model.columns.frozenCount
+        guard requested > 0 else { return 0 }
+        let available = container.bounds.width * DataGridMetrics.maximumFrozenShare
+        let spacing = main.tableView.intercellSpacing.width
+        var width = main.rowNumberTableColumn.map { $0.width + spacing } ?? 0
+        var count = 0
+        for column in model.columns.frozenColumns {
+            guard let tableColumn = main.tableColumn(for: column.id) else { break }
+            let next = width + tableColumn.width + spacing
+            guard next <= available else { break }
+            width = next
+            count += 1
+        }
+        return count
+    }
+
+    // Freeze Up to This Column is refused when the frozen run would leave less than a third of the grid to scroll.
+    func canFreezeColumns(throughDisplayPosition position: Int) -> Bool {
+        guard let index = main.tableIndex(forDisplayPosition: position, columns: model.columns) else { return false }
+        let width = main.tableView.rect(ofColumn: index).maxX
+        let available = container.bounds.width * DataGridMetrics.maximumFrozenShare
+        return available > 0 && width <= available
+    }
+
+    private func apply(_ desired: [NSTableColumn], to pane: DataGridPane) {
+        let table = pane.tableView
+        let wanted = Set(desired.map(\.identifier))
+        for column in table.tableColumns where !wanted.contains(column.identifier) {
+            table.removeTableColumn(column)
+        }
+        let attached = Set(table.tableColumns.map(\.identifier))
+        for column in desired where !attached.contains(column.identifier) {
+            table.addTableColumn(column)
+        }
+
+        NSAnimationContext.beginGrouping()
+        NSAnimationContext.current.duration = 0
+        NSAnimationContext.current.allowsImplicitAnimation = false
+        defer { NSAnimationContext.endGrouping() }
+
+        var indexByIdentifier: [NSUserInterfaceItemIdentifier: Int] = [:]
+        indexByIdentifier.reserveCapacity(table.tableColumns.count)
+        for (index, column) in table.tableColumns.enumerated() {
+            indexByIdentifier[column.identifier] = index
+        }
+        for (target, column) in desired.enumerated() {
+            guard let current = indexByIdentifier[column.identifier], current != target else { continue }
+            table.moveColumn(current, toColumn: target)
+            Self.shiftIndexes(&indexByIdentifier, from: current, to: target)
+        }
+        pane.invalidateSlots()
+    }
+
+    private static func shiftIndexes(_ map: inout [NSUserInterfaceItemIdentifier: Int], from source: Int, to destination: Int) {
+        let lower = min(source, destination)
+        let upper = max(source, destination)
+        let delta = source < destination ? -1 : 1
+        for (key, value) in map where value >= lower && value <= upper {
+            map[key] = value == source ? destination : value + delta
+        }
+    }
+
+    // Raising minWidth past width moves the width without updating the table's geometry, so the width goes in first.
+    private func configure(_ tableColumn: NSTableColumn, as column: DataGridColumn, width: CGFloat) {
+        let configuration = model.configuration
+        let minWidth = configuration.columnMinimumWidths[column.name] ?? DataGridMetrics.dataColumnMinWidth
+        let resolvedWidth = max(width, minWidth)
+        if tableColumn.minWidth > minWidth {
+            tableColumn.minWidth = minWidth
+        }
+        if tableColumn.width != resolvedWidth {
+            tableColumn.width = resolvedWidth
+        }
+        if tableColumn.minWidth != minWidth {
+            tableColumn.minWidth = minWidth
+        }
+        if tableColumn.isEditable != configuration.isEditable {
+            tableColumn.isEditable = configuration.isEditable
+        }
+        guard configuration.supportsColumnSort else {
+            if tableColumn.sortDescriptorPrototype != nil {
+                tableColumn.sortDescriptorPrototype = nil
+            }
+            return
+        }
+        let ascending = firstClickSortDirection == .ascending
+        let key = column.id.stringValue
+        if tableColumn.sortDescriptorPrototype?.key != key || tableColumn.sortDescriptorPrototype?.ascending != ascending {
+            tableColumn.sortDescriptorPrototype = NSSortDescriptor(key: key, ascending: ascending)
+        }
+    }
+
+    // The column is pinned to one width, so its interval opens before the width moves through it; AppKit
+    // otherwise keeps the old geometry and posts no resize (measured on macOS 27).
+    func applyRowNumberWidth() {
+        guard sizeRowNumberColumns() else { return }
+        container.frozenPaneWidth = frozen.tableView.tableColumns.isEmpty ? 0 : frozen.columnsWidth
+        redrawVisibleRows()
+    }
+
+    @discardableResult
+    private func sizeRowNumberColumns() -> Bool {
+        let maxNumber = max((model.dataSource?.gridRowNumberOffset ?? 0) + model.rowCount, 1)
+        let font = ThemeEngine.shared.dataGridFonts.rowNumber
+        let textWidth = (String(maxNumber) as NSString).size(withAttributes: [.font: font]).width
+        let measured = ceil(textWidth) + 2 * DataGridMetrics.cellHorizontalInset + DataGridMetrics.rowNumberHeaderPadding
+        let width = max(DataGridMetrics.rowNumberColumnMinWidth, measured)
+        var changed = false
+        for pane in panes {
+            guard let column = pane.rowNumberTableColumn,
+                  column.width != width || column.minWidth != width || column.maxWidth != width else { continue }
+            column.minWidth = min(column.minWidth, width)
+            column.maxWidth = max(column.maxWidth, width)
+            column.width = width
+            column.minWidth = width
+            column.maxWidth = width
+            changed = true
+        }
+        return changed
+    }
+
+    var firstClickSortDirection: SortDirection {
+        guard model.configuration.appliesRowSortPreferences else { return .ascending }
+        return AppSettingsManager.shared.dataGrid.defaultSortDirection
+    }
+
+    // MARK: - Width measurement
+
+    func widthCalculator() -> DataGridColumnWidthCalculator {
+        DataGridColumnWidthCalculator(
+            rows: model.rows,
+            databaseType: model.configuration.traits.databaseType,
+            nullDisplayString: presenter.registry.nullDisplayString,
+            revealsInvisibleCharacters: presenter.registry.showsInvisibleCharacters,
+            fonts: ThemeEngine.shared.dataGridFonts
+        )
+    }
+
+    func widthInput(for column: DataGridColumn) -> DataGridColumnWidthCalculator.Input {
+        DataGridColumnWidthCalculator.Input(
+            column: column,
+            accessory: presenter.presentation(forDataIndex: column.dataIndex).accessory,
+            displayFormat: model.displayFormat(for: column)
+        )
+    }
+
+    private var visibleGridWidth: CGFloat {
+        main.scrollView.contentView.bounds.width
+    }
+
+    func fittedWidth(for column: DataGridColumn, fittedColumnCount: Int = 1) -> CGFloat {
+        widthCalculator().fittedWidth(widthInput(for: column), availableWidth: visibleGridWidth, fittedColumnCount: fittedColumnCount)
+    }
+
+    // Size to Fit, from the loaded display strings; written to the model as a width the user chose.
+    func sizeColumnToFit(_ column: DataGridColumn) {
+        setWidths([column.id: fittedWidth(for: column)])
+    }
+
+    func sizeAllColumnsToFit() {
+        let columns = model.columns.columns
+        let calculator = widthCalculator()
+        var widths: [DataGridColumnID: CGFloat] = [:]
+        for column in columns {
+            widths[column.id] = calculator.fittedWidth(
+                widthInput(for: column),
+                availableWidth: visibleGridWidth,
+                fittedColumnCount: columns.count
+            )
+        }
+        setWidths(widths)
+    }
+
+    private func setWidths(_ widths: [DataGridColumnID: CGFloat]) {
+        isRebuildingColumns = true
+        var named: [String: CGFloat] = [:]
+        for (id, width) in widths {
+            for pane in panes {
+                pane.tableColumn(for: id)?.width = width
+            }
+            if let column = main.tableColumn(for: id) {
+                named[id.name] = column.width
+                savedWidthIDs.insert(id)
+                knownWidths[id] = column.width
+            }
+        }
+        isRebuildingColumns = false
+        geometryDidChange()
+        model.columnGeometryDidChange(widths: named, order: nil)
+    }
+
+    // MARK: - Geometry from the user
+
+    func columnDidResize(_ tableColumn: NSTableColumn, in pane: DataGridPane) {
+        guard !isRebuildingColumns, let id = pane.columnID(of: tableColumn) else { return }
+        if pane.kind == .frozen, let mainColumn = main.tableColumn(for: id), mainColumn.width != tableColumn.width {
+            isRebuildingColumns = true
+            mainColumn.width = tableColumn.width
+            isRebuildingColumns = false
+        }
+        savedWidthIDs.insert(id)
+        knownWidths[id] = tableColumn.width
+        if resolveEffectiveFrozenCount() != effectiveFrozenCount {
+            updateFrozenPane()
+        }
+        geometryDidChange()
+        model.columnGeometryDidChange(widths: [id.name: tableColumn.width], order: nil)
+    }
+
+    func columnDidMove(from oldIndex: Int, to newIndex: Int, in pane: DataGridPane) {
+        guard !isRebuildingColumns else { return }
+        if pane.kind == .frozen {
+            isRebuildingColumns = true
+            main.tableView.moveColumn(oldIndex, toColumn: newIndex)
+            isRebuildingColumns = false
+        }
+        let order = main.tableView.tableColumns.compactMap { main.columnID(of: $0)?.name }
+        panes.forEach { $0.invalidateSlots() }
+        geometryDidChange()
+        model.columnGeometryDidChange(widths: [:], order: order)
+    }
+
+    // The body has no cell views for AppKit to relay out, so every width, order or freeze step repaints it (#2449).
+    func geometryDidChange() {
+        if !frozen.tableView.tableColumns.isEmpty {
+            container.frozenPaneWidth = frozen.columnsWidth
+        }
+        for pane in panes {
+            pane.tableView.setNeedsDisplay(pane.tableView.visibleRect)
+        }
+        redrawVisibleRows()
+        updateReorderToolTip()
+    }
+
+    func tableDidMoveColumn(_ table: DataGridTableView) {
+        container.pane(of: table)?.invalidateSlots()
+        guard !isRebuildingColumns else { return }
+        redrawVisibleRows()
+    }
+
+    // A frozen column resized in its own header carries the main pane's copy with it on every step.
+    func headerGeometryDidStep(in kind: DataGridPane.Kind) {
+        if kind == .frozen {
+            isRebuildingColumns = true
+            for tableColumn in frozen.tableView.tableColumns {
+                guard let id = frozen.columnID(of: tableColumn),
+                      let mainColumn = main.tableColumn(for: id),
+                      mainColumn.width != tableColumn.width else { continue }
+                mainColumn.width = tableColumn.width
+            }
+            isRebuildingColumns = false
+        }
+        geometryDidChange()
+    }
+
+    func shouldReorderColumn(_ index: Int, to newIndex: Int, in pane: DataGridPane) -> Bool {
+        let table = pane.tableView
+        guard table.tableColumns.indices.contains(index), !pane.isRowNumber(table.tableColumns[index]) else { return false }
+        let leading = pane.hasRowNumberColumn ? 1 : 0
+        switch pane.kind {
+        case .main:
+            // Columns under the frozen pane move in the frozen header, never in this one.
+            let firstMovable = leading + effectiveFrozenCount
+            guard index >= firstMovable else { return false }
+            return newIndex < 0 || newIndex >= firstMovable
+        case .frozen:
+            return newIndex < 0 || newIndex >= leading
+        }
+    }
+
+    // MARK: - Frozen pane edge
+
+    // A 1 pt separator after the row numbers alone, a 2 pt divider once columns are frozen.
+    func drawFrozenPaneEdge(in rect: NSRect, of view: NSView) {
+        let table = frozen.tableView
+        guard !table.tableColumns.isEmpty else { return }
+        let thickness = effectiveFrozenCount > 0 ? DataGridMetrics.frozenDividerThickness : DataGridBodyChrome.separatorThickness
+        let edge = view.convert(NSRect(x: frozen.columnsWidth - thickness, y: 0, width: thickness, height: 1), from: table)
+        let divider = NSRect(x: edge.minX, y: rect.minY, width: thickness, height: rect.height)
+        guard divider.intersects(rect) else { return }
+        table.gridColor.setFill()
+        divider.fill()
+    }
+
+    // MARK: - Reveal
+
+    // Widened leftward by the frozen pane, so a revealed column never parks beneath it; a frozen column is always shown.
+    func revealRect(for rect: NSRect, in table: DataGridTableView) -> NSRect {
+        let frozenWidth = frozen.scrollView.isHidden ? 0 : container.frozenPaneWidth
+        guard frozenWidth > 0 else { return rect }
+        let visible = table.visibleRect
+        if rect.maxX <= frozenWidth {
+            return NSRect(x: visible.minX, y: rect.minY, width: min(rect.width, visible.width), height: rect.height)
+        }
+        guard rect.width < visible.width - frozenWidth else { return rect }
+        return NSRect(x: rect.minX - frozenWidth, y: rect.minY, width: rect.width + frozenWidth, height: rect.height)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+Drawing.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+Drawing.swift
new file mode 100644
index 0000000000..c9cfeb609e
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+Drawing.swift
@@ -0,0 +1,157 @@
+//
+//  DataGridViewController+Drawing.swift
+//  TablePro
+//
+
+import AppKit
+
+extension DataGridViewController {
+    // The full row in a whole-row selection, else the selected columns' span: NSTableView selects rows, not rectangles.
+    func selectionRects(forRow row: Int, in table: DataGridTableView, within tableRect: NSRect) -> [NSRect] {
+        guard row >= 0, let pane = container.pane(of: table) else { return [] }
+        let columns = model.columns
+        let selected = model.selection.columns(in: row)
+        guard !selected.isEmpty, !columns.isEmpty else { return [] }
+        if selected.contains(integersIn: 0..<columns.count) {
+            return [table.rect(ofRow: row)]
+        }
+        return table.columnIndexes(in: tableRect).compactMap { index in
+            guard case .data(let id)? = pane.slot(atTableIndex: index, columns: columns),
+                  let position = columns.displayPosition(of: id),
+                  selected.contains(position) else { return nil }
+            return table.rect(ofColumn: index)
+        }
+    }
+
+    func drawCells(ofRow row: Int, in dirtyRect: NSRect, of view: NSView, table: DataGridTableView, isEmphasized: Bool) {
+        guard row >= 0, let pane = container.pane(of: table),
+              let pass = presenter.makePass(in: NSAppearance.currentDrawing()),
+              let rowModel = model.order.row(at: row, in: pass.rows) else { return }
+        let columns = model.columns
+        let visualState = presenter.visualState(of: rowModel)
+        let selected = pass.selection.columns(in: row)
+        let line = DrawnRow(
+            row: row,
+            model: rowModel,
+            visualState: visualState,
+            selected: selected,
+            isWholeRow: !columns.isEmpty && selected.contains(integersIn: 0..<columns.count),
+            isEmphasized: isEmphasized,
+            pass: pass
+        )
+        let dragged = Self.draggedColumnIndex(of: table)
+        for index in table.columnIndexes(in: view.convert(dirtyRect, to: table)) where index != dragged {
+            drawCell(atTableIndex: index, in: table.rect(ofColumn: index), of: view, table: table, pane: pane, line: line)
+        }
+        // After every cell: a cell fills its whole rect for a tint and would paint over a line drawn beside it.
+        DataGridBodyChrome.drawColumnSeparators(in: dirtyRect, of: view, tableView: table)
+        if let dragged {
+            drawDraggedColumn(dragged, in: dirtyRect, of: view, table: table, pane: pane, line: line)
+        }
+        drawActiveCellBorder(of: view, table: table, pane: pane, line: line)
+        if pane.kind == .frozen {
+            drawFrozenPaneEdge(in: dirtyRect, of: view)
+        }
+    }
+
+    private struct DrawnRow {
+        let row: Int
+        let model: Row
+        let visualState: RowVisualState
+        let selected: IndexSet
+        let isWholeRow: Bool
+        let isEmphasized: Bool
+        let pass: DataGridCellPresenter.Pass
+    }
+
+    private func drawCell(
+        atTableIndex index: Int,
+        in rectInTable: NSRect,
+        of view: NSView,
+        table: DataGridTableView,
+        pane: DataGridPane,
+        line: DrawnRow
+    ) {
+        let columnRect = view.convert(rectInTable, from: table)
+        let cellRect = NSRect(x: columnRect.minX, y: 0, width: columnRect.width, height: view.bounds.height)
+        switch pane.slot(atTableIndex: index, columns: model.columns) {
+        case .rowNumber:
+            let number = (model.dataSource?.gridRowNumberOffset ?? 0) + line.row + 1
+            presenter.renderer.drawRowNumber(
+                number,
+                in: cellRect,
+                font: line.pass.palette.rowNumberFont,
+                color: line.pass.palette.rowNumberColor(
+                    for: line.visualState,
+                    onEmphasizedSelection: line.isWholeRow && line.isEmphasized
+                )
+            )
+        case .data(let id):
+            guard let position = model.columns.displayPosition(of: id),
+                  let column = model.columns.column(at: position),
+                  editedCell != GridCoord(row: line.row, displayColumn: position),
+                  let appearance = presenter.appearance(
+                      of: line.model,
+                      displayRow: line.row,
+                      column: column,
+                      visualState: line.visualState,
+                      pass: line.pass,
+                      onEmphasizedSelection: line.isEmphasized && line.selected.contains(position)
+                  ) else { return }
+            presenter.renderer.draw(appearance, in: cellRect, controlView: view)
+        case nil:
+            return
+        }
+    }
+
+    // The column a header drag is moving, drawn at the pointer over its neighbours, the way AppKit floats cell views.
+    private func drawDraggedColumn(
+        _ dragged: Int,
+        in dirtyRect: NSRect,
+        of view: NSView,
+        table: DataGridTableView,
+        pane: DataGridPane,
+        line: DrawnRow
+    ) {
+        guard let distance = table.headerView?.draggedDistance,
+              let context = NSGraphicsContext.current?.cgContext else { return }
+        let floating = table.rect(ofColumn: dragged).offsetBy(dx: distance, dy: 0)
+        guard floating.intersects(view.convert(dirtyRect, to: table)) else { return }
+        context.saveGState()
+        context.setAlpha(Self.draggedColumnAlpha)
+        context.beginTransparencyLayer(auxiliaryInfo: nil)
+        drawCell(atTableIndex: dragged, in: floating, of: view, table: table, pane: pane, line: line)
+        context.endTransparencyLayer()
+        context.restoreGState()
+    }
+
+    // The alphaValue AppKit gives a floated column's cell views, measured on macOS 27; AppKit does not publish it.
+    private static let draggedColumnAlpha: CGFloat = 0.6
+
+    private static func draggedColumnIndex(of table: NSTableView) -> Int? {
+        guard let dragged = table.headerView?.draggedColumn, dragged >= 0, dragged < table.numberOfColumns else { return nil }
+        return dragged
+    }
+
+    // An inner stroke, 2 pt while the grid has focus and 1 pt otherwise: a focus ring from a row view loses its top
+    // and bottom (critic B M5). On an emphasized fill it takes the selected text color, which stays visible there.
+    private func drawActiveCellBorder(of view: NSView, table: DataGridTableView, pane: DataGridPane, line: DrawnRow) {
+        guard let active = line.pass.selection.activeCell, active.row == line.row,
+              editedCell != active,
+              let index = pane.tableIndex(forDisplayPosition: active.displayColumn, columns: model.columns) else { return }
+        let columnRect = view.convert(table.rect(ofColumn: index), from: table)
+        let lineWidth: CGFloat = gridHasFocus ? 2 : 1
+        let cellRect = NSRect(
+            x: columnRect.minX,
+            y: 0,
+            width: max(0, columnRect.width - table.intercellSpacing.width),
+            height: view.bounds.height
+        )
+        let onFill = line.isEmphasized && line.selected.contains(active.displayColumn)
+        let color = onFill ? line.pass.palette.selectionText : NSColor.keyboardFocusIndicatorColor
+        let path = NSBezierPath(rect: cellRect.insetBy(dx: lineWidth / 2, dy: lineWidth / 2))
+        path.lineWidth = lineWidth
+        color.setStroke()
+        path.stroke()
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+Editing.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+Editing.swift
new file mode 100644
index 0000000000..67a2942f6b
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+Editing.swift
@@ -0,0 +1,155 @@
+//
+//  DataGridViewController+Editing.swift
+//  TablePro
+//
+
+import AppKit
+
+@MainActor
+final class DataGridEditingState {
+    var session: DataGridEditSession?
+    var suspendedField: DataGridSuspendedFieldEdit?
+    var deferredCommit: (session: DataGridEditSession, text: String)?
+    var isApplyingChange = false
+    var isEndingField = false
+
+    lazy var editingCellView = DataGridEditingCellView(frame: .zero)
+    let fieldDelegate = DataGridFieldEditorDelegate()
+
+    var textPopover: DataGridTextEditorPopover?
+
+    var typedPopover: NSPopover?
+    var typedPopoverRow: DataGridHeldRow?
+    var typedPopoverPane: DataGridPane.Kind = .main
+    var typedPopoverEdits = false
+    let typedPopoverObserver = DataGridPopoverCloseObserver()
+
+    weak var poppedOutEditor: JSONViewerWindowController?
+    var poppedOutRow: DataGridHeldRow?
+
+    var foreignKeyPreview: NSPopover?
+    var foreignKeyPreviewModel: FKPreviewModel?
+    var foreignKeyPreviewColumn: DataGridColumnID?
+    var foreignKeyPreviewPane: DataGridPane.Kind = .main
+}
+
+extension DataGridViewController {
+    var isEditingCell: Bool {
+        let state = editingState
+        if state.session != nil || state.suspendedField != nil { return true }
+        return state.typedPopoverEdits && state.typedPopover != nil
+    }
+
+    var editedCell: GridCoord? {
+        guard let session = editingState.session, session.editor == .field else { return nil }
+        return session.cell
+    }
+
+    func editingCellView(in pane: DataGridPane, tableColumn: NSTableColumn, row: Int) -> NSView? {
+        guard let session = editingState.session,
+              session.editor == .field,
+              session.pane == pane.kind,
+              session.cell.row == row,
+              pane.columnID(of: tableColumn) == session.target.columnID else { return nil }
+        return editingState.editingCellView
+    }
+
+    @discardableResult
+    func beginEditingCell(row: Int, displayColumn: Int) -> Bool {
+        let coord = GridCoord(row: row, displayColumn: displayColumn)
+        guard let cell = editCell(at: coord) else { return false }
+        if model.selection.activeCell != coord || model.selection.hasMultipleCells {
+            model.selectCell(coord)
+            mirrorSelection()
+        }
+        reveal(row: row, displayColumn: displayColumn)
+        let target = cell.target
+        guard loadsUnloadedValue(of: cell, then: { $0.beginTextEditing(for: target) }) else { return false }
+        return beginTextEditing(cell)
+    }
+
+    func beginEditingActiveCell() {
+        guard let active = model.selection.activeCell else { return }
+        reveal(row: active.row, displayColumn: active.displayColumn)
+        openEditor(at: active)
+    }
+
+    func commitCellEditing() -> Bool {
+        var committed = true
+        if let session = editingState.session {
+            switch session.editor {
+            case .field:
+                committed = finishFieldEditing(commit: true)
+            case .textPopover:
+                committed = finishTextPopover(.commit(nil))
+            }
+        }
+        flushDeferredCommit()
+        closeCellPopovers()
+        return committed
+    }
+
+    func discardCellEditing() {
+        editingState.deferredCommit = nil
+        if let session = editingState.session {
+            switch session.editor {
+            case .field:
+                finishFieldEditing(commit: false)
+            case .textPopover:
+                finishTextPopover(.cancel)
+            }
+        }
+        closeCellPopovers()
+    }
+
+    func handleCellDoubleClick(at cell: GridCoord) {
+        openEditor(at: cell)
+    }
+
+    func handleClickOnActiveCell(_ cell: GridCoord) {
+        guard let clicked = editCell(at: cell), textEditableValue(of: clicked) != nil else { return }
+        openEditor(at: cell)
+    }
+
+    func handleForeignKeyArrowClick(at cell: GridCoord, opensNewTab: Bool) {
+        followForeignKey(at: cell, opensNewTab: opensNewTab)
+    }
+
+    func handleChevronClick(at cell: GridCoord) {
+        openChevronEditor(at: cell)
+    }
+
+    func toggleForeignKeyPreview() {
+        if editingState.foreignKeyPreview?.isShown == true {
+            closeForeignKeyPreview()
+            return
+        }
+        guard let active = model.selection.activeCell else { return }
+        previewForeignKey(at: active)
+    }
+
+    func editingSelectionDidChange() {
+        followActiveCellWithForeignKeyPreview()
+    }
+
+    func editingWillApply(_ change: DataGridChange) {
+        editingState.isApplyingChange = true
+        guard change.isStructural else { return }
+        suspendFieldEditing(unmounting: change != .reload)
+    }
+
+    func editingDidApply(_ change: DataGridChange) {
+        editingState.isApplyingChange = false
+        flushDeferredCommit()
+        guard change.isStructural else { return }
+        resumeFieldEditing()
+        followRowChangesWithPopovers()
+    }
+}
+
+extension DataGridChange {
+    var isStructural: Bool {
+        if case .rowsUpdated = self { return false }
+        return true
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+Header.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+Header.swift
new file mode 100644
index 0000000000..74d65806b3
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+Header.swift
@@ -0,0 +1,267 @@
+//
+//  DataGridViewController+Header.swift
+//  TablePro
+//
+
+import AppKit
+
+extension DataGridViewController {
+    // The sort entries the current result carries a column for, resolved by name: a stale index would put the
+    // indicator on whichever column moved into the slot.
+    func presentedSortEntries() -> [(column: DataGridColumn, direction: SortDirection)] {
+        guard model.configuration.supportsColumnSort else { return [] }
+        let names = model.rows.columns
+        let columns = model.columns
+        return model.store.sortState.columns.compactMap { sortColumn -> (column: DataGridColumn, direction: SortDirection)? in
+            guard let name = SortColumnResolver.columnName(for: sortColumn, displayColumns: names) else { return nil }
+            let dataIndex: Int
+            if sortColumn.columnIndex >= 0, sortColumn.columnIndex < names.count, names[sortColumn.columnIndex] == name {
+                dataIndex = sortColumn.columnIndex
+            } else if let found = names.firstIndex(of: name) {
+                dataIndex = found
+            } else {
+                return nil
+            }
+            guard let position = columns.displayPosition(ofDataIndex: dataIndex),
+                  let column = columns.column(at: position) else { return nil }
+            return (column: column, direction: sortColumn.direction)
+        }
+    }
+
+    // The model's sort is the source; tableView.sortDescriptors follows it under a guard, since assigning inside the
+    // callback re-enters it once (probe P5b).
+    func sortDidChange() {
+        syncSortIndicators()
+    }
+
+    func summaryRulesDidChange() {
+        selectionSummaryTracker.rulesDidChange()
+    }
+
+    func syncSortIndicators() {
+        let descriptors = presentedSortEntries().map {
+            NSSortDescriptor(key: $0.column.id.stringValue, ascending: $0.direction == .ascending)
+        }
+        isApplyingSortDescriptors = true
+        for pane in panes {
+            let current = pane.tableView.sortDescriptors
+            let same = current.count == descriptors.count
+                && zip(current, descriptors).allSatisfy { $0.key == $1.key && $0.ascending == $1.ascending }
+            if !same {
+                pane.tableView.sortDescriptors = descriptors
+            }
+        }
+        isApplyingSortDescriptors = false
+        refreshHeaders()
+    }
+
+    func headerPressed(_ tableColumn: NSTableColumn, in pane: DataGridPane) {
+        pendingHeaderPress = (pane.kind, tableColumn.identifier)
+    }
+
+    // AppKit already put the clicked key first; a plain click keeps only it, Option-click keeps AppKit's appended key.
+    func sortDescriptorsDidChange(in pane: DataGridPane) {
+        guard !isApplyingSortDescriptors, model.configuration.supportsColumnSort else { return }
+        let column = clickedSortColumn(in: pane)
+        pendingHeaderPress = nil
+        guard let column else {
+            syncSortIndicators()
+            return
+        }
+        let addsKey = NSApp.currentEvent?.modifierFlags.contains(.option) == true
+        let current = SortColumnResolver.reindexed(model.store.sortState, displayColumns: model.rows.columns)
+        let transition = HeaderSortCycle.nextTransition(
+            state: current,
+            clickedColumn: column.dataIndex,
+            isMultiSort: addsKey,
+            firstClickDirection: firstClickSortDirection
+        )
+        model.setSort(SortColumnResolver.stamped(transition.newState, displayColumns: model.rows.columns))
+        syncSortIndicators()
+    }
+
+    private func clickedSortColumn(in pane: DataGridPane) -> DataGridColumn? {
+        if let press = pendingHeaderPress,
+           let tableColumn = container.pane(press.kind).tableView.tableColumns.first(where: { $0.identifier == press.identifier }),
+           let id = container.pane(press.kind).columnID(of: tableColumn) {
+            return model.columns.column(id: id)
+        }
+        guard let key = pane.tableView.sortDescriptors.first?.key else { return nil }
+        return model.columns.columns.first { $0.id.stringValue == key }
+    }
+
+    // Command-click selects the whole column; Shift and Command reach no sort callback at all (critic B M1).
+    func headerClicked(_ tableColumn: NSTableColumn, in pane: DataGridPane) {
+        guard let event = NSApp.currentEvent, event.modifierFlags.contains(.command),
+              let id = pane.columnID(of: tableColumn),
+              let position = model.columns.displayPosition(of: id) else { return }
+        var modifiers: GridPointerModifiers = .command
+        if event.modifierFlags.contains(.shift) {
+            modifiers.insert(.shift)
+        }
+        let next = GridSelectionReducer.columnHeaderCommandClick(
+            model.selection,
+            column: position,
+            modifiers: modifiers,
+            in: selectionContext
+        )
+        model.setSelection(next)
+        mirrorSelection()
+        focus()
+    }
+
+    // Where a popover about a column points: its heading, in the pane that shows it, scrolled into view first.
+    func anchor(forColumn displayColumn: Int) -> (view: NSView, rect: NSRect)? {
+        let pane = displayColumn < effectiveFrozenCount ? frozen : main
+        guard let index = pane.tableIndex(forDisplayPosition: displayColumn, columns: model.columns) else { return nil }
+        if pane.isMain {
+            revealColumn(displayColumn)
+        }
+        return (pane.headerView, pane.headerView.headerRect(ofColumn: index))
+    }
+
+    // MARK: - Header
+
+    // Titles, the value-filter funnel, tooltips and sort accessibility for every column of both panes.
+    func refreshHeaders() {
+        let columns = model.columns
+        let filter = model.store.valueFilter
+        let sortEntries = presentedSortEntries()
+        let showsComments = AppSettingsManager.shared.general.showObjectComments
+        var sortIndex: [DataGridColumnID: (direction: SortDirection, priority: Int)] = [:]
+        for (priority, entry) in sortEntries.enumerated() {
+            sortIndex[entry.column.id] = (entry.direction, priority + 1)
+        }
+        for pane in panes {
+            for tableColumn in pane.tableView.tableColumns {
+                guard let id = pane.columnID(of: tableColumn), let column = columns.column(id: id) else { continue }
+                let sort = sortIndex[id]
+                applyHeaderTitle(
+                    to: tableColumn,
+                    column: column,
+                    isFiltered: model.configuration.supportsValueFilter && filter.isActive(column: column.dataIndex)
+                )
+                let tooltip = headerToolTip(
+                    for: column,
+                    showsComment: showsComments,
+                    sort: sort,
+                    sortKeyCount: sortEntries.count
+                )
+                if tableColumn.headerToolTip != tooltip {
+                    tableColumn.headerToolTip = tooltip
+                }
+                let cell = tableColumn.headerCell
+                let label = headerAccessibilityLabel(for: column, showsComment: showsComments)
+                if cell.accessibilityLabel() != label {
+                    cell.setAccessibilityLabel(label)
+                }
+                // sortDescriptors reaches no accessibility client: the header cell's direction stays unknown (#2381 era).
+                cell.setAccessibilitySortDirection(Self.accessibilitySortDirection(sort?.direction))
+            }
+            pane.headerView.needsDisplay = true
+        }
+    }
+
+    private func applyHeaderTitle(to tableColumn: NSTableColumn, column: DataGridColumn, isFiltered: Bool) {
+        let cell = tableColumn.headerCell
+        guard isFiltered else {
+            if cell.stringValue != column.name {
+                tableColumn.title = column.name
+            }
+            return
+        }
+        let font = cell.font ?? .systemFont(ofSize: NSFont.smallSystemFontSize)
+        let paragraph = NSMutableParagraphStyle()
+        paragraph.lineBreakMode = .byTruncatingTail
+        paragraph.alignment = cell.alignment
+        let attributes: [NSAttributedString.Key: Any] = [
+            .font: font,
+            .foregroundColor: NSColor.headerTextColor,
+            .paragraphStyle: paragraph,
+        ]
+        let title = NSMutableAttributedString(string: column.name + " ", attributes: attributes)
+        if let funnel = Self.filterFunnel(for: font) {
+            let attachment = NSAttributedString(attachment: funnel)
+            let marked = NSMutableAttributedString(attributedString: attachment)
+            marked.addAttributes(attributes, range: NSRange(location: 0, length: marked.length))
+            title.append(marked)
+        }
+        cell.attributedStringValue = title
+    }
+
+    // Drawn in the header's own text color, so the funnel never turns white on an inactive selection (F1).
+    private static func filterFunnel(for font: NSFont) -> NSTextAttachment? {
+        let configuration = NSImage.SymbolConfiguration(pointSize: font.pointSize, weight: .regular)
+            .applying(.init(hierarchicalColor: .headerTextColor))
+        guard let image = NSImage(
+            systemSymbolName: "line.3.horizontal.decrease.circle.fill",
+            accessibilityDescription: String(localized: "Filtered")
+        )?.withSymbolConfiguration(configuration) else { return nil }
+        let attachment = NSTextAttachment()
+        attachment.image = image
+        let size = image.size
+        attachment.bounds = NSRect(x: 0, y: (font.capHeight - size.height) / 2, width: size.width, height: size.height)
+        return attachment
+    }
+
+    private func headerToolTip(
+        for column: DataGridColumn,
+        showsComment: Bool,
+        sort: (direction: SortDirection, priority: Int)?,
+        sortKeyCount: Int
+    ) -> String {
+        var tooltip: String
+        if let typeName = column.type?.rawType ?? column.type?.displayName {
+            tooltip = column.name + " (" + typeName + ")"
+        } else {
+            tooltip = column.name
+        }
+        if showsComment, let comment = Self.displayableComment(column.comment) {
+            tooltip += "\n" + comment
+        }
+        if let sort, sortKeyCount > 1 {
+            tooltip += "\n" + String(
+                format: String(localized: "Sort key %d of %d, %@"),
+                sort.priority,
+                sortKeyCount,
+                sort.direction.displayName
+            )
+        }
+        return tooltip
+    }
+
+    private func headerAccessibilityLabel(for column: DataGridColumn, showsComment: Bool) -> String {
+        let label = String(format: String(localized: "Column: %@"), column.name)
+        guard showsComment, let comment = Self.displayableComment(column.comment) else { return label }
+        return label + ", " + comment
+    }
+
+    private static func displayableComment(_ comment: String?) -> String? {
+        guard let trimmed = comment?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else { return nil }
+        return trimmed
+    }
+
+    private static func accessibilitySortDirection(_ direction: SortDirection?) -> NSAccessibilitySortDirection {
+        switch direction {
+        case .ascending: return .ascending
+        case .descending: return .descending
+        case nil: return .unknown
+        }
+    }
+
+    // A whole column picked by its heading highlights that heading in whichever pane shows it.
+    func updateHighlightedColumns(_ selection: GridSelection) {
+        let picked = selection.activeCell.flatMap { selection.columns.contains($0.displayColumn) ? $0.displayColumn : nil }
+            ?? selection.columns.first
+        let id = picked.flatMap { model.columns.column(at: $0)?.id }
+        for pane in panes {
+            let column = id.flatMap { pane.tableColumn(for: $0) }
+            let attached = column.flatMap { candidate in
+                pane.tableView.tableColumns.contains { $0 === candidate } ? candidate : nil
+            }
+            if pane.tableView.highlightedTableColumn !== attached {
+                pane.tableView.highlightedTableColumn = attached
+            }
+        }
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+Menus.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+Menus.swift
new file mode 100644
index 0000000000..022f1e79bd
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+Menus.swift
@@ -0,0 +1,135 @@
+//
+//  DataGridViewController+Menus.swift
+//  TablePro
+//
+
+import AppKit
+
+@MainActor
+final class DataGridMenuState {
+    let loader = DataGridValueLoader()
+    var valueFilterPopover: NSPopover?
+}
+
+extension DataGridViewController {
+    var gridCommands: DataGridCommands {
+        DataGridCommands(model: model, loader: menuState.loader)
+    }
+
+    // A context menu item carries the scope it was built over; the menu bar acts on the selection.
+    func commandScope(for sender: Any?) -> DataGridCommandScope {
+        if let item = sender as? NSMenuItem {
+            if let context = item.representedObject as? DataGridMenuContext {
+                return context.scope(in: model)
+            }
+            if let choice = item.representedObject as? DataGridSetValueChoice {
+                return choice.context.scope(in: model)
+            }
+        }
+        return .current(model.selection)
+    }
+
+    // Context menu for a row; displayColumn is nil over the row numbers. Built from clickedRow and clickedColumn.
+    func rowMenu(forRow row: Int, displayColumn: Int?, in pane: DataGridPane.Kind) -> NSMenu? {
+        buildRowMenu(row: row, displayColumn: displayColumn)
+    }
+
+    func headerMenu(for column: DataGridColumn) -> NSMenu? {
+        buildHeaderMenu(for: column)
+    }
+
+    func emptySpaceMenu() -> NSMenu? {
+        model.actions?.gridEmptySpaceMenu()
+    }
+
+    // Delete and Forward Delete mark every row the selection touches; a grid that deletes nothing beeps.
+    func performDeleteCommand() {
+        let scope = DataGridCommandScope.current(model.selection)
+        guard gridCommands.canDelete(scope) else {
+            NSSound.beep()
+            return
+        }
+        guard commitCellEditing() else { return }
+        gridCommands.deleteRows(scope)
+    }
+
+    // A double-click below the last row.
+    func handleDoubleClickBelowRows() {
+        guard model.configuration.isEditable, gridCommands.offers(.addRow), commitCellEditing() else { return }
+        model.actions?.gridAddRow()
+    }
+
+    func performSelectAll(_ sender: Any?) {
+        let context = selectionContext
+        guard !context.isEmpty else { return }
+        model.setSelection(GridSelectionReducer.selectAll(model.selection, in: context))
+        mirrorSelection()
+    }
+
+    // MARK: - Standard edit actions
+
+    @objc func copy(_ sender: Any?) {
+        gridCommands.copy(commandScope(for: sender))
+    }
+
+    // The context menu's Paste and Command-V take this one path (interaction 4).
+    @objc func paste(_ sender: Any?) {
+        let scope = commandScope(for: sender)
+        guard commitCellEditing() else { return }
+        gridCommands.paste(scope)
+    }
+
+    @objc func delete(_ sender: Any?) {
+        let scope = commandScope(for: sender)
+        guard gridCommands.canDelete(scope), commitCellEditing() else { return }
+        gridCommands.deleteRows(scope)
+    }
+
+    // MARK: - Validation
+
+    // Validation for the grid's own commands; nil leaves an item to its responder's default.
+    func validateGridCommand(_ item: NSValidatedUserInterfaceItem) -> Bool? {
+        guard let action = item.action else { return nil }
+        let commands = gridCommands
+        let scope = commandScope(for: item)
+        let appliesRowFormat = model.configuration.appliesRowCopyFormat
+        switch action {
+        case #selector(copy(_:)), #selector(GridRowCopyCommandResponding.copySelectedRows(_:)):
+            return commands.canCopy(scope)
+        case #selector(paste(_:)):
+            return commands.canPaste(scope)
+        case #selector(delete(_:)):
+            return commands.canDelete(scope)
+        case #selector(NSTableView.selectAll(_:)):
+            return !selectionContext.isEmpty
+        case #selector(GridCopyCommandResponding.copyCellValue(_:)):
+            return commands.focusCell(scope) != nil
+        case #selector(GridRowCopyCommandResponding.copyRowsWithHeaders(_:)),
+             #selector(GridRowCopyCommandResponding.copyRowsAsJson(_:)),
+             #selector(GridCopyCommandResponding.copyRowsAsCsv(_:)),
+             #selector(GridCopyCommandResponding.copyRowsAsCsvWithHeaders(_:)),
+             #selector(GridCopyCommandResponding.copyRowsAsMarkdown(_:)):
+            return appliesRowFormat && commands.canCopy(scope)
+        case #selector(GridCopyCommandResponding.copyRowsAsInClause(_:)):
+            return appliesRowFormat && commands.canCopy(scope) && commands.inClauseColumn(scope) != nil
+        case #selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:)):
+            return appliesRowFormat && commands.canCopyAsInsert(scope)
+        case #selector(GridCopyCommandResponding.copyRowsAsUpdateStatements(_:)):
+            return appliesRowFormat && commands.canCopyAsUpdate(scope)
+        case #selector(SetValueCommandResponding.setCellsToValue(_:)):
+            return commands.isSetCellsToValueOffered(for: commands.cells(scope))
+        default:
+            if let command = Self.setValueCommand(for: action) {
+                return commands.isSetValueOffered(command, for: commands.cells(scope))
+            }
+            // The menus build these items only where they apply.
+            return Self.contextMenuActions.contains(action) ? true : nil
+        }
+    }
+}
+
+extension DataGridViewController: NSMenuItemValidation {
+    func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
+        validateEditingCommand(menuItem) ?? validateFindCommand(menuItem) ?? validateGridCommand(menuItem) ?? true
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+Selection.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+Selection.swift
new file mode 100644
index 0000000000..7728930d6a
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+Selection.swift
@@ -0,0 +1,393 @@
+//
+//  DataGridViewController+Selection.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+extension DataGridViewController {
+    var selectionContext: GridSelectionContext {
+        GridSelectionContext(rowCount: model.rowCount, columnCount: model.columns.count)
+    }
+
+    // Every rectangle spans all columns: AppKit's own row movement and type-select then drive it.
+    var selectionIsCellRange: Bool {
+        let selection = model.selection
+        return !selection.isEmpty && selection.mode == .cells
+    }
+
+    // MARK: - Model to tables
+
+    func selectionDidChange() {
+        let previous = drawnSelection
+        let current = model.selection
+        drawnSelection = current
+        mirrorSelection()
+        repaintSelection(from: previous, to: current)
+        updateHighlightedColumns(current)
+        postSelectionAccessibility(from: previous, to: current)
+        selectionSummaryTracker.selectionDidChange()
+        editingSelectionDidChange()
+    }
+
+    // A change that kept the selection on its records moved it; nothing to announce, only to repaint.
+    func selectionDidMove() {
+        let previous = drawnSelection
+        let current = model.selection
+        guard previous != current else { return }
+        drawnSelection = current
+        repaintSelection(from: previous, to: current)
+        updateHighlightedColumns(current)
+        selectionSummaryTracker.selectionDidChange()
+    }
+
+    // Both tables hold the rows the selection spans; deferred while a structural change has not reached them yet.
+    func mirrorSelection() {
+        let rowCount = model.rowCount
+        guard panes.allSatisfy({ $0.tableView.numberOfRows == rowCount }) else { return }
+        let rows = model.selection.affectedRows.filteredIndexSet { $0 >= 0 && $0 < rowCount }
+        let wasMirroring = isMirroringSelection
+        isMirroringSelection = true
+        for pane in panes where pane.tableView.selectedRowIndexes != rows {
+            pane.tableView.selectRowIndexes(rows, byExtendingSelection: false)
+        }
+        isMirroringSelection = wasMirroring
+    }
+
+    private func repaintSelection(from previous: GridSelection, to current: GridSelection) {
+        var dirty = previous.affectedRows.union(current.affectedRows)
+        for cell in [previous.activeCell, current.activeCell].compactMap({ $0 }) {
+            dirty.insert(cell.row)
+        }
+        redrawRows(dirty)
+    }
+
+    // A native change in the main table (Up, Down, type-select) goes to the model first, then mirrors.
+    func tableSelectionDidChange(in pane: DataGridPane) {
+        guard !isMirroringSelection else { return }
+        let next = GridSelectionReducer.rowsSelectedNatively(
+            pane.tableView.selectedRowIndexes,
+            previous: model.selection,
+            in: selectionContext
+        )
+        model.setSelection(next)
+        mirrorSelection()
+    }
+
+    // MARK: - Keyboard
+
+    func moveSelection(_ direction: GridMoveDirection, extending: Bool, toEdge: Bool) {
+        applyKeyboardSelection(GridSelectionReducer.move(
+            model.selection,
+            direction,
+            extending: extending,
+            toEdge: toEdge,
+            in: selectionContext
+        ))
+    }
+
+    func moveToColumnEdge(last: Bool, extending: Bool) {
+        applyKeyboardSelection(GridSelectionReducer.moveToColumnEdge(
+            model.selection,
+            last: last,
+            extending: extending,
+            in: selectionContext
+        ))
+    }
+
+    // False leaves the grid through the key view loop: with no cell to start from, Tab has nowhere to go inside.
+    func tabToCell(forward: Bool) -> Bool {
+        let current = model.selection
+        guard current.activeCell != nil || current.anchor != nil || !current.isEmpty else { return false }
+        applyKeyboardSelection(GridSelectionReducer.tab(current, forward: forward, in: selectionContext))
+        return true
+    }
+
+    // Escape drops a range to its active cell, then the cell or rows to nothing; false passes the key on.
+    func cancelSelection() -> Bool {
+        let current = model.selection
+        guard !current.isEmpty else { return false }
+        let next = GridSelectionReducer.cancel(current, in: selectionContext)
+        model.setSelection(next)
+        if next.isEmpty {
+            let wasMirroring = isMirroringSelection
+            isMirroringSelection = true
+            panes.forEach { $0.tableView.deselectAll(nil) }
+            isMirroringSelection = wasMirroring
+        }
+        mirrorSelection()
+        return true
+    }
+
+    func widenSelectionToRows() {
+        applyKeyboardSelection(GridSelectionReducer.widenToRows(model.selection, in: selectionContext))
+    }
+
+    private func applyKeyboardSelection(_ next: GridSelection) {
+        model.setSelection(next)
+        mirrorSelection()
+        revealActiveCell()
+    }
+
+    // Shift+Space widens to rows; Space toggles the checkbox column where one exists, else previews the reference.
+    func handleGridKey(_ event: NSEvent) -> Bool {
+        let modifiers = event.modifierFlags.intersection([.command, .shift, .option, .control])
+        let isSpace = KeyCode(rawValue: event.keyCode) == .space
+        if isSpace, modifiers == .shift {
+            widenSelectionToRows()
+            return true
+        }
+        if isSpace, modifiers.isEmpty, !model.configuration.checkboxColumns.isEmpty, toggleCheckboxesForSelection() {
+            return true
+        }
+        if let shortcut = AppSettingsManager.shared.keyboard.shortcut(for: .previewFKReference),
+           !shortcut.isCleared,
+           shortcut.matches(event) {
+            toggleForeignKeyPreview()
+            return true
+        }
+        return false
+    }
+
+    // MARK: - Checkboxes
+
+    // Sets every selected checkbox the same way, the way a list of mail messages marks them: on unless all are on.
+    func toggleCheckboxesForSelection() -> Bool {
+        guard let dataIndex = model.configuration.checkboxColumns.min(),
+              let column = model.columns.columns.first(where: { $0.dataIndex == dataIndex }),
+              let dataSource = model.dataSource else { return false }
+        let states = model.selectedRowIDs.compactMap { rowID in
+            dataSource.gridCheckboxState(for: rowID, column: column).map { (rowID: rowID, isOn: $0) }
+        }
+        guard !states.isEmpty else { return false }
+        let everyRowChecked = states.allSatisfy { $0.isOn }
+        model.actions?.gridSetCheckbox(!everyRowChecked, rowIDs: states.map { $0.rowID }, column: column)
+        redrawRows(model.selection.affectedRows)
+        return true
+    }
+
+    @discardableResult
+    func toggleCheckbox(rowID: RowID, column: DataGridColumn, displayRow: Int) -> Bool {
+        guard let isOn = model.dataSource?.gridCheckboxState(for: rowID, column: column) else { return false }
+        model.actions?.gridSetCheckbox(!isOn, rowIDs: [rowID], column: column)
+        redrawRows(IndexSet(integer: displayRow))
+        return true
+    }
+
+    // MARK: - Reveal
+
+    func reveal(row: Int, displayColumn: Int?) {
+        let table = main.tableView
+        guard row >= 0, row < table.numberOfRows else { return }
+        table.scrollRowToVisible(row)
+        if let displayColumn {
+            revealColumn(displayColumn)
+        }
+    }
+
+    // Horizontal only; a frozen column is on screen at every offset.
+    func revealColumn(_ displayColumn: Int) {
+        let table = main.tableView
+        guard displayColumn >= effectiveFrozenCount,
+              let index = main.tableIndex(forDisplayPosition: displayColumn, columns: model.columns) else { return }
+        let columnRect = table.rect(ofColumn: index)
+        let visible = table.visibleRect
+        _ = table.scrollToVisible(NSRect(x: columnRect.minX, y: visible.midY, width: columnRect.width, height: 1))
+    }
+
+    func revealActiveCell() {
+        guard let active = model.selection.activeCell else { return }
+        reveal(row: active.row, displayColumn: active.displayColumn)
+    }
+
+    // MARK: - Pointer
+
+    private func pointerModifiers(_ event: NSEvent) -> GridPointerModifiers {
+        var modifiers: GridPointerModifiers = []
+        if event.modifierFlags.contains(.shift) { modifiers.insert(.shift) }
+        if event.modifierFlags.contains(.command) { modifiers.insert(.command) }
+        return modifiers
+    }
+
+    // A press in either pane resolves through the container and the column set to one global cell.
+    func tableMouseDown(_ table: DataGridTableView, with event: NSEvent) {
+        guard let pane = container.pane(of: table) else {
+            table.performNativeMouseDown(with: event)
+            return
+        }
+        view.window?.makeFirstResponder(main.tableView)
+        let point = table.convert(event.locationInWindow, from: nil)
+        let row = table.row(at: point)
+        let tableColumn = table.column(at: point)
+        let modifiers = pointerModifiers(event)
+
+        if event.clickCount == 2, row < 0 {
+            handleDoubleClickBelowRows()
+            return
+        }
+        guard row >= 0 else {
+            if event.clickCount == 1, modifiers.isEmpty {
+                model.clearSelection()
+                mirrorSelection()
+            }
+            return
+        }
+        guard tableColumn >= 0, let slot = pane.slot(atTableIndex: tableColumn, columns: model.columns) else {
+            // Past the last column the press lands on the row, which AppKit selects and tracks as in any table.
+            if modifiers.isEmpty {
+                model.setSelection(GridSelectionReducer.rowsSelectedNatively(
+                    IndexSet(integer: row),
+                    previous: model.selection,
+                    in: selectionContext
+                ))
+                mirrorSelection()
+            }
+            table.performNativeMouseDown(with: event)
+            return
+        }
+
+        switch slot {
+        case .rowNumber:
+            // AppKit tracks a press on the frozen row number itself, so a sideways drag can lift the rows it picks.
+            if pane.kind == .frozen, canDragRows(fromRowNumberAt: row), !modifiers.contains(.command), !modifiers.contains(.shift) {
+                model.setSelection(GridSelectionReducer.rowNumberDragPress(
+                    model.selection,
+                    row: row,
+                    keepsPickedRows: !model.configuration.rowReorder.isEnabled,
+                    in: selectionContext
+                ))
+                mirrorSelection()
+                table.performNativeMouseDown(with: event)
+                return
+            }
+            guard event.clickCount == 1 else { return }
+            let (selection, drag) = GridSelectionReducer.rowHeaderPress(model.selection, row: row, modifiers: modifiers, in: selectionContext)
+            model.setSelection(selection)
+            mirrorSelection()
+            trackDrag(drag, from: GridCoord(row: row, displayColumn: drag.origin.displayColumn))
+        case .data(let id):
+            guard let position = model.columns.displayPosition(of: id) else { return }
+            let cell = GridCoord(row: row, displayColumn: position)
+            if handleAccessoryPress(at: point, in: table, row: row, tableColumn: tableColumn, cell: cell, event: event) {
+                return
+            }
+            if event.clickCount >= 2 {
+                handleCellDoubleClick(at: cell)
+                return
+            }
+            let current = model.selection
+            // The cursor's cell on the one row a click selected, or a lone selected cell: a second click edits it.
+            let pressesActiveCell = current.activeCell == cell && !current.picksRows
+                && current.affectedRows == IndexSet(integer: cell.row)
+                && (!current.hasMultipleCells || current.mode == .cursor)
+            let (selection, drag) = GridSelectionReducer.press(model.selection, at: cell, modifiers: modifiers, in: selectionContext)
+            model.setSelection(selection)
+            mirrorSelection()
+            let moved = trackDrag(drag, from: cell)
+            if !moved, modifiers.isEmpty, pressesActiveCell {
+                handleClickOnActiveCell(cell)
+            }
+        }
+    }
+
+    // Runs until mouse-up, autoscrolling the main pane; the point decides which pane names the cell.
+    @discardableResult
+    private func trackDrag(_ drag: GridSelectionDrag, from start: GridCoord) -> Bool {
+        guard let window = view.window else { return false }
+        var moved = false
+        while let event = window.nextEvent(matching: [.leftMouseDragged, .leftMouseUp]) {
+            if event.type == .leftMouseUp { break }
+            _ = main.tableView.autoscroll(with: event)
+            guard let cell = dragCell(at: event.locationInWindow, rowsOnly: drag.mode == .rows) else { continue }
+            if drag.mode == .rows ? cell.row != start.row : cell != start {
+                moved = true
+            }
+            model.setSelection(GridSelectionReducer.drag(drag, to: cell, in: selectionContext))
+            mirrorSelection()
+        }
+        return moved
+    }
+
+    private func dragCell(at windowPoint: NSPoint, rowsOnly: Bool) -> GridCoord? {
+        let rowCount = model.rowCount
+        let columns = model.columns
+        guard rowCount > 0, !columns.isEmpty else { return nil }
+        let pane = container.pane(at: container.convert(windowPoint, from: nil))
+        let table = pane.tableView
+        let point = table.convert(windowPoint, from: nil)
+        guard let row = GridSelectionReducer.dragIndex(
+            hit: table.row(at: point),
+            coordinate: point.y,
+            first: 0,
+            last: rowCount - 1,
+            lastMaxEdge: table.rect(ofRow: rowCount - 1).maxY
+        ) else { return nil }
+        guard !rowsOnly else { return GridCoord(row: row, displayColumn: 0) }
+
+        let hit = table.column(at: point)
+        if hit >= 0, case .data(let id)? = pane.slot(atTableIndex: hit, columns: columns),
+           let position = columns.displayPosition(of: id) {
+            return GridCoord(row: row, displayColumn: position)
+        }
+        let positions = pane.displayPositions(columns: columns)
+        if hit >= 0 || positions.isEmpty {
+            return GridCoord(row: row, displayColumn: positions.first ?? firstColumnRightOfFrozenPane())
+        }
+        let last = positions.last ?? 0
+        return GridCoord(row: row, displayColumn: point.x >= pane.columnsWidth ? last : positions.first ?? 0)
+    }
+
+    // Over the row numbers alone, a drag reveals what the pane covers and names the column at its edge.
+    private func firstColumnRightOfFrozenPane() -> Int {
+        let table = main.tableView
+        let clip = main.scrollView.contentView.bounds
+        let edge = container.frozenPaneWidth
+        if clip.minX > 0 {
+            table.scroll(NSPoint(x: max(0, clip.minX - edge), y: clip.minY))
+        }
+        let x = main.scrollView.contentView.bounds.minX + edge
+        let hit = table.column(at: NSPoint(x: x, y: clip.minY))
+        guard hit >= 0, case .data(let id)? = main.slot(atTableIndex: hit, columns: model.columns) else { return 0 }
+        return model.columns.displayPosition(of: id) ?? 0
+    }
+
+    // FK arrow (Command opens a new tab), chevron and checkbox are hit-tested here and consume the press.
+    private func handleAccessoryPress(
+        at point: NSPoint,
+        in table: DataGridTableView,
+        row: Int,
+        tableColumn: Int,
+        cell: GridCoord,
+        event: NSEvent
+    ) -> Bool {
+        guard let rowModel = model.row(at: row), let column = model.columns.column(at: cell.displayColumn) else { return false }
+        let columnRect = table.rect(ofColumn: tableColumn)
+        let rowRect = table.rect(ofRow: row)
+        let cellRect = NSRect(x: columnRect.minX, y: rowRect.minY, width: columnRect.width, height: rowRect.height)
+        if model.configuration.checkboxColumns.contains(column.dataIndex) {
+            guard DataGridCheckboxMark.frame(in: cellRect).contains(point) else { return false }
+            return toggleCheckbox(rowID: rowModel.id, column: column, displayRow: row)
+        }
+        let presentation = presenter.presentation(forDataIndex: column.dataIndex)
+        guard presentation.accessory != .none, column.dataIndex < rowModel.values.count else { return false }
+        let accessory = DataGridCellAccessory.visible(
+            for: presentation.kind,
+            isEditable: model.configuration.isEditable,
+            rawValue: rowModel.values[column.dataIndex].asText
+        )
+        let frame = accessory.frame(in: cellRect)
+        guard !frame.isEmpty, frame.contains(point) else { return false }
+        switch accessory {
+        case .foreignKey:
+            handleForeignKeyArrowClick(at: cell, opensNewTab: event.modifierFlags.contains(.command))
+            return true
+        case .chevron:
+            guard !presenter.visualState(of: rowModel).isDeleted else { return false }
+            handleChevronClick(at: cell)
+            return true
+        case .none:
+            return false
+        }
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController+TableDelegate.swift b/apple/TablePro/Views/DataGrid/DataGridViewController+TableDelegate.swift
new file mode 100644
index 0000000000..8ad4588ea3
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController+TableDelegate.swift
@@ -0,0 +1,183 @@
+//
+//  DataGridViewController+TableDelegate.swift
+//  TablePro
+//
+
+import AppKit
+
+extension DataGridViewController: NSTableViewDataSource, NSTableViewDelegate {
+    func numberOfRows(in tableView: NSTableView) -> Int {
+        model.rowCount
+    }
+
+    // MARK: - Views
+
+    func tableView(_ tableView: NSTableView, rowViewForRow row: Int) -> NSTableRowView? {
+        guard let table = tableView as? DataGridTableView else { return nil }
+        let rowView = (tableView.makeView(withIdentifier: Self.rowViewIdentifier, owner: nil) as? DataGridRowView) ?? DataGridRowView()
+        rowView.identifier = Self.rowViewIdentifier
+        rowView.controller = self
+        rowView.gridTable = table
+        rowView.redrawCells()
+        return rowView
+    }
+
+    func tableView(_ tableView: NSTableView, didAdd rowView: NSTableRowView, forRow row: Int) {
+        rowView.isEmphasized = gridHasFocus
+    }
+
+    // Nil for every drawn cell: only the edit cell and, while an assistive client is attached, the accessibility cells mount.
+    func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
+        guard let tableColumn, let pane = container.pane(of: tableView) else { return nil }
+        if let editing = editingCellView(in: pane, tableColumn: tableColumn, row: row) {
+            return editing
+        }
+        guard pane.isMain, DataGridAccessibility.isActive, mountsAccessibilityCell(forRow: row) else { return nil }
+        return accessibilityCellView(for: tableColumn, row: row)
+    }
+
+    static let rowViewIdentifier = NSUserInterfaceItemIdentifier("DataGridRowView")
+
+    // Answers from the active column only, so type-select matches what the reader is looking at.
+    func tableView(_ tableView: NSTableView, typeSelectStringFor tableColumn: NSTableColumn?, row: Int) -> String? {
+        guard tableView === main.tableView,
+              let tableColumn,
+              let id = main.columnID(of: tableColumn),
+              let column = model.columns.column(id: id),
+              let position = model.columns.displayPosition(of: id),
+              position == (model.selection.activeCell?.displayColumn ?? 0),
+              let rowModel = model.row(at: row) else { return nil }
+        return presenter.displayText(
+            of: rowModel,
+            dataIndex: column.dataIndex,
+            type: column.type,
+            formats: model.store.displayFormats,
+            databaseType: model.configuration.traits.databaseType,
+            columnCount: model.rows.columns.count
+        )
+    }
+
+    // MARK: - Selection
+
+    func tableViewSelectionDidChange(_ notification: Notification) {
+        guard let table = notification.object as? NSTableView, let pane = container.pane(of: table) else { return }
+        tableSelectionDidChange(in: pane)
+    }
+
+    // MARK: - Header
+
+    func tableView(_ tableView: NSTableView, sortDescriptorsDidChange oldDescriptors: [NSSortDescriptor]) {
+        guard let pane = container.pane(of: tableView) else { return }
+        sortDescriptorsDidChange(in: pane)
+    }
+
+    func tableView(_ tableView: NSTableView, mouseDownInHeaderOf tableColumn: NSTableColumn) {
+        guard let pane = container.pane(of: tableView) else { return }
+        headerPressed(tableColumn, in: pane)
+    }
+
+    func tableView(_ tableView: NSTableView, didClick tableColumn: NSTableColumn) {
+        guard let pane = container.pane(of: tableView) else { return }
+        headerClicked(tableColumn, in: pane)
+    }
+
+    func tableViewColumnDidResize(_ notification: Notification) {
+        guard let table = notification.object as? NSTableView,
+              let pane = container.pane(of: table),
+              let column = notification.userInfo?["NSTableColumn"] as? NSTableColumn else { return }
+        columnDidResize(column, in: pane)
+    }
+
+    func tableViewColumnDidMove(_ notification: Notification) {
+        guard let table = notification.object as? NSTableView,
+              let pane = container.pane(of: table),
+              let oldIndex = notification.userInfo?["NSOldColumn"] as? Int,
+              let newIndex = notification.userInfo?["NSNewColumn"] as? Int else { return }
+        columnDidMove(from: oldIndex, to: newIndex, in: pane)
+    }
+
+    func tableView(_ tableView: NSTableView, shouldReorderColumn columnIndex: Int, toColumn newColumnIndex: Int) -> Bool {
+        guard let pane = container.pane(of: tableView) else { return false }
+        return shouldReorderColumn(columnIndex, to: newColumnIndex, in: pane)
+    }
+
+    // The divider double-click, measured from the loaded display strings.
+    func tableView(_ tableView: NSTableView, sizeToFitWidthOfColumn column: Int) -> CGFloat {
+        guard let pane = container.pane(of: tableView), column >= 0, column < tableView.tableColumns.count else { return 0 }
+        let tableColumn = tableView.tableColumns[column]
+        guard let id = pane.columnID(of: tableColumn), let dataColumn = model.columns.column(id: id) else {
+            return tableColumn.width
+        }
+        return fittedWidth(for: dataColumn)
+    }
+
+    // MARK: - Row reorder
+
+    func tableView(_ tableView: NSTableView, pasteboardWriterForRow row: Int) -> (any NSPasteboardWriting)? {
+        guard tableView === frozen.tableView, canDragRows(fromRowNumberAt: row) else { return nil }
+        return rowDragPasteboardItem(forRow: row)
+    }
+
+    // Every gap opens in one pane only, so the drop marks the row itself (.regular feedback, critic A M7).
+    func tableView(
+        _ tableView: NSTableView,
+        validateDrop info: any NSDraggingInfo,
+        proposedRow row: Int,
+        proposedDropOperation dropOperation: NSTableView.DropOperation
+    ) -> NSDragOperation {
+        guard model.configuration.rowReorder.isEnabled,
+              info.draggingSource as? NSTableView === frozen.tableView,
+              info.draggingPasteboard.availableType(from: [Self.rowDragType]) != nil else { return [] }
+        if dropOperation != .above {
+            tableView.setDropRow(row, dropOperation: .above)
+        }
+        return .move
+    }
+
+    func tableView(
+        _ tableView: NSTableView,
+        acceptDrop info: any NSDraggingInfo,
+        row: Int,
+        dropOperation: NSTableView.DropOperation
+    ) -> Bool {
+        guard model.configuration.rowReorder.isEnabled,
+              let item = info.draggingPasteboard.pasteboardItems?.first,
+              let fromRow = item.string(forType: Self.rowDragType).flatMap({ Int($0) }),
+              fromRow != row, fromRow != row - 1,
+              let rowID = model.rowID(at: fromRow),
+              let actions = model.actions else { return false }
+        actions.gridMoveRow(from: rowID, toDisplayIndex: row)
+        return true
+    }
+}
+
+extension DataGridViewController: NSMenuDelegate {
+    // Built from clickedRow and clickedColumn, so AppKit draws the clicked-row ring and the selection does not move.
+    func menuNeedsUpdate(_ menu: NSMenu) {
+        menu.removeAllItems()
+        guard let pane = panes.first(where: { $0.tableView.menu === menu }) else { return }
+        let table = pane.tableView
+        let row = table.clickedRow
+        let built: NSMenu?
+        if row >= 0 {
+            let column = table.clickedColumn
+            var position: Int?
+            if column >= 0, case .data(let id)? = pane.slot(atTableIndex: column, columns: model.columns) {
+                position = model.columns.displayPosition(of: id)
+            }
+            built = rowMenu(forRow: row, displayColumn: position, in: pane.kind)
+        } else {
+            built = emptySpaceMenu()
+        }
+        guard let built else { return }
+        let items = built.items
+        built.removeAllItems()
+        items.forEach(menu.addItem)
+    }
+
+    func headerMenu(forTableColumn tableColumn: NSTableColumn, in kind: DataGridPane.Kind) -> NSMenu? {
+        let pane = container.pane(kind)
+        guard let id = pane.columnID(of: tableColumn), let column = model.columns.column(id: id) else { return nil }
+        return headerMenu(for: column)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/DataGridViewController.swift b/apple/TablePro/Views/DataGrid/DataGridViewController.swift
new file mode 100644
index 0000000000..3776585b3e
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/DataGridViewController.swift
@@ -0,0 +1,382 @@
+//
+//  DataGridViewController.swift
+//  TablePro
+//
+
+import AppKit
+import Combine
+
+// An NSViewController so commitEditing() and discardEditing() are NSEditor's own (probe P1h).
+@MainActor
+final class DataGridViewController: NSViewController, DataGridMountedView {
+    private(set) var model: DataGridModel
+    let presenter: DataGridCellPresenter
+    let container = DataGridContainerView()
+    let editingState = DataGridEditingState()
+    let menuState = DataGridMenuState()
+
+    private(set) lazy var selectionSummaryTracker = SelectionSummaryTracker(
+        inputProvider: { [weak self] in self?.selectionSummaryInput() }
+    )
+
+    var isMirroringSelection = false
+    var isApplyingSortDescriptors = false
+    var isRebuildingColumns = false
+    var pendingHeaderPress: (kind: DataGridPane.Kind, identifier: NSUserInterfaceItemIdentifier)?
+    var drawnSelection: GridSelection = .empty
+    var effectiveFrozenCount = 0
+    var resultColumnIDs: [DataGridColumnID] = []
+    var knownWidths: [DataGridColumnID: CGFloat] = [:]
+    var knownWidthsSawRows = false
+    var savedWidthIDs: Set<DataGridColumnID> = []
+    var accessibilityMountedRows = NSRange(location: 0, length: 0)
+    var needsViewportRestore = false
+    var pendingFocus = false
+    var lastDataGridSettings = AppSettingsManager.shared.dataGrid
+    var prewarmTask: Task<Void, Never>?
+    var prewarmResumeTask: Task<Void, Never>?
+    var reorderToolTipOwner: NSString?
+    private var observers: [NSObjectProtocol] = []
+    private var cancellables: Set<AnyCancellable> = []
+    private var themeCancellable: AnyCancellable?
+    private var findCancellable: AnyCancellable?
+    private var drawnFindMatch: GridFindState.Match?
+
+    init(model: DataGridModel) {
+        self.model = model
+        presenter = DataGridCellPresenter(model: model)
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    var main: DataGridPane { container.main }
+    var frozen: DataGridPane { container.frozen }
+    var panes: [DataGridPane] { container.panes }
+    var gridHasFocus: Bool { container.gridHasFocus }
+
+    // MARK: - Lifecycle
+
+    override func loadView() {
+        view = container
+    }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        container.controller = self
+        for pane in panes {
+            pane.tableView.controller = self
+            pane.tableView.delegate = self
+            pane.tableView.dataSource = self
+            let menu = NSMenu()
+            menu.delegate = self
+            pane.tableView.menu = menu
+            pane.tableView.setDraggingSourceOperationMask(.move, forLocal: true)
+            pane.tableView.setDraggingSourceOperationMask(.copy, forLocal: false)
+        }
+        observeEnvironment()
+        mount()
+    }
+
+    private func mount() {
+        model.attach(self)
+        presenter.registry.adopt(model.themeScope, in: view.effectiveAppearance)
+        observeTheme()
+        observeFind()
+        applyTableSettings()
+        reloadAll()
+        needsViewportRestore = model.store.viewportAnchor != nil
+        // Attaching publishes the summary state, which SwiftUI refuses inside the update that made this view.
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.model.mountedView === self else { return }
+            self.selectionSummaryTracker.attach(self.model.selectionSummary)
+        }
+    }
+
+    // A representable kept across a model swap moves the grid to the new model instead of rebuilding.
+    func adopt(_ newModel: DataGridModel) {
+        guard newModel !== model else { return }
+        _ = commitCellEditing()
+        saveViewportAnchor()
+        model.detach(self)
+        model = newModel
+        presenter.adopt(newModel)
+        drawnSelection = .empty
+        resultColumnIDs = []
+        knownWidths = [:]
+        knownWidthsSawRows = false
+        savedWidthIDs = []
+        mount()
+    }
+
+    // A new mount of the same model can arrive before this one goes, so only the current mount writes the anchor.
+    func dismantle() {
+        _ = commitCellEditing()
+        dismissValueFilterPopover()
+        if model.mountedView === self {
+            saveViewportAnchor()
+        }
+        model.detach(self)
+        prewarmTask?.cancel()
+        prewarmTask = nil
+        prewarmResumeTask?.cancel()
+        prewarmResumeTask = nil
+        observers.forEach(NotificationCenter.default.removeObserver)
+        observers.removeAll()
+        cancellables.removeAll()
+        themeCancellable = nil
+        findCancellable = nil
+        selectionSummaryTracker.cancel()
+        selectionSummaryTracker.attach(nil)
+        container.tearDown()
+    }
+
+    func containerDidMoveToWindow() {
+        guard view.window != nil else { return }
+        if pendingFocus {
+            pendingFocus = false
+            focus()
+        }
+        container.refreshFocus()
+    }
+
+    func containerDidLayout() {
+        if resolveEffectiveFrozenCount() != effectiveFrozenCount {
+            updateFrozenPane()
+            redrawVisibleRows()
+        }
+        updateReorderToolTip()
+        if needsViewportRestore, main.scrollView.contentView.bounds.height > 0 {
+            needsViewportRestore = false
+            applyStagedViewport()
+        }
+    }
+
+    // MARK: - DataGridMountedView
+
+    var isEditing: Bool { isEditingCell }
+
+    @discardableResult
+    func beginEditing(row: Int, displayColumn: Int) -> Bool {
+        beginEditingCell(row: row, displayColumn: displayColumn)
+    }
+
+    override func commitEditing() -> Bool {
+        commitCellEditing()
+    }
+
+    override func discardEditing() {
+        discardCellEditing()
+    }
+
+    @discardableResult
+    func focus() -> Bool {
+        guard let window = view.window else {
+            pendingFocus = true
+            return false
+        }
+        return window.makeFirstResponder(main.tableView)
+    }
+
+    func gridFocusDidChange() {
+        let hasFocus = gridHasFocus
+        for pane in panes {
+            pane.tableView.enumerateAvailableRowViews { rowView, _ in
+                rowView.isEmphasized = hasFocus
+                (rowView as? DataGridRowView)?.redrawCells()
+            }
+        }
+    }
+
+    // MARK: - Environment
+
+    private func observeEnvironment() {
+        AppEvents.shared.dataGridSettingsChanged
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in self?.dataGridSettingsDidChange() }
+            .store(in: &cancellables)
+        AppEvents.shared.systemTimeZoneChanged
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in self?.reformatText() }
+            .store(in: &cancellables)
+
+        let center = NotificationCenter.default
+        // Deferred off the accessibility query that raised the flag: rebuilding rows inside it re-enters AppKit's walk.
+        observers.append(center.addObserver(forName: DataGridAccessibility.didActivateNotification, object: nil, queue: nil) { [weak self] _ in
+            Task { @MainActor [weak self] in self?.remountAccessibilityCells() }
+        })
+        let scrollView = main.scrollView
+        observers.append(center.addObserver(forName: NSScrollView.willStartLiveScrollNotification, object: scrollView, queue: .main) { [weak self] _ in
+            MainActor.assumeIsolated { self?.pausePrewarm() }
+        })
+        observers.append(center.addObserver(forName: NSScrollView.didEndLiveScrollNotification, object: scrollView, queue: .main) { [weak self] _ in
+            MainActor.assumeIsolated { self?.schedulePrewarmResume() }
+        })
+    }
+
+    // objectWillChange fires before the value moves, so the current match is read on the next turn.
+    private func observeFind() {
+        drawnFindMatch = model.find.currentMatch
+        findCancellable = model.find.objectWillChange.sink { [weak self] _ in
+            DispatchQueue.main.async { [weak self] in self?.findStateDidChange() }
+        }
+    }
+
+    private func findStateDidChange() {
+        let match = model.find.currentMatch
+        guard match != drawnFindMatch else { return }
+        let rows = IndexSet([drawnFindMatch, match].compactMap { $0.flatMap { model.displayIndex(of: $0.rowID) } })
+        drawnFindMatch = match
+        redrawRows(rows)
+    }
+
+    private func observeTheme() {
+        themeCancellable = model.themeScope.changes
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in self?.themeDidChange() }
+    }
+
+    // Also fires for Accent, Highlight, Increase Contrast and the grid font, none of which moves a value: repaint, never reload.
+    func themeDidChange() {
+        presenter.registry.preparePalette(in: view.effectiveAppearance)
+        for pane in panes {
+            DataGridBodyChrome.applyThemeColors(to: pane.tableView, scope: model.themeScope)
+            pane.headerView.needsDisplay = true
+        }
+        applyRowHeight()
+        applyRowNumberWidth()
+        refreshHeaders()
+        redrawVisibleRows()
+    }
+
+    private func dataGridSettingsDidChange() {
+        let settings = AppSettingsManager.shared.dataGrid
+        let previous = lastDataGridSettings
+        lastDataGridSettings = settings
+        presenter.registry.reloadSettings(settings)
+        applyRowHeight()
+        if previous.showAlternateRows != settings.showAlternateRows {
+            panes.forEach { $0.tableView.usesAlternatingRowBackgroundColors = settings.showAlternateRows }
+            panes.forEach { $0.tableView.needsDisplay = true }
+            redrawVisibleRows()
+        }
+        if previous.defaultSortDirection != settings.defaultSortDirection {
+            reconcileColumns()
+        }
+        if previous.dateFormat != settings.dateFormat
+            || previous.nullDisplay != settings.nullDisplay
+            || previous.enableSmartValueDetection != settings.enableSmartValueDetection {
+            reformatText()
+        } else if previous.showInvisibleCharacters != settings.showInvisibleCharacters {
+            redrawVisibleRows()
+        }
+    }
+
+    // Rebuilds every formatted string: the date format, NULL text or smart detection moved, or the Mac's time zone did.
+    func reformatText() {
+        model.display.cache.removeAll()
+        redrawVisibleRows()
+        startBackgroundPrewarm()
+    }
+
+    func applyTableSettings() {
+        if presenter.registry.scope !== model.themeScope {
+            presenter.registry.adopt(model.themeScope, in: view.effectiveAppearance)
+            observeTheme()
+        }
+        let configuration = model.configuration
+        let settings = AppSettingsManager.shared.dataGrid
+        for pane in panes {
+            let table = pane.tableView
+            DataGridBodyChrome.applyThemeColors(to: table, scope: model.themeScope)
+            table.usesAlternatingRowBackgroundColors = settings.showAlternateRows
+            table.toolTip = configuration.isEditable ? nil : configuration.editRefusalMessage
+            applyRowReorder(configuration.rowReorder, to: table)
+        }
+        main.tableView.setAccessibilityLabel(configuration.accessibilityLabel ?? String(localized: "Data grid"))
+        applyRowHeight()
+    }
+
+    private func applyRowReorder(_ reorder: DataGridRowReorder, to table: DataGridTableView) {
+        let hasType = table.registeredDraggedTypes.contains(Self.rowDragType)
+        if reorder.isEnabled, !hasType {
+            table.registerForDraggedTypes([Self.rowDragType])
+            table.draggingDestinationFeedbackStyle = .regular
+        } else if !reorder.isEnabled, hasType {
+            let remaining = table.registeredDraggedTypes.filter { $0 != Self.rowDragType }
+            table.unregisterDraggedTypes()
+            if !remaining.isEmpty {
+                table.registerForDraggedTypes(remaining)
+            }
+        }
+    }
+
+    static let rowDragType = NSPasteboard.PasteboardType("com.TablePro.rowDrag")
+
+    // The row number is the handle a reorder drag starts from, so it carries the reason a drag is withheld.
+    func updateReorderToolTip() {
+        let table = frozen.tableView
+        table.removeAllToolTips()
+        reorderToolTipOwner = nil
+        guard let reason = model.configuration.rowReorder.unavailableReason, frozen.hasRowNumberColumn else { return }
+        let owner = reason as NSString
+        reorderToolTipOwner = owner
+        _ = table.addToolTip(table.rect(ofColumn: 0), owner: owner, userData: nil)
+    }
+
+    // MARK: - Rows
+
+    func redrawVisibleRows() {
+        for pane in panes {
+            pane.tableView.enumerateAvailableRowViews { rowView, _ in
+                (rowView as? DataGridRowView)?.redrawCells()
+            }
+        }
+    }
+
+    // Only rows AppKit holds a view for can need a repaint, so a select-all over a large result costs the prepared rows.
+    func redrawRows(_ rows: IndexSet) {
+        guard !rows.isEmpty else { return }
+        for pane in panes {
+            pane.tableView.enumerateAvailableRowViews { rowView, row in
+                guard rows.contains(row) else { return }
+                (rowView as? DataGridRowView)?.redrawCells()
+            }
+        }
+    }
+
+    func rowTint(forRow row: Int) -> NSColor? {
+        let rows = model.rows
+        guard let rowModel = model.order.row(at: row, in: rows) else { return nil }
+        presenter.prepareRowState(rows: rows)
+        return presenter.visualState(of: rowModel).tint(in: model.themeScope)
+    }
+
+    // MARK: - Selection summary
+
+    // Only a range of two or more cells has a summary; a clicked or picked row spans its cells without choosing them.
+    private func selectionSummaryInput() -> SelectionSummaryInput? {
+        let selection = model.selection
+        guard selection.mode == .cells, selection.hasMultipleCells else { return nil }
+        let rows = model.rows
+        let changeState = model.changeState
+        let policy = model.dataSource?.gridSummaryColumnPolicy() ?? .derived(
+            columnTypes: rows.columnTypes,
+            displayFormats: model.store.displayFormats,
+            columnCount: rows.columns.count
+        )
+        return SelectionSummaryInput(
+            selection: selection,
+            tableRows: rows,
+            displayIDs: model.order.filteredIDs,
+            dataColumnsByDisplayPosition: model.columns.columns.map(\.dataIndex),
+            policy: policy,
+            deletedRowIDs: changeState?.deletedRowIDs ?? [],
+            insertedRowIDs: changeState?.insertedRowIDs ?? [],
+            modifiedCells: changeState?.modifiedCells ?? [:]
+        )
+    }
+}
diff --git a/apple/TablePro/Views/Results/CellEditorMovement.swift b/apple/TablePro/Views/DataGrid/Editing/CellEditorMovement.swift
similarity index 54%
rename from apple/TablePro/Views/Results/CellEditorMovement.swift
rename to apple/TablePro/Views/DataGrid/Editing/CellEditorMovement.swift
index 65965bacd9..a35473ddda 100644
--- a/apple/TablePro/Views/Results/CellEditorMovement.swift
+++ b/apple/TablePro/Views/DataGrid/Editing/CellEditorMovement.swift
@@ -5,28 +5,15 @@
 
 import Foundation
 
-/// Which way an inline cell editor was left.
-///
-/// The cases are AppKit's own vocabulary for leaving one field for the next: `NSTextMovement`
-/// declares `up` and `down` beside `tab` and `backtab` as "movement codes for movement between
-/// fields". The overlay editor is a standalone text view rather than a field editor, so it reads
-/// the four selectors itself and reports them here.
-enum CellEditorMovement {
+// NSTableView never moves editing between view-based cells itself (probe P1c), so the grid does, in these steps.
+enum CellEditorMovement: Equatable {
     case tab
     case backtab
     case up
     case down
 }
 
-/// Whether Up or Down in an inline cell editor moves the caret or leaves the cell.
-///
-/// A cell value can hold line breaks, so the arrow keys belong to the value's own lines first and
-/// the editor is left only from the line at that end. A value on one line has no line to move to
-/// in either direction, so both arrows leave it, including straight after the editor opens with
-/// the whole value selected.
-///
-/// A line break is the only thing that starts a line here, because the overlay never wraps text
-/// (`CellOverlayBase.applyCellTextLayout`, pinned by `CellOverlayTextLayoutTests`).
+// Up and Down belong to a value's own lines first and leave the cell only from the line at that end (#2569).
 struct CellEditorArrowExit {
     let canExitUp: Bool
     let canExitDown: Bool
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridEditSession.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridEditSession.swift
new file mode 100644
index 0000000000..4f550b2aab
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridEditSession.swift
@@ -0,0 +1,87 @@
+//
+//  DataGridEditSession.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+// Captured when an editor opens, so a reload, a sort or a tab switch never redirects its commit (H2).
+struct DataGridEditTarget: Equatable {
+    let rowID: RowID
+    let columnID: DataGridColumnID
+}
+
+struct DataGridEditSession {
+    enum Editor: Equatable {
+        case field
+        case textPopover
+    }
+
+    let target: DataGridEditTarget
+    let editor: Editor
+    // Committing it unchanged is no edit, even over a NULL that opened as empty text.
+    let originalText: String
+    // A replaced result reuses RowIDs for other records; the values tell them apart.
+    let originalRow: ContiguousArray<PluginCellValue>
+    var pane: DataGridPane.Kind
+    // Read by every drawn cell, so it is refreshed per change rather than resolved per draw.
+    var cell: GridCoord
+}
+
+struct DataGridHeldRow {
+    let target: DataGridEditTarget
+    var values: ContiguousArray<PluginCellValue>
+}
+
+struct DataGridEditCell {
+    let coord: GridCoord
+    let row: Row
+    let column: DataGridColumn
+
+    var target: DataGridEditTarget {
+        DataGridEditTarget(rowID: row.id, columnID: column.id)
+    }
+
+    var value: PluginCellValue {
+        row[column.dataIndex]
+    }
+
+    var isUnloaded: Bool {
+        row.unloadedByteCount(column.dataIndex) != nil
+    }
+}
+
+// A reload ends AppKit's editing (probe P1d), so the field pauses across one.
+struct DataGridSuspendedFieldEdit {
+    let session: DataGridEditSession
+    let text: String
+    let selection: NSRange
+}
+
+// A menu item's target is weak, so the item keeps its action alive as its represented object.
+@MainActor
+final class DataGridMenuAction: NSObject {
+    private let perform: @MainActor () -> Void
+
+    init(_ perform: @escaping @MainActor () -> Void) {
+        self.perform = perform
+    }
+
+    @objc func invoke(_ sender: Any?) {
+        perform()
+    }
+
+    static func item(
+        _ title: String,
+        state: NSControl.StateValue = .off,
+        perform: @escaping @MainActor () -> Void
+    ) -> NSMenuItem {
+        let action = DataGridMenuAction(perform)
+        let item = NSMenuItem(title: title, action: #selector(invoke(_:)), keyEquivalent: "")
+        item.target = action
+        item.representedObject = action
+        item.state = state
+        return item
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridEditingCellView.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridEditingCellView.swift
new file mode 100644
index 0000000000..21762e8b70
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridEditingCellView.swift
@@ -0,0 +1,196 @@
+//
+//  DataGridEditingCellView.swift
+//  TablePro
+//
+
+import AppKit
+import TableProTheme
+
+// The one cell view the grid mounts, for the edited cell; every other cell is drawn (probe P1a, P1b).
+@MainActor
+final class DataGridEditingCellView: NSTableCellView {
+    static let reuseIdentifier = NSUserInterfaceItemIdentifier("data-grid-edit-cell")
+
+    private static let borderWidth: CGFloat = 2
+
+    let field = DataGridEditingTextField(frame: .zero)
+    private var scope: ThemeScope = .live
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+        identifier = Self.reuseIdentifier
+        // Its own layer: the row view draws its subviews into one layer, which would flatten the caret.
+        wantsLayer = true
+        field.autoresizingMask = []
+        addSubview(field)
+        textField = field
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func prepare(text: String, font: NSFont, scope: ThemeScope, columnName: String, delegate: any NSTextFieldDelegate) {
+        self.scope = scope
+        let palette = scope.palette
+        field.adopt(scope)
+        field.font = font
+        field.textColor = palette.color(.editorText, otherwise: .textColor)
+        field.backgroundColor = palette.color(.editorBackground, otherwise: .textBackgroundColor)
+        field.stringValue = text
+        field.delegate = delegate
+        // A text field's accessibility element is its cell; a label set on the control never reaches VoiceOver (measured).
+        field.cell?.setAccessibilityLabel(columnName)
+        needsLayout = true
+        needsDisplay = true
+    }
+
+    // Centred like the drawn text, which a field the cell's height would draw above.
+    func layoutField() {
+        let inset = Self.borderWidth
+        let lineHeight = field.font.map { ($0.ascender - $0.descender + $0.leading).rounded(.up) } ?? bounds.height
+        let height = min(lineHeight + 2, max(0, bounds.height - 2 * inset))
+        let frame = NSRect(
+            x: inset,
+            y: ((bounds.height - height) / 2).rounded(),
+            width: max(0, bounds.width - 2 * inset),
+            height: height
+        )
+        if field.frame != frame {
+            field.frame = frame
+        }
+    }
+
+    override func layout() {
+        super.layout()
+        layoutField()
+    }
+
+    override func resizeSubviews(withOldSize oldSize: NSSize) {
+        super.resizeSubviews(withOldSize: oldSize)
+        layoutField()
+    }
+
+    override var isFlipped: Bool { true }
+
+    // A selected row's emphasized style would turn the text white on the field's own white background.
+    override var backgroundStyle: NSView.BackgroundStyle {
+        get { .normal }
+        set { super.backgroundStyle = newValue == .emphasized ? .normal : newValue }
+    }
+
+    // The row skips the active-cell border under the edited cell, so the editor draws it.
+    override func draw(_ dirtyRect: NSRect) {
+        scope.palette.color(.editorBackground, otherwise: .textBackgroundColor).setFill()
+        bounds.fill()
+        let path = NSBezierPath(rect: bounds.insetBy(dx: Self.borderWidth / 2, dy: Self.borderWidth / 2))
+        path.lineWidth = Self.borderWidth
+        NSColor.keyboardFocusIndicatorColor.setStroke()
+        path.stroke()
+    }
+}
+
+// Its own field editor: a caret color written to the window's shared one stays on the next field edited (measured).
+@MainActor
+final class DataGridEditingTextField: NSTextField {
+    private(set) lazy var ownFieldEditor: NSTextView = {
+        let editor = DataGridFieldEditor()
+        editor.isFieldEditor = true
+        editor.allowsUndo = true
+        TextValueEditor.disableSubstitutions(in: editor)
+        return editor
+    }()
+
+    // Held, or its theme subscription stops at the first change.
+    private var fieldEditorStyle: ThemeTextViewStyle?
+    private var invisibleCharacters: InvisibleCharacterTextDisplay?
+
+    override class var cellClass: AnyClass? {
+        get { DataGridEditingTextFieldCell.self }
+        set { super.cellClass = newValue }
+    }
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+        isEditable = true
+        isSelectable = true
+        isBordered = false
+        isBezeled = false
+        drawsBackground = true
+        focusRingType = .none
+        usesSingleLineMode = true
+        lineBreakMode = .byClipping
+        maximumNumberOfLines = 1
+        allowsEditingTextAttributes = false
+        importsGraphics = false
+        cell?.wraps = false
+        cell?.isScrollable = true
+        cell?.setAccessibilityIdentifier("data-grid-edit-field")
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func adopt(_ scope: ThemeScope) {
+        guard fieldEditorStyle?.scope !== scope else { return }
+        fieldEditorStyle?.detach()
+        fieldEditorStyle = ThemeTextViewStyle(textView: ownFieldEditor, scope: scope)
+    }
+
+    // AppKit resets the editor's colors from the cell each time editing starts.
+    fileprivate func fieldEditorDidSetUp() {
+        fieldEditorStyle?.apply()
+        let marksInvisibles = AppSettingsManager.shared.dataGrid.showInvisibleCharacters
+        if let invisibleCharacters {
+            invisibleCharacters.isEnabled = marksInvisibles
+        } else {
+            invisibleCharacters = InvisibleCharacterTextDisplay.install(on: ownFieldEditor, isEnabled: marksInvisibles)
+        }
+    }
+}
+
+// Holds no state of its own: AppKit copies a cell bit for bit, so everything lives on the field.
+private final class DataGridEditingTextFieldCell: NSTextFieldCell {
+    override func fieldEditor(for controlView: NSView) -> NSTextView? {
+        (controlView as? DataGridEditingTextField)?.ownFieldEditor
+    }
+
+    override func setUpFieldEditorAttributes(_ textObj: NSText) -> NSText {
+        let configured = super.setUpFieldEditorAttributes(textObj)
+        (controlView as? DataGridEditingTextField)?.fieldEditorDidSetUp()
+        return configured
+    }
+
+    override func endEditing(_ textObj: NSText) {
+        (textObj as? DataGridFieldEditor)?.endUndoSession()
+        super.endEditing(textObj)
+    }
+}
+
+// The window's undo manager would keep typing actions into text AppKit empties at the end, and Undo would raise.
+private final class DataGridFieldEditor: NSTextView {
+    private let sessionUndoManager = UndoManager()
+
+    override var undoManager: UndoManager? {
+        sessionUndoManager
+    }
+
+    func endUndoSession() {
+        sessionUndoManager.removeAllActions()
+    }
+
+    // Paste, drop and Services read here; single-line mode would drop the text's line breaks.
+    override func readSelection(from pboard: NSPasteboard, type: NSPasteboard.PasteboardType) -> Bool {
+        let range = rangeForUserTextChange
+        if range.location != NSNotFound,
+           let text = pboard.string(forType: .string), text.contains(where: \.isNewline),
+           let fieldDelegate = (delegate as? NSTextField)?.delegate as? DataGridFieldEditorDelegate,
+           fieldDelegate.fieldEditorInsertsLines(text, replacing: range) {
+            return true
+        }
+        return super.readSelection(from: pboard, type: type)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridTextEditorPopover.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridTextEditorPopover.swift
new file mode 100644
index 0000000000..e5a0c52077
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridTextEditorPopover.swift
@@ -0,0 +1,213 @@
+//
+//  DataGridTextEditorPopover.swift
+//  TablePro
+//
+
+import AppKit
+import TableProTheme
+
+// The field editor cannot grow past its row, so a multi-line or long value edits here; read-only, it is the viewer.
+@MainActor
+final class DataGridTextEditorPopover: NSObject, NSPopoverDelegate, NSTextViewDelegate {
+    enum Ending: Equatable {
+        case commit(CellEditorMovement?)
+        case cancel
+    }
+
+    // Wrapping lays a paragraph out whole first: 206 ms at 256 KB and 816 ms at 1 MB, 7 ms unwrapped (#2381).
+    static let wrapLimit = 65_536
+
+    private static let minimumWidth: CGFloat = 320
+    private static let maximumWidth: CGFloat = 560
+    private static let minimumHeight: CGFloat = 80
+    private static let maximumHeight: CGFloat = 360
+
+    let popover = NSPopover()
+    let textView: DataGridPopoverTextView
+    let isEditable: Bool
+    var onEnd: ((Ending, String) -> Void)?
+
+    private var hasEnded = false
+    // Held, or their subscriptions stop at the first change.
+    private var style: ThemeTextViewStyle?
+    private var invisibleCharacters: InvisibleCharacterTextDisplay?
+
+    init(text: String, isEditable: Bool, cellWidth: CGFloat, scope: ThemeScope) {
+        self.isEditable = isEditable
+        let font = ThemeEngine.shared.dataGridFonts.regular
+        let size = Self.contentSize(for: text, cellWidth: cellWidth, font: font)
+        let scrollView = NSScrollView(frame: NSRect(origin: .zero, size: size))
+        scrollView.hasVerticalScroller = true
+        scrollView.autohidesScrollers = true
+        scrollView.borderType = .noBorder
+        scrollView.drawsBackground = true
+        scrollView.backgroundColor = scope.palette.color(.editorBackground, otherwise: .textBackgroundColor)
+        scrollView.autoresizingMask = [.width, .height]
+
+        let textView = DataGridPopoverTextView(usingTextLayoutManager: true)
+        textView.frame = NSRect(origin: .zero, size: scrollView.contentSize)
+        textView.isEditable = isEditable
+        textView.isSelectable = true
+        textView.isRichText = false
+        textView.allowsUndo = true
+        textView.importsGraphics = false
+        TextValueEditor.disableSubstitutions(in: textView)
+        textView.font = font
+        textView.textColor = .textColor
+        textView.backgroundColor = .textBackgroundColor
+        textView.textContainerInset = NSSize(width: 4, height: 6)
+        Self.applyLayout(to: textView, for: text, width: scrollView.contentSize.width)
+        scrollView.hasHorizontalScroller = !Self.wraps(text)
+        self.textView = textView
+        super.init()
+
+        textView.editorPopover = self
+        style = ThemeTextViewStyle(textView: textView, scope: scope)
+        invisibleCharacters = InvisibleCharacterTextDisplay.install(
+            on: textView,
+            isEnabled: AppSettingsManager.shared.dataGrid.showInvisibleCharacters
+        )
+        textView.string = text
+        textView.delegate = self
+        textView.setAccessibilityIdentifier(isEditable ? "grid-text-editor" : "grid-text-viewer")
+        scrollView.documentView = textView
+
+        let controller = NSViewController()
+        controller.view = scrollView
+        popover.contentViewController = controller
+        popover.contentSize = size
+        popover.behavior = .transient
+        popover.animates = false
+        popover.delegate = self
+    }
+
+    static func wraps(_ text: String) -> Bool {
+        (text as NSString).length <= wrapLimit
+    }
+
+    // maxSize stays unbounded, or a long line is clipped at the popover's edge instead of scrolling.
+    static func applyLayout(to textView: NSTextView, for text: String, width: CGFloat) {
+        let unbounded = NSSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude)
+        textView.minSize = .zero
+        textView.maxSize = unbounded
+        textView.isVerticallyResizable = true
+        let wrapping = wraps(text)
+        textView.isHorizontallyResizable = !wrapping
+        textView.autoresizingMask = wrapping ? [.width] : []
+        textView.textContainer?.widthTracksTextView = wrapping
+        textView.textContainer?.containerSize = wrapping
+            ? NSSize(width: width, height: CGFloat.greatestFiniteMagnitude)
+            : unbounded
+    }
+
+    static func contentSize(for text: String, cellWidth: CGFloat, font: NSFont) -> NSSize {
+        let width = min(max(cellWidth, minimumWidth), maximumWidth)
+        let lineHeight = (font.ascender - font.descender + font.leading).rounded(.up)
+        var lines = 1
+        let scalars = text.unicodeScalars
+        var previous: Unicode.Scalar?
+        for scalar in scalars where lines < 40 {
+            if scalar == "\r" || (scalar == "\n" && previous != "\r") {
+                lines += 1
+            }
+            previous = scalar
+        }
+        let characterWidth = max(1, ("0" as NSString).size(withAttributes: [.font: font]).width)
+        let charactersPerLine = max(1, Int((width - 16) / characterWidth))
+        let wrappedLines = wraps(text) ? (text.utf16.count / charactersPerLine) : 0
+        let height = CGFloat(lines + wrappedLines) * lineHeight + 16
+        return NSSize(width: width, height: min(max(height, minimumHeight), maximumHeight))
+    }
+
+    func show(relativeTo rect: NSRect, of view: NSView, selection: NSRange?) {
+        // A window off screen has no place on screen to point the popover at.
+        if view.window?.isVisible == true {
+            popover.show(relativeTo: rect, of: view, preferredEdge: .maxY)
+            textView.window?.makeFirstResponder(textView)
+        }
+        let length = (textView.string as NSString).length
+        if let selection {
+            let location = min(max(selection.location, 0), length)
+            textView.setSelectedRange(NSRange(location: location, length: min(max(selection.length, 0), length - location)))
+        } else if isEditable {
+            textView.selectAll(nil)
+        }
+        textView.scrollRangeToVisible(textView.selectedRange())
+    }
+
+    var isShown: Bool { popover.isShown && !hasEnded }
+
+    func end(_ ending: Ending) {
+        guard !hasEnded else { return }
+        hasEnded = true
+        let text = textView.string
+        style?.detach()
+        style = nil
+        invisibleCharacters = nil
+        popover.close()
+        onEnd?(ending, text)
+        onEnd = nil
+    }
+
+    // A click outside or an app switch closes it; what was typed is kept, as when focus leaves a field.
+    func popoverDidClose(_ notification: Notification) {
+        end(isEditable ? .commit(nil) : .cancel)
+    }
+
+    func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
+        switch commandSelector {
+        case #selector(NSResponder.insertNewline(_:)):
+            end(isEditable ? .commit(nil) : .cancel)
+            return true
+        case #selector(NSResponder.cancelOperation(_:)):
+            end(.cancel)
+            return true
+        case #selector(NSResponder.insertTab(_:)):
+            return leave(.tab, from: textView)
+        case #selector(NSResponder.insertBacktab(_:)):
+            return leave(.backtab, from: textView)
+        case #selector(NSResponder.moveUp(_:)):
+            return leaveVertically(.up, from: textView)
+        case #selector(NSResponder.moveDown(_:)):
+            return leaveVertically(.down, from: textView)
+        default:
+            return false
+        }
+    }
+
+    // An arrow during an IME composition moves through the composition.
+    private func leaveVertically(_ movement: CellEditorMovement, from textView: NSTextView) -> Bool {
+        guard isEditable, !textView.hasMarkedText() else { return false }
+        let exit = CellEditorArrowExit(text: textView.string as NSString, selection: textView.selectedRange())
+        guard movement == .up ? exit.canExitUp : exit.canExitDown else { return false }
+        end(.commit(movement))
+        return true
+    }
+
+    // A literal tab is not what Tab was pressed for, so a composition swallows it.
+    private func leave(_ movement: CellEditorMovement, from textView: NSTextView) -> Bool {
+        guard !textView.hasMarkedText() else { return true }
+        end(isEditable ? .commit(movement) : .cancel)
+        return true
+    }
+}
+
+// Typing undo stays here, apart from the window's history of committed edits.
+@MainActor
+final class DataGridPopoverTextView: NSTextView {
+    private let storedUndoManager = UndoManager()
+
+    weak var editorPopover: DataGridTextEditorPopover?
+
+    override var undoManager: UndoManager? { storedUndoManager }
+
+    // Cmd+S saves what is typed: commit first, then let Save run.
+    override func performKeyEquivalent(with event: NSEvent) -> Bool {
+        let modifiers = event.modifierFlags.intersection([.command, .shift, .option, .control])
+        if modifiers == .command, event.charactersIgnoringModifiers == "s", let editorPopover, editorPopover.isEditable {
+            editorPopover.end(.commit(nil))
+            return false
+        }
+        return super.performKeyEquivalent(with: event)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+ConnectionScope.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+ConnectionScope.swift
new file mode 100644
index 0000000000..bdbf6df778
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+ConnectionScope.swift
@@ -0,0 +1,35 @@
+//
+//  DataGridViewController+ConnectionScope.swift
+//  TablePro
+//
+
+import AppKit
+
+// The editors that read the database learn the connection from the configuration the owner sets.
+extension DataGridViewController {
+    var foreignKeyScope: DatabaseScope? {
+        model.configuration.traits.connectionScope
+    }
+
+    var editingDatabaseType: DatabaseType? {
+        model.configuration.traits.databaseType
+    }
+
+    var userDefinedTypeScope: DatabaseScope? {
+        let traits = model.configuration.traits
+        return traits.looksUpUserDefinedTypes ? traits.connectionScope : nil
+    }
+
+    // MySQL doubles a backslash as well as a quote, which the shared helper does not.
+    func stringLiteralEscaper() -> (String) -> String {
+        guard let connectionId = model.configuration.traits.connectionScope?.connectionId,
+              let driver = DatabaseManager.shared.driver(for: connectionId) else {
+            return { SQLEscaping.escapeStringLiteral($0) }
+        }
+        return { driver.escapeStringLiteral($0) }
+    }
+
+    func canSearchForeignKeys(_ databaseType: DatabaseType) -> Bool {
+        PluginManager.shared.sqlDialect(for: databaseType) != nil
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+EditCells.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+EditCells.swift
new file mode 100644
index 0000000000..9af494d523
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+EditCells.swift
@@ -0,0 +1,216 @@
+//
+//  DataGridViewController+EditCells.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+extension DataGridViewController {
+    // MARK: - Cells
+
+    func editCell(at coord: GridCoord) -> DataGridEditCell? {
+        guard let row = model.row(at: coord.row), let column = model.columns.column(at: coord.displayColumn) else { return nil }
+        return DataGridEditCell(coord: coord, row: row, column: column)
+    }
+
+    func editCell(for target: DataGridEditTarget) -> DataGridEditCell? {
+        guard let row = model.displayIndex(of: target.rowID),
+              let column = model.columns.displayPosition(of: target.columnID) else { return nil }
+        return editCell(at: GridCoord(row: row, displayColumn: column))
+    }
+
+    // A replaced result reuses RowIDs for other records.
+    func editCell(for held: DataGridHeldRow) -> DataGridEditCell? {
+        guard let cell = editCell(for: held.target), cell.row.values == held.values else { return nil }
+        return cell
+    }
+
+    func heldRow(_ cell: DataGridEditCell) -> DataGridHeldRow {
+        DataGridHeldRow(target: cell.target, values: cell.row.values)
+    }
+
+    func isRowDeleted(_ rowID: RowID) -> Bool {
+        model.changeState?.isRowDeleted(rowID) == true
+    }
+
+    func textEditableValue(of cell: DataGridEditCell) -> String? {
+        guard model.configuration.isEditable,
+              !isRowDeleted(cell.row.id),
+              model.isColumnWritable(cell.column),
+              !cell.isUnloaded,
+              cell.column.type?.isBlobType != true,
+              cell.value.asBytes == nil else { return nil }
+        return cell.value.asText ?? ""
+    }
+
+    func cellContext(for cell: DataGridEditCell) -> CellContext {
+        let name = cell.column.name
+        let rows = model.rows
+        let value = cell.value
+        // A column the owner locked is not read-only content: it refuses with a beep instead (#2726).
+        let serverOwned = model.configuration.traits.immutableColumns.contains(name)
+            || model.changeState?.generatedColumns.contains(name) == true
+        return CellContext(
+            columnType: cell.column.type,
+            value: value.asText,
+            isTableEditable: model.configuration.isEditable,
+            isRowDeleted: isRowDeleted(cell.row.id),
+            isImmutableColumn: serverOwned,
+            isBinaryValue: value.asBytes != nil,
+            isForeignKey: rows.columnForeignKeys[name] != nil,
+            displayFormatOverride: model.displayFormat(for: cell.column),
+            detectedContent: CellValueContentDetector.detect(value)
+        )
+    }
+
+    // A grid that refuses a keystroke in silence reads as broken (#2726).
+    func refuseEdit(of column: DataGridColumn) {
+        let configuration = model.configuration
+        if configuration.lockedColumns.contains(column.name) || (!configuration.isEditable && configuration.editRefusalMessage != nil) {
+            NSSound.beep()
+        }
+    }
+
+    // MARK: - Geometry
+
+    // A frozen column's home in the main table lies under the frozen pane.
+    func editingPane(forDisplayColumn displayColumn: Int) -> DataGridPane {
+        if !frozen.scrollView.isHidden, frozen.tableIndex(forDisplayPosition: displayColumn, columns: model.columns) != nil {
+            return frozen
+        }
+        return main
+    }
+
+    func cellFrame(of coord: GridCoord) -> (pane: DataGridPane, tableIndex: Int, rect: NSRect)? {
+        let pane = editingPane(forDisplayColumn: coord.displayColumn)
+        let table = pane.tableView
+        guard coord.row >= 0, coord.row < table.numberOfRows,
+              let index = pane.tableIndex(forDisplayPosition: coord.displayColumn, columns: model.columns),
+              index < table.numberOfColumns else { return nil }
+        return (pane, index, table.frameOfCell(atColumn: index, row: coord.row))
+    }
+
+    // MARK: - Commit
+
+    @discardableResult
+    static func commitEnteredText(_ text: String?, to target: DataGridEditTarget, in model: DataGridModel?) -> Bool {
+        guard let model else { return false }
+        if refusesEntry(text, for: target, in: model) {
+            NSSound.beep()
+            return false
+        }
+        model.commit(
+            [DataGridCellEdit(rowID: target.rowID, columnID: target.columnID, value: .enteredText(text))],
+            actionName: String(localized: "Edit Cell")
+        )
+        return true
+    }
+
+    @discardableResult
+    static func commitValue(_ value: PluginCellValue, to target: DataGridEditTarget, in model: DataGridModel?) -> Bool {
+        guard let model else { return false }
+        return model.commit(
+            [DataGridCellEdit(rowID: target.rowID, columnID: target.columnID, value: .value(value, isExpression: false))],
+            actionName: String(localized: "Edit Cell")
+        )
+    }
+
+    private static func refusesEntry(_ text: String?, for target: DataGridEditTarget, in model: DataGridModel) -> Bool {
+        let rows = model.rows
+        let ids = DataGridColumnSet.columnIDs(for: rows.columns)
+        guard let dataIndex = ids.firstIndex(of: target.columnID) else { return false }
+        let traits = model.configuration.traits
+        if let text, let databaseType = traits.databaseType,
+           CellEntry.typed(
+               text,
+               columnType: rows.editingColumnType(at: dataIndex),
+               databaseType: databaseType,
+               writer: traits.cellWriterSupport
+           ) != nil {
+            return false
+        }
+        return rows.enteredValue(text, forColumn: dataIndex) == nil
+    }
+
+    // MARK: - Unloaded values
+
+    // A value left on the server reads NULL until loaded (#3758); the retry finds the record by identity.
+    func loadsUnloadedValue(
+        of cell: DataGridEditCell,
+        then retry: @escaping @MainActor (DataGridViewController) -> Void
+    ) -> Bool {
+        guard cell.isUnloaded else { return true }
+        guard let actions = model.actions else {
+            NSSound.beep()
+            return false
+        }
+        let target = cell.target
+        actions.gridLoadUnloadedValues(rowIDs: [target.rowID], columns: IndexSet(integer: cell.column.dataIndex)) { [weak self] loaded in
+            guard let self else { return }
+            guard loaded, let current = self.editCell(for: target), !current.isUnloaded else {
+                NSSound.beep()
+                return
+            }
+            retry(self)
+        }
+        return false
+    }
+
+    // MARK: - Opening
+
+    func openEditor(for target: DataGridEditTarget) {
+        guard let cell = editCell(for: target) else { return }
+        openEditor(at: cell.coord)
+    }
+
+    func openEditor(at coord: GridCoord) {
+        guard let cell = editCell(at: coord) else { return }
+        let target = cell.target
+        guard loadsUnloadedValue(of: cell, then: { $0.openEditor(for: target) }) else { return }
+        let mode = CellInteractionResolver().resolve(cellContext(for: cell))
+        switch mode {
+        case .blocked:
+            return
+        case .viewText(let value):
+            showTextPopover(for: cell, text: value, isEditable: false)
+        case .viewJson:
+            showJSONViewer(for: cell)
+        case .viewBlob:
+            showBlobPopover(for: cell, isEditable: false)
+        case .viewPhpSerialized:
+            showPhpViewer(for: cell)
+        case .viewBinaryValue(let format):
+            showBinaryValueViewer(for: cell, format: format)
+        case .viewVector, .editVector:
+            showVectorPopover(for: cell, isEditable: mode == .editVector && textEditableValue(of: cell) != nil)
+        case .viewSvg, .editSvg:
+            showSvgPopover(for: cell, isEditable: mode == .editSvg && textEditableValue(of: cell) != nil)
+        case .editInline, .editText:
+            beginTextEditing(cell)
+        case .editForeignKey:
+            showForeignKeyPicker(for: cell)
+        case .editJson:
+            showJSONEditor(for: cell)
+        case .editBlob:
+            showBlobPopover(for: cell, isEditable: true)
+        }
+    }
+
+    @discardableResult
+    func beginTextEditing(_ cell: DataGridEditCell) -> Bool {
+        guard let original = textEditableValue(of: cell) else {
+            refuseEdit(of: cell.column)
+            return false
+        }
+        if CellInteractionResolver.editsInPopover(original) {
+            return beginTextPopoverEditing(cell, text: original, original: original, selection: nil)
+        }
+        return beginFieldEditing(cell, text: original, original: original, selection: nil, reveals: true)
+    }
+
+    func beginTextEditing(for target: DataGridEditTarget) {
+        guard let cell = editCell(for: target) else { return }
+        beginTextEditing(cell)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+EditorPopovers.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+EditorPopovers.swift
new file mode 100644
index 0000000000..7c4b14ce2c
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+EditorPopovers.swift
@@ -0,0 +1,138 @@
+//
+//  DataGridViewController+EditorPopovers.swift
+//  TablePro
+//
+
+import AppKit
+import SwiftUI
+
+extension DataGridViewController {
+    // An .applicationDefined popover the grid forgot would strand on screen.
+    @discardableResult
+    func presentTypedPopover<Content: View>(
+        for cell: DataGridEditCell,
+        edits: Bool,
+        contentSize: NSSize? = nil,
+        behavior: NSPopover.Behavior = .semitransient,
+        @ViewBuilder content: (_ dismiss: @escaping () -> Void) -> Content
+    ) -> NSPopover? {
+        endOpenTextEditor()
+        closeTypedPopover()
+        reveal(row: cell.coord.row, displayColumn: cell.coord.displayColumn)
+        guard let frame = cellFrame(of: cell.coord) else { return nil }
+        let popover = PopoverPresenter.make(contentSize: contentSize, behavior: behavior, content: content)
+        let state = editingState
+        state.typedPopover = popover
+        state.typedPopoverRow = heldRow(cell)
+        state.typedPopoverPane = frame.pane.kind
+        state.typedPopoverEdits = edits
+        state.typedPopoverObserver.onClose = { [weak self] closed in
+            self?.typedPopoverDidClose(closed)
+        }
+        popover.delegate = state.typedPopoverObserver
+        if frame.pane.tableView.window?.isVisible == true {
+            popover.show(relativeTo: frame.rect, of: frame.pane.tableView, preferredEdge: .maxY)
+        }
+        return popover
+    }
+
+    func closeTypedPopover() {
+        guard let popover = editingState.typedPopover else { return }
+        popover.close()
+        typedPopoverDidClose(popover)
+    }
+
+    private func typedPopoverDidClose(_ popover: NSPopover) {
+        let state = editingState
+        guard state.typedPopover === popover else { return }
+        let edits = state.typedPopoverEdits
+        state.typedPopover = nil
+        state.typedPopoverRow = nil
+        state.typedPopoverEdits = false
+        if edits {
+            model.editingDidEnd()
+        }
+    }
+
+    func closePoppedOutEditor() {
+        let state = editingState
+        state.poppedOutRow = nil
+        guard let window = state.poppedOutEditor else { return }
+        state.poppedOutEditor = nil
+        window.close()
+    }
+
+    func closeCellPopovers() {
+        if editingState.session == nil, let viewer = editingState.textPopover {
+            viewer.onEnd = nil
+            viewer.end(.cancel)
+            editingState.textPopover = nil
+        }
+        closeTypedPopover()
+        closePoppedOutEditor()
+        closeForeignKeyPreview()
+    }
+
+    func refreshHeldRows() {
+        let state = editingState
+        let rows = model.rows
+        func refreshed(_ held: DataGridHeldRow?) -> DataGridHeldRow? {
+            guard let held, let index = rows.index(of: held.target.rowID) else { return held }
+            return DataGridHeldRow(target: held.target, values: rows.rows[index].values)
+        }
+        state.typedPopoverRow = refreshed(state.typedPopoverRow)
+        state.poppedOutRow = refreshed(state.poppedOutRow)
+    }
+
+    // The detached window needs no cell to point at, so it stays while its record exists.
+    func followRowChangesWithPopovers() {
+        let state = editingState
+        if let session = state.session, session.editor == .textPopover, let popover = state.textPopover {
+            let held = DataGridHeldRow(target: session.target, values: session.originalRow)
+            if let cell = editCell(for: held), let frame = cellFrame(of: cell.coord), frame.pane.kind == session.pane {
+                state.session?.cell = cell.coord
+                // Moving a popover that is not on screen raises "window must exist" in NSPopover.
+                if popover.popover.isShown {
+                    popover.popover.positioningRect = frame.rect
+                }
+            } else {
+                finishTextPopover(.cancel)
+            }
+        } else if let viewer = state.textPopover, state.session == nil {
+            viewer.onEnd = nil
+            viewer.end(.cancel)
+            state.textPopover = nil
+        }
+        if let held = state.typedPopoverRow, let popover = state.typedPopover {
+            if let cell = editCell(for: held), let frame = cellFrame(of: cell.coord), frame.pane.kind == state.typedPopoverPane {
+                if popover.isShown {
+                    popover.positioningRect = frame.rect
+                }
+            } else {
+                closeTypedPopover()
+            }
+        }
+        if let held = state.poppedOutRow {
+            let rows = model.rows
+            let holds = rows.index(of: held.target.rowID).map { rows.rows[$0].values == held.values } ?? false
+            if !holds {
+                closePoppedOutEditor()
+            }
+        }
+        // The value filter lists the values it opened over, which a reload, insert or removal makes stale.
+        dismissValueFilterPopover()
+        followActiveCellWithForeignKeyPreview()
+    }
+}
+
+// A popover that closes itself (Escape, a click outside, its own Done) reaches the grid here.
+@MainActor
+final class DataGridPopoverCloseObserver: NSObject, NSPopoverDelegate {
+    var onClose: (@MainActor (NSPopover) -> Void)?
+
+    // Names the popover that closed: a replaced one finishes animating out after the next is shown.
+    func popoverDidClose(_ notification: Notification) {
+        guard let popover = notification.object as? NSPopover else { return }
+        onClose?(popover)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+FieldEditing.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+FieldEditing.swift
new file mode 100644
index 0000000000..b5363f8f42
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+FieldEditing.swift
@@ -0,0 +1,403 @@
+//
+//  DataGridViewController+FieldEditing.swift
+//  TablePro
+//
+
+import AppKit
+
+// Probe P1: set the session, reload the one cell so viewFor mounts the field, editColumn; reload it again to unmount.
+extension DataGridViewController {
+    // MARK: - Field
+
+    @discardableResult
+    func beginFieldEditing(
+        _ cell: DataGridEditCell,
+        text: String,
+        original: String,
+        selection: NSRange?,
+        reveals: Bool
+    ) -> Bool {
+        endOpenTextEditor()
+        closeTypedPopover()
+        unmountEditingCell()
+        if reveals {
+            reveal(row: cell.coord.row, displayColumn: cell.coord.displayColumn)
+        }
+        guard let frame = cellFrame(of: cell.coord) else { return false }
+        let table = frame.pane.tableView
+        let state = editingState
+        state.session = DataGridEditSession(
+            target: cell.target,
+            editor: .field,
+            originalText: original,
+            originalRow: cell.row.values,
+            pane: frame.pane.kind,
+            cell: cell.coord
+        )
+        let cellView = state.editingCellView
+        cellView.prepare(
+            text: text,
+            font: ThemeEngine.shared.dataGridFonts.regular,
+            scope: model.themeScope,
+            columnName: cell.column.name,
+            delegate: state.fieldDelegate
+        )
+        state.fieldDelegate.controller = self
+        table.reloadData(forRowIndexes: IndexSet(integer: cell.coord.row), columnIndexes: IndexSet(integer: frame.tableIndex))
+        guard table.view(atColumn: frame.tableIndex, row: cell.coord.row, makeIfNecessary: true) === cellView else {
+            state.session = nil
+            return false
+        }
+        cellView.layoutField()
+        table.editColumn(frame.tableIndex, row: cell.coord.row, with: nil, select: true)
+        // The frozen table refuses first responder, which editColumn may ask of it; the field itself never does.
+        if cellView.field.currentEditor() == nil {
+            view.window?.makeFirstResponder(cellView.field)
+        }
+        guard let editor = cellView.field.currentEditor() as? NSTextView else {
+            state.session = nil
+            unmountEditingCell()
+            return false
+        }
+        if let selection {
+            let length = (editor.string as NSString).length
+            let location = min(max(selection.location, 0), length)
+            editor.setSelectedRange(NSRange(location: location, length: min(max(selection.length, 0), length - location)))
+        }
+        redrawRows(IndexSet(integer: cell.coord.row))
+        return true
+    }
+
+    // abortEditing sends no end notification, so the commit is made here.
+    @discardableResult
+    func finishFieldEditing(commit: Bool, then movement: CellEditorMovement? = nil) -> Bool {
+        guard let session = editingState.session, session.editor == .field else { return true }
+        let text = currentFieldText()
+        endFieldSession()
+        unmountEditingCell()
+        restoreGridFocus()
+        let committed = commit ? commitText(text, for: session) : true
+        model.editingDidEnd()
+        if let movement, committed {
+            continueEditing(from: session.target, movement)
+        }
+        return committed
+    }
+
+    func currentFieldText() -> String {
+        let field = editingState.editingCellView.field
+        return (field.currentEditor() as? NSTextView)?.string ?? field.stringValue
+    }
+
+    private func currentFieldSelection() -> NSRange {
+        let field = editingState.editingCellView.field
+        if let editor = field.currentEditor() as? NSTextView {
+            return editor.selectedRange()
+        }
+        return NSRange(location: (field.stringValue as NSString).length, length: 0)
+    }
+
+    private func endFieldSession() {
+        let state = editingState
+        guard let session = state.session, session.editor == .field else { return }
+        state.session = nil
+        state.isEndingField = true
+        state.editingCellView.field.abortEditing()
+        state.isEndingField = false
+        redrawRows(IndexSet(integer: session.cell.row))
+    }
+
+    // An insert or a column move can carry the field elsewhere without asking.
+    func unmountEditingCell() {
+        let cellView = editingState.editingCellView
+        guard let table = cellView.enclosingTableView else { return }
+        let row = table.row(for: cellView)
+        let column = table.column(for: cellView)
+        guard row >= 0, column >= 0, row < table.numberOfRows, column < table.numberOfColumns else {
+            cellView.removeFromSuperview()
+            return
+        }
+        table.reloadData(forRowIndexes: IndexSet(integer: row), columnIndexes: IndexSet(integer: column))
+    }
+
+    // After an abort the window holds first responder; the grid keeps the keyboard it had.
+    private func restoreGridFocus() {
+        guard let window = view.window, window.firstResponder === window || window.firstResponder == nil else { return }
+        window.makeFirstResponder(main.tableView)
+    }
+
+    private func commitText(_ text: String, for session: DataGridEditSession) -> Bool {
+        guard text != session.originalText else { return true }
+        return Self.commitEnteredText(text, to: session.target, in: model)
+    }
+
+    // MARK: - Field editor callbacks
+
+    func fieldEditor(_ textView: NSTextView, doCommandBy selector: Selector) -> Bool {
+        guard editingState.session?.editor == .field else { return false }
+        switch selector {
+        case #selector(NSResponder.insertNewline(_:)):
+            finishFieldEditing(commit: true)
+            return true
+        case #selector(NSResponder.cancelOperation(_:)):
+            finishFieldEditing(commit: false)
+            return true
+        case #selector(NSResponder.insertTab(_:)):
+            guard !textView.hasMarkedText() else { return true }
+            finishFieldEditing(commit: true, then: .tab)
+            return true
+        case #selector(NSResponder.insertBacktab(_:)):
+            guard !textView.hasMarkedText() else { return true }
+            finishFieldEditing(commit: true, then: .backtab)
+            return true
+        case #selector(NSResponder.moveUp(_:)), #selector(NSResponder.moveDown(_:)):
+            let movement: CellEditorMovement = selector == #selector(NSResponder.moveUp(_:)) ? .up : .down
+            guard !textView.hasMarkedText() else { return false }
+            let exit = CellEditorArrowExit(text: textView.string as NSString, selection: textView.selectedRange())
+            guard movement == .up ? exit.canExitUp : exit.canExitDown else { return false }
+            finishFieldEditing(commit: true, then: movement)
+            return true
+        case #selector(NSResponder.insertNewlineIgnoringFieldEditor(_:)):
+            moveFieldEditToPopover(inserting: "\n", replacing: textView.selectedRange())
+            return true
+        default:
+            return false
+        }
+    }
+
+    // NSTextMovement.other: focus moved away or the cell went; the text is kept.
+    func fieldDidEndEditing() {
+        let state = editingState
+        guard !state.isEndingField, let session = state.session, session.editor == .field else { return }
+        let text = state.editingCellView.field.stringValue
+        endFieldSession()
+        // The end can arrive inside a reload or a first-responder change, which a reload of the cell must not re-enter.
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.editingState.session?.editor != .field else { return }
+            self.unmountEditingCell()
+        }
+        if state.isApplyingChange {
+            state.deferredCommit = (session, text)
+        } else {
+            _ = commitText(text, for: session)
+            model.editingDidEnd()
+        }
+    }
+
+    func flushDeferredCommit() {
+        guard let deferred = editingState.deferredCommit else { return }
+        editingState.deferredCommit = nil
+        _ = commitText(deferred.text, for: deferred.session)
+        model.editingDidEnd()
+    }
+
+    // Pasted or dropped text with a line break goes to the popover editor, which keeps the break.
+    func fieldEditorInsertsLines(_ text: String, replacing range: NSRange) -> Bool {
+        guard editingState.session?.editor == .field else { return false }
+        moveFieldEditToPopover(inserting: text, replacing: range)
+        return true
+    }
+
+    private func moveFieldEditToPopover(inserting insertion: String, replacing selection: NSRange) {
+        guard let session = editingState.session, session.editor == .field else { return }
+        let text = currentFieldText() as NSString
+        let location = min(max(selection.location, 0), text.length)
+        let replaced = NSRange(location: location, length: min(max(selection.length, 0), text.length - location))
+        let combined = text.replacingCharacters(in: replaced, with: insertion)
+        endFieldSession()
+        unmountEditingCell()
+        guard let cell = editCell(for: session.target) else {
+            model.editingDidEnd()
+            return
+        }
+        let caret = NSRange(location: location + (insertion as NSString).length, length: 0)
+        if !beginTextPopoverEditing(cell, text: combined, original: session.originalText, selection: caret) {
+            model.editingDidEnd()
+        }
+    }
+
+    // MARK: - Structural changes
+
+    func suspendFieldEditing(unmounting: Bool) {
+        let state = editingState
+        guard let session = state.session, session.editor == .field else { return }
+        let text = currentFieldText()
+        let selection = currentFieldSelection()
+        endFieldSession()
+        if unmounting {
+            unmountEditingCell()
+        }
+        state.suspendedField = DataGridSuspendedFieldEdit(session: session, text: text, selection: selection)
+    }
+
+    // Hidden by a filter, the record keeps what was typed; gone, or replaced at its RowID, it loses it.
+    func resumeFieldEditing() {
+        let state = editingState
+        guard let suspended = state.suspendedField else { return }
+        state.suspendedField = nil
+        let session = suspended.session
+        let held = DataGridHeldRow(target: session.target, values: session.originalRow)
+        if let cell = editCell(for: held), textEditableValue(of: cell) != nil,
+           beginFieldEditing(cell, text: suspended.text, original: session.originalText, selection: suspended.selection, reveals: false) {
+            return
+        }
+        restoreGridFocus()
+        let rows = model.rows
+        if let index = rows.index(of: session.target.rowID), rows.rows[index].values == session.originalRow {
+            _ = commitText(suspended.text, for: session)
+        } else if suspended.text != session.originalText {
+            NSSound.beep()
+        }
+        model.editingDidEnd()
+    }
+
+    // MARK: - Moving on
+
+    // Up and Down hold the column and stop at the ends rather than wrap.
+    func continueEditing(from target: DataGridEditTarget, _ movement: CellEditorMovement) {
+        guard let current = editCell(for: target)?.coord else { return }
+        let context = selectionContext
+        let next: GridCoord
+        switch movement {
+        case .tab, .backtab:
+            let moved = GridSelectionReducer.tab(GridSelectionReducer.single(current), forward: movement == .tab, in: context)
+            guard let active = moved.activeCell else { return }
+            next = active
+        case .up:
+            next = GridCoord(row: current.row - 1, displayColumn: current.displayColumn)
+        case .down:
+            next = GridCoord(row: current.row + 1, displayColumn: current.displayColumn)
+        }
+        guard next != current, next.row >= 0, next.row < context.rowCount else { return }
+        model.selectCell(next)
+        mirrorSelection()
+        revealActiveCell()
+        guard let cell = editCell(at: next), textEditableValue(of: cell) != nil else { return }
+        let nextTarget = cell.target
+        guard loadsUnloadedValue(of: cell, then: { $0.beginTextEditing(for: nextTarget) }) else { return }
+        beginTextEditing(cell)
+    }
+
+    // MARK: - Text popover
+
+    @discardableResult
+    func beginTextPopoverEditing(_ cell: DataGridEditCell, text: String, original: String, selection: NSRange?) -> Bool {
+        showTextPopover(for: cell, text: text, isEditable: true, original: original, selection: selection)
+    }
+
+    @discardableResult
+    func showTextPopover(
+        for cell: DataGridEditCell,
+        text: String,
+        isEditable: Bool,
+        original: String? = nil,
+        selection: NSRange? = nil
+    ) -> Bool {
+        endOpenTextEditor()
+        closeTypedPopover()
+        reveal(row: cell.coord.row, displayColumn: cell.coord.displayColumn)
+        guard let frame = cellFrame(of: cell.coord) else { return false }
+        let popover = DataGridTextEditorPopover(
+            text: text,
+            isEditable: isEditable,
+            cellWidth: frame.rect.width,
+            scope: model.themeScope
+        )
+        let state = editingState
+        if isEditable {
+            state.session = DataGridEditSession(
+                target: cell.target,
+                editor: .textPopover,
+                originalText: original ?? text,
+                originalRow: cell.row.values,
+                pane: frame.pane.kind,
+                cell: cell.coord
+            )
+        }
+        state.textPopover = popover
+        popover.onEnd = { [weak self, weak popover] ending, text in
+            guard let self, let popover else { return }
+            self.textPopoverDidEnd(popover, ending: ending, text: text)
+        }
+        popover.show(relativeTo: frame.rect, of: frame.pane.tableView, selection: selection)
+        return true
+    }
+
+    @discardableResult
+    func finishTextPopover(_ ending: DataGridTextEditorPopover.Ending) -> Bool {
+        guard let popover = editingState.textPopover else { return true }
+        var committed = true
+        let session = editingState.session
+        popover.onEnd = nil
+        popover.end(ending)
+        editingState.textPopover = nil
+        guard let session, session.editor == .textPopover else { return true }
+        editingState.session = nil
+        if case .commit = ending {
+            committed = commitText(popover.textView.string, for: session)
+        }
+        model.editingDidEnd()
+        return committed
+    }
+
+    private func textPopoverDidEnd(_ popover: DataGridTextEditorPopover, ending: DataGridTextEditorPopover.Ending, text: String) {
+        let state = editingState
+        guard state.textPopover === popover else { return }
+        state.textPopover = nil
+        guard let session = state.session, session.editor == .textPopover else { return }
+        state.session = nil
+        var committed = true
+        if case .commit = ending {
+            committed = commitText(text, for: session)
+        }
+        model.editingDidEnd()
+        if case .commit(let movement?) = ending, committed {
+            continueEditing(from: session.target, movement)
+        }
+    }
+
+    func endOpenTextEditor() {
+        guard let session = editingState.session else {
+            if let viewer = editingState.textPopover {
+                viewer.onEnd = nil
+                viewer.end(.cancel)
+                editingState.textPopover = nil
+            }
+            return
+        }
+        switch session.editor {
+        case .field:
+            finishFieldEditing(commit: true)
+        case .textPopover:
+            finishTextPopover(.commit(nil))
+        }
+    }
+}
+
+private extension NSView {
+    var enclosingTableView: NSTableView? {
+        var ancestor = superview
+        while let current = ancestor {
+            if let table = current as? NSTableView { return table }
+            ancestor = current.superview
+        }
+        return nil
+    }
+}
+
+@MainActor
+final class DataGridFieldEditorDelegate: NSObject, NSTextFieldDelegate {
+    weak var controller: DataGridViewController?
+
+    func control(_ control: NSControl, textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
+        controller?.fieldEditor(textView, doCommandBy: commandSelector) ?? false
+    }
+
+    func fieldEditorInsertsLines(_ text: String, replacing range: NSRange) -> Bool {
+        controller?.fieldEditorInsertsLines(text, replacing: range) ?? false
+    }
+
+    func controlTextDidEndEditing(_ obj: Notification) {
+        controller?.fieldDidEndEditing()
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+ForeignKeys.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+ForeignKeys.swift
new file mode 100644
index 0000000000..7bf6731a9b
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+ForeignKeys.swift
@@ -0,0 +1,151 @@
+//
+//  DataGridViewController+ForeignKeys.swift
+//  TablePro
+//
+
+import AppKit
+import SwiftUI
+import TableProPluginKit
+
+extension DataGridViewController {
+    func foreignKeyInfo(of cell: DataGridEditCell) -> ForeignKeyInfo? {
+        model.rows.columnForeignKeys[cell.column.name]
+    }
+
+    // MARK: - Follow
+
+    func followForeignKey(at coord: GridCoord, opensNewTab: Bool) {
+        guard let cell = editCell(at: coord), let info = foreignKeyInfo(of: cell),
+              let value = cell.value.asText, !value.isEmpty else { return }
+        model.actions?.gridNavigateForeignKey(value: value, info: info, intent: opensNewTab ? .newTab : .follow)
+    }
+
+    // MARK: - Picker
+
+    // The picker writes one column, so a column of a composite key keeps the text editor.
+    func canChooseForeignKeyRow(for cell: DataGridEditCell) -> Bool {
+        guard let info = foreignKeyInfo(of: cell), textEditableValue(of: cell) != nil else { return false }
+        return !ForeignKeyConstraintSpan.isMultiColumn(info, among: model.rows.columnForeignKeys)
+    }
+
+    // Choose <table> Row…: the picker, whatever editor the cell's content would otherwise open.
+    func chooseForeignKeyRow(at coord: GridCoord) {
+        guard let cell = editCell(at: coord) else { return }
+        let target = cell.target
+        guard loadsUnloadedValue(of: cell, then: { controller in
+            guard let cell = controller.editCell(for: target) else { return }
+            controller.showForeignKeyPicker(for: cell)
+        }) else { return }
+        showForeignKeyPicker(for: cell)
+    }
+
+    // With no dialect to search in or no connection, the cell keeps the text editor.
+    func showForeignKeyPicker(for cell: DataGridEditCell) {
+        guard canChooseForeignKeyRow(for: cell),
+              let info = foreignKeyInfo(of: cell),
+              let databaseType = editingDatabaseType,
+              canSearchForeignKeys(databaseType),
+              let scope = foreignKeyScope else {
+            beginTextEditing(cell)
+            return
+        }
+        let commit = enteredTextCommit(for: cell)
+        let current = cell.value.asText
+        let isNullable = model.rows.columnNullable[cell.column.name] ?? true
+        presentTypedPopover(for: cell, edits: true) { dismiss in
+            ForeignKeyPickerView(
+                scope: scope,
+                databaseType: databaseType,
+                fkInfo: info,
+                currentValue: current,
+                isNullable: isNullable,
+                onCommit: { commit($0) },
+                onDismiss: dismiss
+            )
+        }
+    }
+
+    // MARK: - Preview
+
+    func canPreviewForeignKey(at coord: GridCoord) -> Bool {
+        guard let cell = editCell(at: coord), foreignKeyInfo(of: cell) != nil,
+              cell.value.asText?.isEmpty == false else { return false }
+        return editingDatabaseType != nil && foreignKeyScope != nil
+    }
+
+    func previewForeignKey(at coord: GridCoord) {
+        guard canPreviewForeignKey(at: coord),
+              let cell = editCell(at: coord),
+              let info = foreignKeyInfo(of: cell),
+              let databaseType = editingDatabaseType,
+              let scope = foreignKeyScope else { return }
+        closeForeignKeyPreview()
+        reveal(row: coord.row, displayColumn: coord.displayColumn)
+        guard let frame = cellFrame(of: coord), frame.pane.tableView.window?.isVisible == true else { return }
+        let previewModel = FKPreviewModel(cellValue: cell.value.asText, fkInfo: info)
+        let popover = PopoverPresenter.show(
+            relativeTo: frame.rect,
+            of: frame.pane.tableView,
+            contentSize: NSSize(width: 380, height: 400)
+        ) { [weak self] dismiss in
+            ForeignKeyPreviewView(
+                model: previewModel,
+                scope: scope,
+                databaseType: databaseType,
+                onNavigate: { [previewModel] in
+                    dismiss()
+                    guard let value = previewModel.cellValue else { return }
+                    self?.model.actions?.gridNavigateForeignKey(value: value, info: previewModel.fkInfo, intent: .follow)
+                },
+                onDismiss: dismiss
+            )
+        }
+        let state = editingState
+        state.foreignKeyPreview = popover
+        state.foreignKeyPreviewModel = previewModel
+        state.foreignKeyPreviewColumn = cell.column.id
+        state.foreignKeyPreviewPane = frame.pane.kind
+    }
+
+    func closeForeignKeyPreview() {
+        let state = editingState
+        let popover = state.foreignKeyPreview
+        state.foreignKeyPreview = nil
+        state.foreignKeyPreviewModel = nil
+        state.foreignKeyPreviewColumn = nil
+        popover?.close()
+    }
+
+    func followActiveCellWithForeignKeyPreview() {
+        let state = editingState
+        guard let popover = state.foreignKeyPreview else { return }
+        guard popover.isShown,
+              let previewModel = state.foreignKeyPreviewModel,
+              let active = model.selection.activeCell,
+              let cell = editCell(at: active),
+              cell.column.id == state.foreignKeyPreviewColumn,
+              let info = foreignKeyInfo(of: cell),
+              let frame = cellFrame(of: active),
+              frame.pane.kind == state.foreignKeyPreviewPane else {
+            closeForeignKeyPreview()
+            return
+        }
+        previewModel.cellValue = cell.value.asText
+        previewModel.fkInfo = info
+        popover.positioningRect = frame.rect
+    }
+
+    // MARK: - Menu
+
+    @objc func previewFKReference(_ sender: Any?) {
+        toggleForeignKeyPreview()
+    }
+
+    // validateMenuItem asks this first; nil leaves the item to the other commands.
+    func validateEditingCommand(_ item: NSValidatedUserInterfaceItem) -> Bool? {
+        guard item.action == #selector(previewFKReference(_:)) else { return nil }
+        if editingState.foreignKeyPreview?.isShown == true { return true }
+        guard let active = model.selection.activeCell else { return false }
+        return canPreviewForeignKey(at: active)
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+TypedEditors.swift b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+TypedEditors.swift
new file mode 100644
index 0000000000..a0a4227f07
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/Editing/DataGridViewController+TypedEditors.swift
@@ -0,0 +1,432 @@
+//
+//  DataGridViewController+TypedEditors.swift
+//  TablePro
+//
+
+import AppKit
+import SwiftUI
+import TableProPluginKit
+
+extension DataGridViewController {
+    // MARK: - Chevron
+
+    func openChevronEditor(for target: DataGridEditTarget) {
+        guard let cell = editCell(for: target) else { return }
+        openChevronEditor(at: cell.coord)
+    }
+
+    func openChevronEditor(at coord: GridCoord) {
+        guard model.configuration.isEditable, let cell = editCell(at: coord), !isRowDeleted(cell.row.id) else { return }
+        guard model.isColumnWritable(cell.column) else {
+            refuseEdit(of: cell.column)
+            return
+        }
+        let target = cell.target
+        guard loadsUnloadedValue(of: cell, then: { $0.openChevronEditor(for: target) }) else { return }
+
+        let configuration = model.configuration
+        let dataIndex = cell.column.dataIndex
+        if configuration.dropdownColumns?.contains(dataIndex) == true {
+            showDropdownMenu(for: cell)
+            return
+        }
+        if configuration.typePickerColumns?.contains(dataIndex) == true {
+            showTypePicker(for: cell)
+            return
+        }
+        guard let columnType = cell.column.type else { return }
+        let allowedValues = model.rows.columnEnumValues[cell.column.name] ?? []
+        if columnType.isBooleanType {
+            showDropdownMenu(for: cell)
+        } else if columnType.supportsElementEditing {
+            showArrayEditor(for: cell)
+        } else if columnType.isVectorType {
+            showVectorPopover(for: cell, isEditable: textEditableValue(of: cell) != nil)
+        } else if !allowedValues.isEmpty {
+            if columnType.isSetType {
+                showSetMenu(for: cell, allowedValues: allowedValues)
+            } else {
+                showEnumMenu(for: cell, allowedValues: allowedValues)
+            }
+        } else if columnType.isJsonType {
+            showJSONEditor(for: cell)
+        } else if columnType.isBlobType {
+            showBlobPopover(for: cell, isEditable: true)
+        } else if columnType.isDateType {
+            if opensDatePicker(cell.value.asText) {
+                showDateTimePicker(for: cell, columnType: columnType)
+            } else {
+                beginTextEditing(cell)
+            }
+        } else if columnType.isEnumOrSetType {
+            beginTextEditing(cell)
+        }
+    }
+
+    // MARK: - Commit closures
+
+    // Never a display position: an open editor outlives a filter or a sort (interaction 5).
+    func enteredTextCommit(for cell: DataGridEditCell) -> (String?) -> Void {
+        let target = cell.target
+        return { [weak self, weak model = self.model] text in
+            Self.commitEnteredText(text, to: target, in: model)
+            self?.refreshHeldRows()
+        }
+    }
+
+    func valueCommit(for cell: DataGridEditCell) -> (PluginCellValue) -> Void {
+        let target = cell.target
+        return { [weak self, weak model = self.model] value in
+            Self.commitValue(value, to: target, in: model)
+            self?.refreshHeldRows()
+        }
+    }
+
+    // MARK: - Menus
+
+    func showDropdownMenu(for cell: DataGridEditCell) {
+        reveal(row: cell.coord.row, displayColumn: cell.coord.displayColumn)
+        guard let frame = cellFrame(of: cell.coord) else { return }
+        let configuration = model.configuration
+        let dataIndex = cell.column.dataIndex
+        let current = cell.value.asText
+        // A list that depends on the row cannot live in a dictionary keyed by column.
+        let custom = model.dataSource?.gridMenuOptions(for: cell.row.id, column: cell.column)
+            ?? configuration.customDropdownOptions?[dataIndex]
+        let options: [GridMenuOption]
+        if let custom {
+            options = custom
+        } else if configuration.dropdownColumns?.contains(dataIndex) == true {
+            return
+        } else {
+            options = GridMenuOption.values(configuration.traits.usesTrueFalseBooleans ? ["true", "false"] : ["1", "0"])
+        }
+
+        let commit = enteredTextCommit(for: cell)
+        let target = cell.target
+        let menu = NSMenu()
+        for option in options {
+            switch option {
+            case .sectionHeader(let title):
+                menu.addItem(NSMenuItem.sectionHeaderCompat(title: title))
+            case .value(let title, let sql):
+                menu.addItem(DataGridMenuAction.item(title, state: sql == current ? .on : .off) { commit(sql) })
+            case .clear(let title):
+                menu.addItem(DataGridMenuAction.item(title, state: current == nil ? .on : .off) { commit(nil) })
+            case .custom(let title):
+                menu.addItem(DataGridMenuAction.item(title) { [weak self] in
+                    guard let self, let cell = self.editCell(for: target) else { return }
+                    self.showCustomValuePopover(for: cell)
+                })
+            }
+        }
+        let isNullable = model.rows.columnNullable[cell.column.name] ?? true
+        if isNullable, custom == nil {
+            menu.addItem(.separator())
+            menu.addItem(DataGridMenuAction.item(String(localized: "Set NULL"), state: current == nil ? .on : .off) { commit(nil) })
+        }
+        menu.popUp(positioning: nil, at: NSPoint(x: frame.rect.minX, y: frame.rect.maxY), in: frame.pane.tableView)
+    }
+
+    func showEnumMenu(for cell: DataGridEditCell, allowedValues: [String]) {
+        reveal(row: cell.coord.row, displayColumn: cell.coord.displayColumn)
+        guard let frame = cellFrame(of: cell.coord) else { return }
+        let rows = model.rows
+        let name = cell.column.name
+        // A string default arrives as the SQL after DEFAULT, quoted; the picker matches unquoted tokens.
+        let storedDefault = rows.columnDefaults[name] ?? nil
+        let defaultValue = storedDefault.flatMap(SQLStringLiteral.unquoted) ?? storedDefault
+        let commit = enteredTextCommit(for: cell)
+        EnumMenuPicker.presentEnum(
+            relativeTo: frame.rect,
+            in: frame.pane.tableView,
+            allowedValues: allowedValues,
+            currentValue: cell.value.asText,
+            isNullable: rows.columnNullable[name] ?? true,
+            defaultValue: defaultValue
+        ) { commit($0) }
+    }
+
+    func showSetMenu(for cell: DataGridEditCell, allowedValues: [String]) {
+        reveal(row: cell.coord.row, displayColumn: cell.coord.displayColumn)
+        guard let frame = cellFrame(of: cell.coord) else { return }
+        let commit = enteredTextCommit(for: cell)
+        EnumMenuPicker.presentSet(
+            relativeTo: frame.rect,
+            in: frame.pane.tableView,
+            allowedValues: allowedValues,
+            currentCsv: cell.value.asText
+        ) { commit($0) }
+    }
+
+    // MARK: - Popovers
+
+    func showCustomValuePopover(for cell: DataGridEditCell) {
+        let commit = enteredTextCommit(for: cell)
+        let escape = stringLiteralEscaper()
+        let prefix = SQLStringLiteralPrefix.forDatabaseType(editingDatabaseType)
+        let current = cell.value.asText ?? ""
+        presentTypedPopover(for: cell, edits: true) { dismiss in
+            CustomValueContentView(
+                initialValue: current,
+                escapeStringLiteral: escape,
+                stringLiteralPrefix: prefix,
+                onCommit: { commit($0) },
+                onDismiss: dismiss
+            )
+        }
+    }
+
+    func showTypePicker(for cell: DataGridEditCell) {
+        let commit = enteredTextCommit(for: cell)
+        let databaseType = editingDatabaseType ?? .mysql
+        let scope = userDefinedTypeScope
+        let current = cell.value.asText ?? ""
+        presentTypedPopover(for: cell, edits: true) { dismiss in
+            UserDefinedTypeAwarePicker(scope: scope) { userDefinedTypes in
+                TypePickerContentView(
+                    databaseType: databaseType,
+                    currentValue: current,
+                    userDefinedTypes: userDefinedTypes,
+                    onCommit: { commit($0) },
+                    onDismiss: dismiss
+                )
+            }
+        }
+    }
+
+    // A date control has no unreadable state: a value the parser rejects keeps the text editor.
+    func opensDatePicker(_ value: String?) -> Bool {
+        guard let value, !value.trimmingCharacters(in: .whitespaces).isEmpty else { return true }
+        return DatabaseDateParser.parse(value) != nil
+    }
+
+    func showDateTimePicker(for cell: DataGridEditCell, columnType: ColumnType) {
+        let commit = enteredTextCommit(for: cell)
+        let parsed = DatabaseDateParser.parse(cell.value.asText)
+        // A fraction near one second rounds up, which would open past the stored value.
+        let initialDate = parsed?.wholeSecond ?? Date()
+        let timeZone = parsed?.timeZone ?? DateEditingService.defaultTimeZone
+        let components = DateEditingService.components(for: columnType)
+        presentTypedPopover(for: cell, edits: true) { dismiss in
+            DateTimePickerContentView(
+                initialDate: initialDate,
+                components: components,
+                timeZone: timeZone,
+                carriesItsOwnZone: parsed?.carriesItsOwnZone ?? false,
+                onCommit: { picked in
+                    guard picked != initialDate else { return }
+                    let text = parsed.map { DateEditingService.string(from: picked, like: $0, offered: components) }
+                        ?? DateEditingService.defaultString(from: picked, columnType: columnType)
+                    commit(text)
+                },
+                onDismiss: dismiss
+            )
+        }
+    }
+
+    func showArrayEditor(for cell: DataGridEditCell) {
+        guard let columnType = cell.column.type else { return }
+        let delimiter = PostgresArrayDelimiter.forColumn(columnType)
+        let value = cell.value
+        let literal: String?
+        if value.isNull {
+            literal = nil
+        } else {
+            let stored = value.asText ?? ""
+            guard PostgresArrayLiteralCodec.parse(stored, delimiter: delimiter) != nil else {
+                beginTextEditing(cell)
+                return
+            }
+            literal = stored
+        }
+        let rows = model.rows
+        let name = cell.column.name
+        let allowedValues = rows.columnEnumValues[name] ?? []
+        let isNullable = rows.columnNullable[name] ?? true
+        let elementEditor = columnType.arrayElementEditor ?? .scalar
+        let commit = enteredTextCommit(for: cell)
+        presentTypedPopover(for: cell, edits: true, behavior: .applicationDefined) { dismiss in
+            ArrayValueEditorView(
+                literal: literal,
+                allowedValues: allowedValues,
+                isNullable: isNullable,
+                delimiter: delimiter,
+                elementEditor: elementEditor,
+                onCommit: { commit($0) },
+                onDismiss: dismiss
+            )
+        }
+    }
+
+    func showVectorPopover(for cell: DataGridEditCell, isEditable: Bool) {
+        guard let literal = cell.value.asText, VectorLiteral.isVectorText(literal) else {
+            if isEditable { beginTextEditing(cell) }
+            return
+        }
+        let commit = enteredTextCommit(for: cell)
+        let expectedDimensions = cell.column.type?.vectorDimensions
+        presentTypedPopover(
+            for: cell,
+            edits: isEditable,
+            behavior: isEditable ? .applicationDefined : .semitransient
+        ) { dismiss in
+            VectorValueView(
+                literal: literal,
+                expectedDimensions: expectedDimensions,
+                isEditable: isEditable,
+                onCommit: { commit($0) },
+                onDismiss: dismiss
+            )
+        }
+    }
+
+    func showSvgPopover(for cell: DataGridEditCell, isEditable: Bool) {
+        let commit = enteredTextCommit(for: cell)
+        let value = cell.value.asText ?? ""
+        let name = cell.column.name
+        presentTypedPopover(for: cell, edits: isEditable) { dismiss in
+            SvgViewerContentView(
+                initialValue: value,
+                isEditable: isEditable,
+                onDismiss: dismiss,
+                onCommit: isEditable ? { commit($0) } : nil,
+                onPopOut: { text in
+                    dismiss()
+                    CellImageWindowController.open(data: Data(text.utf8), format: .svg, sourceKind: .markup, columnName: name)
+                }
+            )
+        }
+    }
+
+    func showJSONEditor(for cell: DataGridEditCell) {
+        let commit = enteredTextCommit(for: cell)
+        let current = cell.value.asText
+        let name = cell.column.name
+        let held = heldRow(cell)
+        presentTypedPopover(for: cell, edits: true, contentSize: NSSize(width: 560, height: 420)) { [weak self] dismiss in
+            JSONEditorContentView(
+                initialValue: current,
+                columnName: name,
+                onCommit: { commit($0) },
+                onDismiss: dismiss,
+                onPopOut: { text in
+                    dismiss()
+                    self?.popOutJSONEditor(text: text, baseline: current, columnName: name, held: held)
+                }
+            )
+        }
+    }
+
+    // Save compares against the stored value: the popover's text can hold an edit nothing committed yet.
+    private func popOutJSONEditor(text: String, baseline: String?, columnName: String, held: DataGridHeldRow) {
+        closePoppedOutEditor()
+        let target = held.target
+        let window = JSONViewerWindowController.open(
+            text: text,
+            baseline: baseline,
+            columnName: columnName,
+            isEditable: true,
+            onCommit: { [weak self, weak model = self.model] value in
+                Self.commitEnteredText(value, to: target, in: model)
+                self?.refreshHeldRows()
+            }
+        )
+        editingState.poppedOutEditor = window
+        editingState.poppedOutRow = held
+    }
+
+    func showJSONViewer(for cell: DataGridEditCell) {
+        let current = cell.value.asText
+        let name = cell.column.name
+        presentTypedPopover(for: cell, edits: false, contentSize: NSSize(width: 560, height: 360)) { dismiss in
+            JSONViewerContentView(
+                initialValue: current,
+                columnName: name,
+                onDismiss: dismiss,
+                onPopOut: { text in
+                    dismiss()
+                    JSONViewerWindowController.open(text: text, columnName: name, isEditable: false, onCommit: nil)
+                }
+            )
+        }
+    }
+
+    func showPhpViewer(for cell: DataGridEditCell) {
+        let current = cell.value.asText
+        let name = cell.column.name
+        presentTypedPopover(for: cell, edits: false, contentSize: NSSize(width: 560, height: 360)) { dismiss in
+            PhpViewerContentView(
+                initialValue: current,
+                columnName: name,
+                onDismiss: dismiss,
+                onPopOut: { text in
+                    dismiss()
+                    PhpViewerWindowController.open(text: text, columnName: name)
+                }
+            )
+        }
+    }
+
+    func showBinaryValueViewer(for cell: DataGridEditCell, format: BinaryValueFormat) {
+        let data: Data
+        switch cell.value {
+        case .null: return
+        case .bytes(let bytes): data = bytes
+        case .text(let text): data = text.storedBytes
+        }
+        let name = cell.column.name
+        presentTypedPopover(for: cell, edits: false, contentSize: NSSize(width: 560, height: 360)) { dismiss in
+            BinaryValueViewerView(
+                data: data,
+                format: format,
+                onPopOut: {
+                    dismiss()
+                    BinaryValueViewerWindowController.open(data: data, format: format, columnName: name)
+                }
+            )
+            .frame(width: 560)
+            .frame(minHeight: 200, maxHeight: 480)
+        }
+    }
+
+    func showBlobPopover(for cell: DataGridEditCell, isEditable: Bool) {
+        let commit = enteredTextCommit(for: cell)
+        let commitBytes = valueCommit(for: cell)
+        let current = blobText(of: cell.value)
+        let image = model.displayFormat(for: cell.column) == .raw ? nil : blobImage(of: cell.value)
+        let name = cell.column.name
+        presentTypedPopover(for: cell, edits: isEditable) { dismiss in
+            BlobPopoverContentView(
+                initialValue: current,
+                image: image,
+                columnName: name,
+                isEditable: isEditable,
+                onCommit: isEditable ? { commit($0) } : nil,
+                onCommitBytes: isEditable ? { commitBytes(.bytes($0)) } : nil,
+                onDismiss: dismiss
+            )
+        }
+    }
+
+    private func blobImage(of value: PluginCellValue) -> CellImageValue? {
+        switch value {
+        case .null:
+            return nil
+        case .bytes(let bytes):
+            guard let format = CellImageSniffer.format(of: bytes) else { return nil }
+            return CellImageValue(data: bytes, format: format)
+        case .text(let text):
+            guard let format = CellImageSniffer.format(ofText: text) else { return nil }
+            return CellImageValue(data: text.storedBytes, format: format)
+        }
+    }
+
+    private func blobText(of value: PluginCellValue) -> String? {
+        switch value {
+        case .null: return nil
+        case .text(let text): return text
+        case .bytes(let data): return String(data: data, encoding: .isoLatin1)
+        }
+    }
+}
diff --git a/apple/TablePro/Views/DataGrid/HeaderSortCycle.swift b/apple/TablePro/Views/DataGrid/HeaderSortCycle.swift
new file mode 100644
index 0000000000..ac546e62d1
--- /dev/null
+++ b/apple/TablePro/Views/DataGrid/HeaderSortCycle.swift
@@ -0,0 +1,46 @@
+//
+//  HeaderSortCycle.swift
+//  TablePro
+//
+
+import Foundation
+
+struct HeaderSortTransition: Equatable {
+    let newState: SortState
+}
+
+// HIG sorting: a click sorts by the column, a click on the sorted column flips it, Option-click adds or flips a
+// secondary key. Don't Sort lives in the header menu. Every result is stamped .user so the app default never overwrites it.
+enum HeaderSortCycle {
+    static func nextTransition(
+        state: SortState,
+        clickedColumn: Int,
+        isMultiSort: Bool,
+        firstClickDirection: SortDirection
+    ) -> HeaderSortTransition {
+        var next = isMultiSort
+            ? addingKey(state: state, clickedColumn: clickedColumn, firstClickDirection: firstClickDirection)
+            : replacingSort(state: state, clickedColumn: clickedColumn, firstClickDirection: firstClickDirection)
+        next.source = .user
+        return HeaderSortTransition(newState: next)
+    }
+
+    private static func addingKey(state: SortState, clickedColumn: Int, firstClickDirection: SortDirection) -> SortState {
+        var next = state
+        guard let index = state.columns.firstIndex(where: { $0.columnIndex == clickedColumn }) else {
+            next.columns.append(SortColumn(columnIndex: clickedColumn, direction: firstClickDirection))
+            return next
+        }
+        next.columns[index].direction = state.columns[index].direction.opposite
+        return next
+    }
+
+    private static func replacingSort(state: SortState, clickedColumn: Int, firstClickDirection: SortDirection) -> SortState {
+        guard let primary = state.columns.first, primary.columnIndex == clickedColumn else {
+            return SortState(columns: [SortColumn(columnIndex: clickedColumn, direction: firstClickDirection)])
+        }
+        var flipped = primary
+        flipped.direction = primary.direction.opposite
+        return SortState(columns: [flipped])
+    }
+}
diff --git a/apple/TablePro/Views/ERDiagram/ERDiagramNodeRenderer.swift b/apple/TablePro/Views/ERDiagram/ERDiagramNodeRenderer.swift
index b6a07c6475..8fdd29deeb 100644
--- a/apple/TablePro/Views/ERDiagram/ERDiagramNodeRenderer.swift
+++ b/apple/TablePro/Views/ERDiagram/ERDiagramNodeRenderer.swift
@@ -54,13 +54,7 @@ enum ERDiagramNodeRenderer {
         )
 
         canvas.clip(to: body) {
-            if let headerFill = palette.headerFill {
-                canvas.fill(headerRect, color: headerFill)
-            }
-            // A cluster's hue groups related tables, so it still washes a themed header.
-            if palette.headerFill == nil || clusterColor != nil {
-                canvas.fill(headerRect, color: palette.headerWash(cluster: clusterColor))
-            }
+            canvas.fill(headerRect, color: palette.headerWash(cluster: clusterColor))
         }
 
         canvas.stroke(
@@ -76,7 +70,7 @@ enum ERDiagramNodeRenderer {
         canvas.drawText(
             displayName,
             font: .monospacedSystemFont(ofSize: headerPointSize * scale, weight: .semibold),
-            color: palette.headerText,
+            color: palette.text,
             at: CGPoint(x: rect.minX + headerTextXOffset, y: rect.minY + headerHeight / 2),
             anchor: .leading
         )
diff --git a/apple/TablePro/Views/ERDiagram/ERDiagramPalette.swift b/apple/TablePro/Views/ERDiagram/ERDiagramPalette.swift
index 4f716cb659..5e1639dab8 100644
--- a/apple/TablePro/Views/ERDiagram/ERDiagramPalette.swift
+++ b/apple/TablePro/Views/ERDiagram/ERDiagramPalette.swift
@@ -1,20 +1,16 @@
 import AppKit
 import TableProTheme
 
-/// Key, link and cluster hues carry meaning, so they stay system colors under a theme.
+// Key, link and cluster hues carry meaning, so they stay system colors under a theme.
 @MainActor
 internal struct ERDiagramPalette {
     internal let appearance: NSAppearance
     internal let backdrop: CGColor
     internal let nodeFill: CGColor
-    /// Nil keeps the accent wash a table header has always had, also while the theme draws the
-    /// header in the body's color, as the derived header does.
-    internal let headerFill: CGColor?
     internal let rule: CGColor
     internal let selectionRule: CGColor
     internal let edge: CGColor
     internal let text: NSColor
-    internal let headerText: NSColor
     internal let secondaryText: NSColor
     internal let insertedRow: CGColor
     internal let modifiedRow: CGColor
@@ -39,13 +35,10 @@ internal struct ERDiagramPalette {
 
         backdrop = Self.bake(color(.windowBackdrop, otherwise: .controlBackgroundColor), in: appearance)
         nodeFill = Self.bake(color(.gridBackground, otherwise: .controlBackgroundColor), in: appearance)
-        headerFill = Self.headerFill(of: theme, in: appearance)
         rule = Self.bake(color(.gridLine, otherwise: .tertiaryLabelColor), in: appearance)
-        // The grid outlines its own selection with the focus border, not the row fill.
-        selectionRule = Self.bake(color(.gridFocusBorder, otherwise: .controlAccentColor), in: appearance)
+        selectionRule = Self.bake(.controlAccentColor, in: appearance)
         edge = Self.wash(.secondaryLabelColor, alpha: Self.edgeAlpha, in: appearance)
         text = color(.gridText, otherwise: .labelColor)
-        headerText = color(.gridHeaderText, otherwise: .labelColor)
         secondaryText = .secondaryLabelColor
         insertedRow = Self.bake(color(.gridInserted, otherwise: NativeThemeColors.insertedRow), in: appearance)
         modifiedRow = Self.bake(color(.gridModified, otherwise: NativeThemeColors.modifiedRow), in: appearance)
@@ -66,13 +59,6 @@ internal struct ERDiagramPalette {
         return clusterWashes[cluster] ?? Self.wash(cluster, alpha: Self.clusterWashAlpha, in: appearance)
     }
 
-    private static func headerFill(of theme: ThemeDefinition, in appearance: NSAppearance) -> CGColor? {
-        let highContrast = appearance.isHighContrast
-        guard let header = theme.value(for: .gridHeaderBackground, highContrast: highContrast).themedColor,
-              header != theme.value(for: .gridBackground, highContrast: highContrast).themedColor else { return nil }
-        return bake(header.nsColor, in: appearance)
-    }
-
     private static func bake(_ color: NSColor, in appearance: NSAppearance) -> CGColor {
         var result: CGColor?
         appearance.performAsCurrentDrawingAppearance {
@@ -81,7 +67,7 @@ internal struct ERDiagramPalette {
         return result ?? color.cgColor
     }
 
-    /// The alpha goes on the resolved color, so the system color itself is never frozen.
+    // The alpha goes on the resolved color, so the system color itself is never frozen.
     private static func wash(_ color: NSColor, alpha: CGFloat, in appearance: NSAppearance) -> CGColor {
         let resolved = bake(color, in: appearance)
         return resolved.copy(alpha: alpha) ?? resolved
diff --git a/apple/TablePro/Views/Main/Child/DataGridModelReader.swift b/apple/TablePro/Views/Main/Child/DataGridModelReader.swift
new file mode 100644
index 0000000000..9190709fe8
--- /dev/null
+++ b/apple/TablePro/Views/Main/Child/DataGridModelReader.swift
@@ -0,0 +1,40 @@
+//
+//  DataGridModelReader.swift
+//  TablePro
+//
+
+import SwiftUI
+
+// Re-renders its content when the model's selection or display order moves, for views outside the grid.
+struct DataGridModelReader<Content: View>: View {
+    @ObservedObject var model: DataGridModel
+    @ViewBuilder let content: (DataGridModel) -> Content
+
+    var body: some View {
+        content(model)
+    }
+}
+
+// Runs `onChange` for every selection change of the model, and once when it starts watching another one.
+struct GridSelectionWatcher: View {
+    @ObservedObject var model: DataGridModel
+    let onAttach: () -> Void
+    let onChange: (_ rowsChanged: Bool) -> Void
+    @State private var selectedRowIDs: [RowID] = []
+
+    var body: some View {
+        Color.clear
+            .frame(width: 0, height: 0)
+            .accessibilityHidden(true)
+            .onAppear {
+                selectedRowIDs = model.selectedRowIDs
+                onAttach()
+            }
+            .onChange(of: model.selectionRevision) { _ in
+                let rowIDs = model.selectedRowIDs
+                let rowsChanged = rowIDs != selectedRowIDs
+                selectedRowIDs = rowIDs
+                onChange(rowsChanged)
+            }
+    }
+}
diff --git a/apple/TablePro/Views/Main/Child/DataTabGridAdapter.swift b/apple/TablePro/Views/Main/Child/DataTabGridAdapter.swift
new file mode 100644
index 0000000000..fc724a2854
--- /dev/null
+++ b/apple/TablePro/Views/Main/Child/DataTabGridAdapter.swift
@@ -0,0 +1,316 @@
+//
+//  DataTabGridAdapter.swift
+//  TablePro
+//
+
+import AppKit
+import Combine
+import TableProPluginKit
+
+@MainActor
+final class DataTabGridAdapter: DataGridDataSource, DataGridActions {
+    private static let detachedChangeState = AnyChangeManager(DataChangeManager())
+
+    let tabId: UUID
+    private weak var coordinator: MainContentCoordinator?
+    private weak var model: DataGridModel?
+    private let sqlExporter: DataTabSQLExporter
+    var pendingColumnJump: ColumnJumpRequest?
+
+    init(tabId: UUID, coordinator: MainContentCoordinator) {
+        self.tabId = tabId
+        self.coordinator = coordinator
+        self.sqlExporter = DataTabSQLExporter(tabId: tabId, coordinator: coordinator)
+    }
+
+    // A refresh deferred while a cell was open runs once the edit ends, committed, cancelled or unchanged, on the
+    // next turn, as after a commit, so the editor finishes tearing down first.
+    func attach(_ model: DataGridModel) {
+        self.model = model
+        model.onEditingEnded = { [weak coordinator] in
+            Task { @MainActor [weak coordinator] in
+                coordinator?.resumeDeferredTableRefresh()
+            }
+        }
+    }
+
+    private var tab: QueryTab? {
+        coordinator?.tabManager.tabs.first { $0.id == tabId }
+    }
+
+    // The change manager and the window's row commands belong to the selected tab only.
+    private var ownsWindowState: Bool {
+        coordinator?.changeManagerTabId == tabId
+    }
+
+    // MARK: - DataGridDataSource
+
+    var gridRows: TableRows {
+        coordinator?.tabSessionRegistry.existingTableRows(for: tabId) ?? TableRows()
+    }
+
+    var gridChangeState: AnyChangeManager {
+        coordinator?.gridChangeState ?? Self.detachedChangeState
+    }
+
+    var gridRowNumberOffset: Int {
+        tab?.pagination.currentOffset ?? 0
+    }
+
+    var gridHasUnloadedRows: Bool {
+        guard let tab else { return false }
+        return tab.pagination.hasUnloadedRows(loadedRowCount: gridRows.rows.count)
+    }
+
+    var gridHighlightRules: [HighlightRule] {
+        guard let coordinator, let tab else { return [] }
+        return coordinator.highlightRules(for: tab)
+    }
+
+    // MARK: - Edits
+
+    // A commit against a tab the shared change manager no longer holds would land in another table (H2).
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        guard let coordinator, ownsWindowState else { return false }
+        let committed = coordinator.rowEditingCoordinator.commitGridEdits(edits, actionName: actionName, tabId: tabId)
+        if committed {
+            coordinator.gridCellsEdited.send()
+            Task { @MainActor [weak coordinator] in
+                coordinator?.resumeDeferredTableRefresh()
+            }
+        }
+        return committed
+    }
+
+    func gridDeleteRows(_ rowIDs: [RowID]) {
+        guard ownsWindowState else { return }
+        coordinator?.deleteRows(rowIDs)
+    }
+
+    // The window's own copy, whose paste payload carries staged SQL, as Copy Rows always was here.
+    func gridCopyRows(_ rowIDs: [RowID]) -> Bool {
+        guard let coordinator, ownsWindowState, !rowIDs.isEmpty else { return false }
+        coordinator.copyRowsToClipboard(rowIDs)
+        return true
+    }
+
+    func gridUndoDelete(_ rowIDs: [RowID]) {
+        guard ownsWindowState else { return }
+        coordinator?.undoRowDeletions(rowIDs)
+    }
+
+    func gridAddRow() {
+        guard ownsWindowState else { return }
+        coordinator?.addNewRow()
+    }
+
+    func gridDuplicateRows(_ rowIDs: [RowID]) {
+        guard ownsWindowState, let first = rowIDs.first else { return }
+        coordinator?.duplicateRow(first)
+    }
+
+    func gridCanPasteRows() -> Bool {
+        ownsWindowState && (coordinator?.commandActions?.canPasteRows ?? false)
+    }
+
+    func gridPasteRows() {
+        guard ownsWindowState else { return }
+        coordinator?.pasteRows()
+    }
+
+    func gridLoadUnloadedValues(
+        rowIDs: [RowID],
+        columns: IndexSet?,
+        completion: @escaping @MainActor (Bool) -> Void
+    ) {
+        guard let coordinator else {
+            completion(false)
+            return
+        }
+        let tabId = tabId
+        Task { @MainActor in
+            completion(await coordinator.loadUnloadedValues(tabId: tabId, rowIDs: rowIDs, columns: columns))
+        }
+    }
+
+    // MARK: - Display order
+
+    // The gate sort, pagination and the WHERE filter take; it answers at once when nothing would be lost.
+    func gridConfirmDisplayOrderChange(then apply: @escaping @MainActor () -> Void) {
+        guard let coordinator else {
+            apply()
+            return
+        }
+        coordinator.confirmDiscardRestoringRowsIfNeeded(action: .displayOrder) { confirmed in
+            guard confirmed else { return }
+            apply()
+        }
+    }
+
+    // MARK: - Columns
+
+    func gridFilterWithColumn(_ column: DataGridColumn) {
+        guard ownsWindowState else { return }
+        coordinator?.addFilterForColumn(column.name)
+    }
+
+    func gridHideColumn(_ column: DataGridColumn) {
+        guard ownsWindowState else { return }
+        coordinator?.hideColumn(column.name)
+    }
+
+    func gridShowAllColumns() {
+        guard ownsWindowState else { return }
+        coordinator?.showAllColumns()
+    }
+
+    // MARK: - Navigation and results
+
+    func gridNavigateForeignKey(value: String, info: ForeignKeyInfo, intent: ReferenceOpenIntent) {
+        coordinator?.navigateToFKReference(value: value, fkInfo: info, intent: intent)
+    }
+
+    // The inspector shows the selection, so rows the menu was opened on outside it become the selection.
+    func gridShowRowsAsJSON(_ rowIDs: [RowID]) {
+        guard ownsWindowState else { return }
+        if let model, !rowIDs.isEmpty, Set(model.selectedRowIDs) != Set(rowIDs) {
+            model.selectRows(rowIDs)
+        }
+        coordinator?.showRowAsJSON()
+    }
+
+    func gridExportResults() {
+        AppCommands.shared.exportQueryResults.send(())
+    }
+
+    func gridClearResults() {
+        guard ownsWindowState else { return }
+        coordinator?.clearActiveQueryResults()
+    }
+
+    func gridSearchAllRows(term: String) {
+        coordinator?.findCoordinator.searchAllRows(term: term, tabID: tabId)
+    }
+
+    var gridSQLExporter: (any DataGridSQLExporting)? {
+        sqlExporter
+    }
+
+    // MARK: - Menus
+
+    func gridRowMenuItems(for rowIDs: [RowID], clickedRow: RowID) -> [NSMenuItem] {
+        guard let coordinator, ownsWindowState, coordinator.canInsertDocument else { return [] }
+        var items: [NSMenuItem] = []
+        // Read while the menu is built, so a reload under the open menu cannot retarget the edit.
+        if rowIDs.count == 1, let rowID = rowIDs.first, let locator = coordinator.documentLocator(for: rowID) {
+            items.append(ClosureMenuTarget.item(title: String(localized: "Edit Document…")) { [weak coordinator] in
+                coordinator?.presentEditDocument(locator: locator)
+            })
+        }
+        items.append(ClosureMenuTarget.item(title: String(localized: "Insert Document…")) { [weak coordinator] in
+            coordinator?.presentInsertDocument()
+        })
+        return items
+    }
+
+    func gridCellMenuItems(for rowID: RowID, column: DataGridColumn) -> [NSMenuItem] {
+        guard let coordinator, ownsWindowState else { return [] }
+        let rows = gridRows
+        guard let row = rows.row(withID: rowID), column.dataIndex < row.values.count else { return [] }
+        var items: [NSMenuItem] = []
+        if let filterItem = filterMenuItem(row: row, column: column, in: rows, coordinator: coordinator) {
+            items.append(filterItem)
+        }
+        if let highlightItem = highlightMenuItem(row: row, column: column, in: rows, coordinator: coordinator) {
+            items.append(highlightItem)
+        }
+        return items
+    }
+
+    // Only a value the server holds: a filter built from an inserted row or an edited cell finds nothing.
+    private func filterMenuItem(
+        row: Row,
+        column: DataGridColumn,
+        in rows: TableRows,
+        coordinator: MainContentCoordinator
+    ) -> NSMenuItem? {
+        guard coordinator.canFilterRows,
+              !row.id.isInserted,
+              !coordinator.changeManager.isCellModified(rowID: row.id, columnIndex: column.dataIndex) else { return nil }
+        let tabId = tabId
+        return CellFilterMenuBuilder.menuItem(
+            columnName: column.name,
+            columnType: column.type,
+            value: row.values[column.dataIndex],
+            family: SQLTypeFamily.of(coordinator.connection.type)
+        ) { [weak coordinator] filter in
+            coordinator?.applyCellFilter(filter, forTab: tabId)
+        }
+    }
+
+    private func highlightMenuItem(
+        row: Row,
+        column: DataGridColumn,
+        in rows: TableRows,
+        coordinator: MainContentCoordinator
+    ) -> NSMenuItem? {
+        guard let tab else { return nil }
+        let tabId = tabId
+        let context = HighlightMenuBuilder.CellContext(
+            columnName: column.name,
+            columnOccurrence: HighlightRuleSet.occurrence(ofColumnAt: column.dataIndex, in: rows.columns),
+            columnType: column.type,
+            value: row.values[column.dataIndex],
+            existingRules: coordinator.highlightRules(for: tab)
+        )
+        let actions = HighlightMenuBuilder.Actions(
+            apply: { [weak coordinator] rule in
+                coordinator?.applyQuickHighlight(rule, forTab: tabId)
+            },
+            remove: { [weak coordinator] rule in
+                coordinator?.removeHighlightRules(sharingConditionWith: rule, forTab: tabId)
+            },
+            showRules: { [weak coordinator] in
+                coordinator?.presentHighlightRules()
+            }
+        )
+        return HighlightMenuBuilder.menuItem(for: context, actions: actions)
+    }
+
+    func gridEmptySpaceMenu() -> NSMenu? {
+        guard let coordinator, ownsWindowState else { return nil }
+        var items: [NSMenuItem] = []
+        if coordinator.canAddRow {
+            items.append(ClosureMenuTarget.item(title: String(localized: "Add Row")) { [weak coordinator] in
+                coordinator?.addNewRow()
+            })
+        }
+        if coordinator.canInsertDocument {
+            items.append(ClosureMenuTarget.item(title: String(localized: "Insert Document…")) { [weak coordinator] in
+                coordinator?.presentInsertDocument()
+            })
+        }
+        guard !items.isEmpty else { return nil }
+        let menu = NSMenu()
+        items.forEach(menu.addItem)
+        return menu
+    }
+
+    func gridHighlightValuesMenuItem(for column: DataGridColumn) -> NSMenuItem? {
+        guard let coordinator, ownsWindowState else { return nil }
+        let occurrence = HighlightRuleSet.occurrence(ofColumnAt: column.dataIndex, in: gridRows.columns)
+        let name = column.name
+        return ClosureMenuTarget.item(title: String(localized: "Highlight Values…")) { [weak coordinator] in
+            coordinator?.presentHighlightRules(addingRuleForColumn: name, occurrence: occurrence)
+        }
+    }
+}
+
+// A jump to a column the result does not present yet, landed once the column arrives.
+struct ColumnJumpRequest: Equatable {
+    let name: String
+    let dataIndex: Int?
+    let tableKey: ColumnLayoutTableKey?
+    // A table tab fetches a column to show it, so its jump waits for that result rather than an interim update.
+    let awaitsResultReplacement: Bool
+}
diff --git a/apple/TablePro/Views/Main/Child/DataTabGridDelegate.swift b/apple/TablePro/Views/Main/Child/DataTabGridDelegate.swift
deleted file mode 100644
index 7d23be8eb3..0000000000
--- a/apple/TablePro/Views/Main/Child/DataTabGridDelegate.swift
+++ /dev/null
@@ -1,245 +0,0 @@
-//
-//  DataTabGridDelegate.swift
-//  TablePro
-//
-//  DataGridViewDelegate for the data tab in MainEditorContentView.
-//  Bridges delegate calls to MainContentCoordinator and view-level callbacks.
-//
-
-import AppKit
-import Combine
-
-@MainActor
-final class DataTabGridDelegate: DataGridViewDelegate {
-    weak var coordinator: MainContentCoordinator?
-
-    var selectionState: GridSelectionState?
-
-    var onCellEdit: ((Int, Int, String?) -> Void)?
-    var onSortStateChanged: ((SortState) -> Void)?
-    var onAddRow: (() -> Void)?
-    var onFilterColumn: ((String) -> Void)?
-
-    // MARK: - DataGridViewDelegate
-
-    func dataGridDidEditCell(row: Int, column: Int, newValue: String?) {
-        onCellEdit?(row, column, newValue)
-    }
-
-    func dataGridSortStateChanged(_ state: SortState) {
-        onSortStateChanged?(state)
-    }
-
-    /// The same gate sort, pagination and the WHERE filter go through. `confirmDiscardChangesIfNeeded`
-    /// answers immediately when there is nothing to lose, so an unedited result never sees an alert.
-    func dataGridConfirmDisplayOrderChange(then apply: @escaping () -> Void) {
-        guard let coordinator else {
-            apply()
-            return
-        }
-        coordinator.confirmDiscardRestoringRowsIfNeeded(action: .displayOrder) { confirmed in
-            guard confirmed else { return }
-            apply()
-        }
-    }
-
-    func dataGridDisplayOrderChanged() {
-        coordinator?.gridDisplayRevision &+= 1
-    }
-
-    func dataGridDisplayFormatChanged() {
-        coordinator?.gridDisplayRevision &+= 1
-    }
-
-    func dataGridAddRow() {
-        onAddRow?()
-    }
-
-    func dataGridFilterColumn(_ columnName: String) {
-        onFilterColumn?(columnName)
-    }
-
-    func dataGridDeleteRows(_ indices: Set<Int>) {
-        coordinator?.deleteSelectedRows(indices: indices)
-    }
-
-    func dataGridCopyRows(_ indices: Set<Int>) {
-        coordinator?.copySelectedRowsToClipboard(indices: indices)
-    }
-
-    func dataGridPasteRows() {
-        coordinator?.pasteRows()
-    }
-
-    func dataGridCanPasteRows() -> Bool {
-        coordinator?.commandActions?.canPasteRows ?? false
-    }
-
-    func dataGridDuplicateRow() {
-        guard let selectionState, let firstIndex = selectionState.indices.first else { return }
-        coordinator?.duplicateSelectedRow(index: firstIndex)
-    }
-
-    func dataGridExportResults() {
-        AppCommands.shared.exportQueryResults.send(())
-    }
-
-    func dataGridClearResults() {
-        coordinator?.clearActiveQueryResults()
-    }
-
-    func dataGridCanClearResults() -> Bool {
-        coordinator?.canClearActiveQueryResults ?? false
-    }
-
-    func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo, intent: ReferenceOpenIntent) {
-        coordinator?.navigateToFKReference(value: value, fkInfo: fkInfo, intent: intent)
-    }
-
-    /// The panel reads the selection, not a row this is told about.
-    ///
-    /// `KeyHandlingTableView.menu(for:)` retargets the selection to a row clicked outside it, so
-    /// the usual single-row case shows the row the reader asked about. A click inside a multi-row
-    /// selection keeps that selection on purpose, and the panel then shows its first row, which is
-    /// the row the Details tab shows too.
-    func dataGridShowRowAsJSON() {
-        coordinator?.showRowAsJSON()
-    }
-
-    func dataGridHideColumn(_ columnName: String) {
-        coordinator?.hideColumn(columnName)
-    }
-
-    func dataGridShowAllColumns() {
-        coordinator?.showAllColumns()
-    }
-
-    func dataGridEmptySpaceMenu() -> NSMenu? {
-        var items: [NSMenuItem] = []
-        if let onAddRow, coordinator?.canAddRow == true {
-            items.append(Self.menuItem(String(localized: "Add Row"), action: onAddRow))
-        }
-        if let coordinator, coordinator.canInsertDocument {
-            items.append(Self.menuItem(String(localized: "Insert Document…")) { [weak coordinator] in
-                coordinator?.presentInsertDocument()
-            })
-        }
-        guard !items.isEmpty else { return nil }
-        let menu = NSMenu()
-        items.forEach(menu.addItem)
-        return menu
-    }
-
-    /// The row's locator is read while the menu is built and carried by the item, so a reload that
-    /// lands while the menu is open cannot turn the click into an edit of another document.
-    func dataGridDocumentMenuItems(forRow displayRow: Int) -> [NSMenuItem] {
-        guard let coordinator, coordinator.canInsertDocument else { return [] }
-        var items: [NSMenuItem] = []
-        if let locator = coordinator.documentLocator(forDisplayRow: displayRow) {
-            items.append(Self.menuItem(String(localized: "Edit Document…")) { [weak coordinator] in
-                coordinator?.presentEditDocument(locator: locator)
-            })
-        }
-        items.append(Self.menuItem(String(localized: "Insert Document…")) { [weak coordinator] in
-            coordinator?.presentInsertDocument()
-        })
-        return items
-    }
-
-    private static func menuItem(_ title: String, action: @escaping () -> Void) -> NSMenuItem {
-        let target = StructureMenuTarget(action: action)
-        let item = NSMenuItem(title: title, action: #selector(StructureMenuTarget.runAction), keyEquivalent: "")
-        item.target = target
-        item.representedObject = target
-        return item
-    }
-
-    func dataGridHighlightMenuItem(forRow displayRow: Int, dataColumn: Int) -> NSMenuItem? {
-        guard let coordinator,
-              let grid = tableViewCoordinator,
-              let tab = coordinator.tabManager.selectedTab,
-              let row = grid.displayRow(at: displayRow) else { return nil }
-        let tableRows = grid.tableRowsProvider()
-        let columns = tableRows.columns
-        guard columns.indices.contains(dataColumn), dataColumn < row.values.count else { return nil }
-
-        let tabId = tab.id
-        let context = HighlightMenuBuilder.CellContext(
-            columnName: columns[dataColumn],
-            columnOccurrence: HighlightRuleSet.occurrence(ofColumnAt: dataColumn, in: columns),
-            columnType: dataColumn < tableRows.columnTypes.count ? tableRows.columnTypes[dataColumn] : nil,
-            value: row.values[dataColumn],
-            existingRules: coordinator.highlightRules(for: tab)
-        )
-        let actions = HighlightMenuBuilder.Actions(
-            apply: { [weak coordinator] rule in
-                coordinator?.applyQuickHighlight(rule, forTab: tabId)
-            },
-            remove: { [weak coordinator] rule in
-                coordinator?.removeHighlightRules(sharingConditionWith: rule, forTab: tabId)
-            },
-            showRules: { [weak coordinator] in
-                coordinator?.presentHighlightRules()
-            }
-        )
-        return HighlightMenuBuilder.menuItem(for: context, actions: actions)
-    }
-
-    /// Offered only for a value the server holds: a row the reader inserted, or a cell they edited,
-    /// is not on the server yet, so a filter built from it cannot find the row it came from.
-    func dataGridFilterMenuItem(forRow displayRow: Int, dataColumn: Int) -> NSMenuItem? {
-        guard let coordinator, coordinator.canFilterRows,
-              let grid = tableViewCoordinator,
-              let tabId = coordinator.tabManager.selectedTab?.id else { return nil }
-        return grid.cellFilterMenuItem(forRow: displayRow, dataColumn: dataColumn) { [weak coordinator] filter in
-            coordinator?.applyCellFilter(filter, forTab: tabId)
-        }
-    }
-
-    func dataGridHighlightValuesMenuItem(forColumn dataColumnIndex: Int) -> NSMenuItem? {
-        guard coordinator != nil, let grid = tableViewCoordinator else { return nil }
-        let columns = grid.tableRowsProvider().columns
-        guard columns.indices.contains(dataColumnIndex) else { return nil }
-        let columnName = columns[dataColumnIndex]
-        let occurrence = HighlightRuleSet.occurrence(ofColumnAt: dataColumnIndex, in: columns)
-        return ClosureMenuTarget.item(title: String(localized: "Highlight Values…")) { [weak coordinator] in
-            coordinator?.presentHighlightRules(addingRuleForColumn: columnName, occurrence: occurrence)
-        }
-    }
-
-    weak var tableViewCoordinator: TableViewCoordinator?
-
-    func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        self.tableViewCoordinator = tableViewCoordinator
-    }
-
-    func dataGridDidInsertRows(at indices: IndexSet) {
-        tableViewCoordinator?.applyInsertedRows(indices)
-    }
-
-    func dataGridDidRemoveRows(at indices: IndexSet) {
-        tableViewCoordinator?.applyRemovedRows(indices)
-    }
-
-    func dataGridDidReplaceAllRows() {
-        tableViewCoordinator?.applyFullReplace()
-    }
-
-    func dataGridDidCloseCellOverlay() {
-        coordinator?.resumeDeferredTableRefresh()
-    }
-
-    func dataGridLoadUnloadedValues(
-        rowIDs: [RowID],
-        columns: IndexSet?,
-        completion: @escaping @MainActor (Bool) -> Void
-    ) {
-        guard let coordinator, let tabId = coordinator.tabManager.selectedTab?.id else {
-            completion(false)
-            return
-        }
-        Task { @MainActor in
-            completion(await coordinator.loadUnloadedValues(tabId: tabId, rowIDs: rowIDs, columns: columns))
-        }
-    }
-}
diff --git a/apple/TablePro/Views/Main/Child/DataTabSQLExporter.swift b/apple/TablePro/Views/Main/Child/DataTabSQLExporter.swift
new file mode 100644
index 0000000000..87addaed2a
--- /dev/null
+++ b/apple/TablePro/Views/Main/Child/DataTabSQLExporter.swift
@@ -0,0 +1,170 @@
+//
+//  DataTabSQLExporter.swift
+//  TablePro
+//
+
+import Foundation
+import os
+import TableProAutocomplete
+import TableProPluginKit
+
+@MainActor
+final class DataTabSQLExporter: DataGridSQLExporting {
+    private static let logger = Logger(subsystem: "com.TablePro", category: "DataTabSQLExporter")
+
+    private let tabId: UUID
+    private weak var coordinator: MainContentCoordinator?
+
+    init(tabId: UUID, coordinator: MainContentCoordinator?) {
+        self.tabId = tabId
+        self.coordinator = coordinator
+    }
+
+    private struct Target {
+        let tableName: String
+        let schemaName: String?
+        let primaryKeyColumns: [String]
+        let databaseType: DatabaseType
+        let connectionId: UUID
+        let changeManager: DataChangeManager
+        let driver: (any DatabaseDriver)?
+    }
+
+    private var target: Target? {
+        guard let coordinator,
+              let tab = coordinator.tabManager.tabs.first(where: { $0.id == tabId }),
+              let tableName = tab.tableContext.tableName else { return nil }
+        return Target(
+            tableName: tableName,
+            schemaName: tab.tableContext.schemaName,
+            primaryKeyColumns: tab.tableContext.primaryKeyColumns,
+            databaseType: coordinator.connection.type,
+            connectionId: coordinator.connectionId,
+            changeManager: coordinator.changeManager,
+            driver: coordinator.services.databaseManager.driver(for: coordinator.connectionId)
+        )
+    }
+
+    // The statements leave out the columns the server owns, which only the schema names.
+    func canCopyAsInsert(_ rows: TableRows) -> Bool {
+        guard let target, target.databaseType != .mongodb, target.databaseType != .redis else { return false }
+        return rows.hasAuthoritativeSchema
+    }
+
+    // A table without a key is matched on every column, so one no match can compare leaves nothing to find the row by.
+    func canCopyAsUpdate(_ rows: TableRows) -> Bool {
+        guard canCopyAsInsert(rows), let target else { return false }
+        return !target.primaryKeyColumns.isEmpty || rows.rowMatchPolicy.excludedColumns.isEmpty
+    }
+
+    func insertStatements(for rowIDs: [RowID], columns: [DataGridColumn], in rows: TableRows) -> String? {
+        guard let target else { return nil }
+        let projection = VisibleColumnProjection(indices: columns.map(\.dataIndex))
+        do {
+            let converter = try SQLRowToStatementConverter(
+                tableName: target.tableName,
+                schemaName: target.schemaName,
+                columns: projection.columns(rows.columns),
+                primaryKeyColumns: target.primaryKeyColumns,
+                databaseType: target.databaseType,
+                unwritableColumns: unwritableColumns(in: rows, target: target),
+                quoteIdentifier: target.driver?.quoteIdentifier,
+                escapeStringLiteral: target.driver?.escapeStringLiteral,
+                identifierSpelling: identifierSpelling(for: target)
+            )
+            let sources = rowIDs.compactMap { rows.row(withID: $0) }.map { row in
+                SQLRowToStatementConverter.SourceRow(
+                    values: projection.values(Array(row.values)),
+                    defaultedColumns: projection.positions(of: stagedDefaults(of: row, target: target)),
+                    expressionColumns: projection.positions(of: target.changeManager.expressionColumns(forRow: row.id))
+                )
+            }
+            return nonEmpty(converter.generateInserts(rows: sources))
+        } catch {
+            Self.logger.error("Copy as INSERT failed: \(error.publicLogShape, privacy: .public)")
+            return nil
+        }
+    }
+
+    // SET covers the columns asked for; the row is found by all of its key, or every stored column, hidden ones included.
+    func updateStatements(for rowIDs: [RowID], columns: [DataGridColumn], in rows: TableRows) -> String? {
+        guard let target else { return nil }
+        do {
+            let converter = try SQLRowToStatementConverter(
+                tableName: target.tableName,
+                schemaName: target.schemaName,
+                columns: rows.columns,
+                primaryKeyColumns: target.primaryKeyColumns,
+                databaseType: target.databaseType,
+                unwritableColumns: unwritableColumns(in: rows, target: target),
+                rowMatchPolicy: rows.rowMatchPolicy,
+                settableColumns: columns.map(\.name),
+                quoteIdentifier: target.driver?.quoteIdentifier,
+                escapeStringLiteral: target.driver?.escapeStringLiteral,
+                identifierSpelling: identifierSpelling(for: target),
+                rowUpdateStatement: target.driver?.rowUpdateStatement,
+                matchesEveryColumn: target.driver?.primaryKeyNamesOneRow == false
+            )
+            let sources = rowIDs.compactMap { rows.row(withID: $0) }.map { sourceRow($0, target: target) }
+            return nonEmpty(converter.generateUpdates(rows: sources))
+        } catch {
+            Self.logger.error("Copy as UPDATE failed: \(error.publicLogShape, privacy: .public)")
+            return nil
+        }
+    }
+
+    // Any result, a join included, needs its engine's escaping: MySQL reads a backslash as one.
+    func inClause(values: [PluginCellValue], column: DataGridColumn) -> String? {
+        guard !values.isEmpty, let coordinator else { return nil }
+        let databaseType = coordinator.connection.type
+        let driver = coordinator.services.databaseManager.driver(for: coordinator.connectionId)
+        let converter = InClauseConverter(
+            columnIndex: 0,
+            columnTypes: [column.type ?? .text(rawType: nil)],
+            escapeStringLiteral: driver?.escapeStringLiteral,
+            stringLiteralPrefix: SQLStringLiteralPrefix.forDatabaseType(databaseType)
+        )
+        return converter.generateInClause(rows: values.map { [$0] })
+    }
+
+    private func identifierSpelling(for target: Target) -> SQLIdentifierSpelling? {
+        guard let rules = target.databaseType.identifierRules else { return nil }
+        return SQLIdentifierSpelling(rules: rules, policy: SQLIdentifierCase.stored(for: target.connectionId))
+    }
+
+    private func unwritableColumns(in rows: TableRows, target: Target) -> Set<String> {
+        let immutable = Set(PluginManager.shared.immutableColumns(for: target.databaseType))
+        return Set(rows.columns.filter { name in
+            rows.generatedColumns.contains(name) || immutable.contains(name) || !target.changeManager.isColumnWritable(name)
+        })
+    }
+
+    private func sourceRow(_ row: Row, target: Target) -> SQLRowToStatementConverter.SourceRow {
+        var stored = Array(row.values)
+        let pendingUpdate = target.changeManager.rowChanges.first { $0.rowID == row.id && $0.type == .update }
+        for cellChange in pendingUpdate?.cellChanges ?? [] where stored.indices.contains(cellChange.columnIndex) {
+            stored[cellChange.columnIndex] = cellChange.oldValue
+        }
+        return SQLRowToStatementConverter.SourceRow(
+            values: Array(row.values),
+            storedValues: stored,
+            isPendingInsert: target.changeManager.insertedRowIDs.contains(row.id),
+            defaultedColumns: stagedDefaults(of: row, target: target),
+            expressionColumns: target.changeManager.expressionColumns(forRow: row.id)
+        )
+    }
+
+    // Every marker in a row not saved yet, and in a saved row the cells a pending edit set to Default.
+    private func stagedDefaults(of row: Row, target: Target) -> Set<Int> {
+        let marker = PluginCellValue.text("__DEFAULT__")
+        if target.changeManager.insertedRowIDs.contains(row.id) {
+            return Set(row.values.indices.filter { row.values[$0] == marker })
+        }
+        let pendingUpdate = target.changeManager.rowChanges.first { $0.rowID == row.id && $0.type == .update }
+        return Set(pendingUpdate?.cellChanges.filter { $0.newValue == marker }.map(\.columnIndex) ?? [])
+    }
+
+    private func nonEmpty(_ statements: String) -> String? {
+        statements.isEmpty ? nil : statements
+    }
+}
diff --git a/apple/TablePro/Views/Main/Child/MainEditorContentView.swift b/apple/TablePro/Views/Main/Child/MainEditorContentView.swift
index 370ecef4c2..366fd67835 100644
--- a/apple/TablePro/Views/Main/Child/MainEditorContentView.swift
+++ b/apple/TablePro/Views/Main/Child/MainEditorContentView.swift
@@ -11,17 +11,13 @@ import SwiftUI
 import TableProEditorKit
 import TableProPluginKit
 
-/// Identity for the visibility-scoped lazy-load `.task(id:)` modifier on
-/// `MainEditorContentView`. Changes to either field cancel the previous
-/// task and start a new one — exactly the rapid-switch coalescing semantic
-/// we want for Cmd+Number tab navigation.
+// A change to either field cancels the old task and starts a new one, which coalesces rapid Cmd+Number switches.
 private struct TabLoadKey: Hashable {
     let tabId: UUID?
     let loadEpoch: Int
 }
 
-/// Picking another database reruns the tab only while it shows rows. An error, a plan or a write's
-/// count is not a view of the data the new database holds, and rerunning it was an unasked run.
+// Only a tab showing rows reruns: an error, a plan or a write's count is not a view of the new database's data.
 @MainActor
 internal enum ContainerChangeRerunPolicy {
     internal static func reruns(showing activeResult: ResultSet?) -> Bool {
@@ -36,9 +32,7 @@ struct MainEditorContentView: View {
     @ObservedObject private var schemaService = SchemaService.shared
     @ObservedObject private var licenseManager = LicenseManager.shared
     @ObservedObject private var settingsManager = AppSettingsManager.shared
-    /// A query tab nests its own editor/results split, whose two minimums are required constraints.
-    /// The drawer's own minimum has to clear their sum, or dragging the drawer down asks AppKit to
-    /// satisfy a height the content it contains cannot reach.
+    // Must clear the nested editor/results split's required minimums, or dragging the drawer asks AppKit for an unreachable height.
     static let tabContentMinimumHeight = CollapsibleSplitController.combinedMinimumThickness
 
     // MARK: - Dependencies
@@ -46,26 +40,15 @@ struct MainEditorContentView: View {
     @ObservedObject var tabManager: QueryTabManager
     @ObservedObject var coordinator: MainContentCoordinator
 
-    /// The drawer state is a per-connection singleton behind a factory, so it is handed in
-    /// rather than resolved in `body`, where nothing would observe it.
+    // Handed in, not resolved in `body` where nothing would observe it: the drawer state is a per-connection singleton.
     @ObservedObject var historyState: HistoryPanelState
     @ObservedObject var changeManager: DataChangeManager
     let connection: DatabaseConnection
     let windowId: UUID
     let connectionId: UUID
 
-    // MARK: - Selection State
-
-    @ObservedObject var selectionState: GridSelectionState
-
     // MARK: - Callbacks
 
-    let onCellEdit: (Int, Int, String?) -> Void
-    let onSortStateChanged: (SortState) -> Void
-    let onAddRow: () -> Void
-    let onSelectionChange: (Set<Int>) -> Void
-    let onFilterColumn: (String) -> Void
-
     let onFirstPage: () -> Void
     let onPreviousPage: () -> Void
     let onNextPage: () -> Void
@@ -74,38 +57,17 @@ struct MainEditorContentView: View {
     let onShowAll: () -> Void
     let onGoToPage: (Int) -> Void
 
-    @State private var cachedChangeManager: AnyChangeManager?
     @State private var queryPlanViewStates = QueryPlanViewStateStore()
     @State private var serverDashboardViewModels: [UUID: ServerDashboardViewModel] = [:]
     @State private var usersRolesViewModels: [UUID: UsersRolesViewModel] = [:]
     @State private var queryInsightsViewModels: [UUID: QueryInsightsViewModel] = [:]
     @State private var tableListingModels = TableListingModelStore()
-    @State private var dataTabDelegate = DataTabGridDelegate()
 
     @ObservedObject private var treeService = DatabaseTreeMetadataService.shared
-    /// A table's highlight rules live in this store, not on the tab, and `body` reads them for both
-    /// the grid and the status bar popover. Without observing it here a rule added to a table tab was
-    /// written and never shown: Add Rule did nothing visible, while a query result's rules, kept on
-    /// the tab, updated as expected.
+    // Table highlight rules live here, not on the tab; unobserved, Add Rule on a table tab changed nothing on screen.
     @ObservedObject private var highlightRuleStorage = HighlightRuleStorage.shared
 
-    // Native macOS window tabs — no LRU tracking needed (single tab per window)
-
-    // MARK: - Environment
-
-
-    /// Returns the cached AnyChangeManager, creating it on first access.
-    private var currentChangeManager: AnyChangeManager {
-        if let existing = cachedChangeManager {
-            return existing
-        }
-        // Fallback before onAppear initializes cachedChangeManager.
-        // Safe: onAppear fires before any user interaction needs it.
-        return AnyChangeManager(changeManager)
-    }
-
-    /// The tip that tells a first-time reader where past queries are. It is answered once history
-    /// has been on screen, which is now the trailing pane rather than a drawer under the editor.
+    // The tip is answered once history has been on screen, now the trailing pane rather than a drawer under the editor.
     private var showsHistoryTip: Bool {
         let historyState = HistoryPanelState.forConnection(connectionId)
         return !historyState.isVisible && !historyState.isCapturePaused
@@ -206,12 +168,6 @@ struct MainEditorContentView: View {
         }
         .onAppear {
             updateHasQueryText()
-            cachedChangeManager = AnyChangeManager(changeManager)
-            wireDataTabDelegateStableRefs()
-            coordinator.dataTabDelegate = dataTabDelegate
-        }
-        .onDisappear {
-            cachedChangeManager = nil
         }
         .task(id: TabLoadKey(
             tabId: tabManager.selectedTabId,
@@ -219,18 +175,6 @@ struct MainEditorContentView: View {
         )) {
             coordinator.lazyLoadCurrentTabIfNeeded()
         }
-        .onChange(of: selectionState.indices) { newIndices in
-            onSelectionChange(newIndices)
-        }
-    }
-
-    private func wireDataTabDelegateStableRefs() {
-        dataTabDelegate.coordinator = coordinator
-        dataTabDelegate.selectionState = selectionState
-        dataTabDelegate.onCellEdit = onCellEdit
-        dataTabDelegate.onSortStateChanged = onSortStateChanged
-        dataTabDelegate.onAddRow = onAddRow
-        dataTabDelegate.onFilterColumn = onFilterColumn
     }
 
     // MARK: - Tab Content
@@ -463,8 +407,6 @@ struct MainEditorContentView: View {
         PluginManager.shared.containerSwitchTarget(for: connection.type)
     }
 
-    /// The schemas on an engine whose entries are schemas: a query tab is bound to one, and this is
-    /// how it is pointed at another.
     private func containerDatabases(for tab: QueryTab) -> [DatabaseMetadata] {
         switch containerSwitchTarget {
         case .database:
@@ -489,8 +431,7 @@ struct MainEditorContentView: View {
         PluginManager.shared.containerEntityName(for: connection.type)
     }
 
-    /// Read from the tab's own scope, the same value completion resolves against, so the control
-    /// and the suggestions can never describe different databases.
+    // Read from the tab's own scope, which completion also resolves against, so the two never name different databases.
     private func containerName(for tab: QueryTab) -> String {
         if containerSwitchTarget == .schema {
             return coordinator.scope(for: tab)?.schema ?? tab.tableContext.schemaName ?? ""
@@ -500,15 +441,13 @@ struct MainEditorContentView: View {
         return bound.isEmpty ? coordinator.browseDatabaseName : bound
     }
 
-    /// Only shown beside a database, never instead of one: on an engine whose container IS the
-    /// schema the picker is already naming it.
+    // Only beside a database: where the container is the schema, the picker already names it.
     private func containerSchemaName(for tab: QueryTab) -> String? {
         guard containerSwitchTarget == .database else { return nil }
         return coordinator.scope(for: tab)?.schema
     }
 
-    /// The tab owns the new database, or schema, for the rest of its life, so it moves to that
-    /// entry and the window goes with it, the way selecting a tab of another entry does.
+    // The tab owns the new container for life, so it moves to that entry and the window follows, like selecting its tab.
     private func changeContainer(for tab: QueryTab, to name: String) {
         let tabId = tab.id
         guard tabManager.containerName(of: tab) != name,
@@ -519,7 +458,7 @@ struct MainEditorContentView: View {
         SchemaProviderRegistry.shared.reclaimUnheldProviders(for: connectionId)
         guard tabManager.selectedTabId == tabId,
               ContainerChangeRerunPolicy.reruns(showing: tabManager.selectedTab?.display.activeResultSet) else { return }
-        /// The statement at the caret may not be the one that produced the rows, so a write asks first.
+        // The statement at the caret may not be the one that produced the rows, so a write asks first.
         coordinator.runQuery(viewport: .firstRow, extraCapabilities: .confirmsWrites)
     }
 
@@ -527,9 +466,7 @@ struct MainEditorContentView: View {
         coordinator.tabManager.mutate(tabId: tabId) { FileTabBaseline.dismissDiskChange(in: &$0.content) }
     }
 
-    /// Both facts the toolbar's query items validate against, written together. They used to be one
-    /// fact, because the only thing that read it was a button inside this view which already knew
-    /// it was on a query tab. The toolbar does not: it belongs to the window and outlives every tab.
+    // Two facts, not one: the window's toolbar outlives every tab, so unlike the old in-view button it cannot assume a query tab.
     private func updateHasQueryText() {
         coordinator.syncQueryToolbarStateForSelectedTab()
     }
@@ -542,17 +479,12 @@ struct MainEditorContentView: View {
                 tabManager.tabs.first(where: { $0.id == tabId })?.content.query ?? fallbackQuery
             },
             set: { newValue in
-                // Find this tab by ID, not by selectedTabIndex. During tab switch,
-                // flushTextUpdate() fires on the OLD tab's EditorCoordinator when
-                // selectedTabIndex already points to the NEW tab — writing to
-                // selectedTabIndex would overwrite the new tab's query.
+                // By ID: mid-switch, flushTextUpdate() fires for the old tab while selectedTabIndex already points to the new one.
                 guard tabManager.mutate(tabId: tabId, { $0.content.query = newValue }) else { return }
 
                 coordinator.scheduleDraftSave()
 
-                // Typing into a scratch tab dirties it too: the text lives nowhere but this tab.
-                // The dot belongs to this tab's own window, not whichever window happens to be
-                // key, because a background window tab's editor stays mounted and can fire here.
+                // Scratch tabs dirty too. Only this tab's window: a background window tab's editor stays mounted and can fire here.
                 guard tabId == tabManager.selectedTabId,
                       let index = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
                       let window = coordinator.contentWindow else { return }
@@ -622,8 +554,7 @@ struct MainEditorContentView: View {
         coordinator.scope(for: tab)
     }
 
-    /// A Create Table tab holds nothing but unsaved work, so its draft is cached here rather than
-    /// left in the view, which is destroyed the moment the tab is deselected.
+    // The draft is cached here because the view is destroyed as soon as the tab is deselected.
     @ViewBuilder
     private func createTableContent(tab: QueryTab) -> some View {
         Group {
@@ -632,7 +563,6 @@ struct MainEditorContentView: View {
                     connection: connection,
                     scope: structureScope(for: tab),
                     coordinator: coordinator,
-                    selectionState: selectionState,
                     draft: draft
                 )
             } else {
@@ -643,17 +573,7 @@ struct MainEditorContentView: View {
         .id(tab.id)
     }
 
-    /// The structure editor is rebuilt whenever the tab is deselected or switched to Data, so its
-    /// staged ALTERs live in a session cached here by tab, the same way the Users & Roles, ER
-    /// diagram and dashboard view models do. Creating it in `onAppear` rather than inline keeps the
-    /// write out of the view-update pass.
-    ///
-    /// The identity is the tab, exactly as it is for every other builder that caches a view model
-    /// under `tab.id`. It used to be `"<database>.<schema>.<table>"`, which two tabs on one table
-    /// share, so switching between them updated the view in place instead of re-creating it: its
-    /// `@State` went on answering for whichever tab mounted first while `session` resolved to the
-    /// other. The `session.identity == identity` branch stays, because flipping it is what forces a
-    /// real remount when a tab is retargeted to a different table.
+    // Session cached by tab.id (a table-name key let two tabs share @State); the identity check forces a remount on retarget.
     @ViewBuilder
     private func structureContent(tab: QueryTab, tableName: String) -> some View {
         let scope = structureScope(for: tab)
@@ -668,7 +588,6 @@ struct MainEditorContentView: View {
                     schemaName: scope?.schema,
                     toolbarState: coordinator.toolbarState,
                     coordinator: coordinator,
-                    selectionState: selectionState,
                     session: session
                 )
             } else {
@@ -691,9 +610,6 @@ struct MainEditorContentView: View {
         .frame(maxHeight: .infinity)
     }
 
-    /// Renders `QueryResultPresentation`. Every branch this used to take lived here as a switch
-    /// over the view mode whose arms each repeated the result chrome, wrapped around a nested
-    /// `if/else` chain. The decision is a pure value now, so this is a rendering and nothing else.
     @ViewBuilder
     private func resultsSection(tab: QueryTab) -> some View {
         let rows = resolvedTableRows(for: tab)
@@ -708,31 +624,17 @@ struct MainEditorContentView: View {
                 rowFilterChrome(tab: tab, rows: rows)
             }
 
-            if presentation.showsFindBar {
-                FindBarView(
-                    coordinator: coordinator,
-                    findState: tab.findState,
-                    rowsRevision: tab.loadEpoch
-                        &+ tab.pagination.currentPage
-                        &+ tab.paginationVersion
-                        &+ rows.rows.count,
-                    onSearchAllRows: { coordinator.findCoordinator.escalateToAllRows() }
-                )
-                /// Per tab, like the grid below it. The field text lives in the view's own
-                /// `@State`, seeded once from `onAppear`, and the grid's find tint lives on a
-                /// coordinator that `.id(tabId)` rebuilds from nothing. With find open on both tabs
-                /// this view kept its identity across a switch, so neither was re-seeded: the field
-                /// showed the other tab's term next to this tab's match count, and the grid came
-                /// back untinted. (#2667)
-                .id(tab.id)
-                Divider()
-            }
-
             resultContent(presentation.content, tab: tab, rows: rows)
                 .gridStandInBackground(isActive: presentation.content.standsInForGrid)
 
             if presentation.showsStatusBar {
-                statusBar(tab: tab)
+                if let model = coordinator.activeGridModel {
+                    DataGridModelReader(model: model) { model in
+                        statusBar(tab: tab, selectedRowCount: model.selection.affectedRows.count)
+                    }
+                } else {
+                    statusBar(tab: tab, selectedRowCount: 0)
+                }
             }
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
@@ -770,40 +672,41 @@ struct MainEditorContentView: View {
             }
         case .map:
             if let resultSet = tab.display.activeResultSet {
-                ResultMapView(
-                    configuration: mapConfigurationBinding(for: tab),
-                    columns: tab.display.spatialColumns,
+                DataGridModelReader(model: coordinator.gridModel(forTab: tab.id)) { model in
+                    ResultMapView(
+                        configuration: mapConfigurationBinding(for: tab),
+                        columns: tab.display.spatialColumns,
+                        tableRows: rows,
+                        displayIDs: model.displayedRowIDs,
+                        selectedRowIDs: Set(model.selectedRowIDs),
+                        tabId: tab.id,
+                        resultSetId: resultSet.id,
+                        dataRevision: coordinator.tabSessionRegistry.session(for: tab.id)?.dataRevision ?? 0,
+                        displayRevision: coordinator.gridDisplayRevision,
+                        onSelectRow: { rowID in
+                            if let rowID {
+                                model.selectRows([rowID])
+                            } else {
+                                model.clearSelection()
+                            }
+                        }
+                    )
+                }
+                .id(tab.id)
+            }
+        case .json:
+            DataGridModelReader(model: coordinator.gridModel(forTab: tab.id)) { model in
+                ResultsJsonView(
                     tableRows: rows,
-                    displayIDs: coordinator.displayIDs(forTab: tab.id),
-                    selectedRowIndices: selectionState.indices,
-                    tabId: tab.id,
-                    resultSetId: resultSet.id,
+                    selectedRowIDs: Set(model.selectedRowIDs),
+                    displayIDs: model.displayedRowIDs,
+                    deletedRowIDs: changeManager.deletedRowIDs,
+                    valueFilter: tab.valueFilter,
                     dataRevision: coordinator.tabSessionRegistry.session(for: tab.id)?.dataRevision ?? 0,
                     displayRevision: coordinator.gridDisplayRevision,
-                    onSelectRow: { displayIndex in
-                        let selected: Set<Int> = displayIndex.map { [$0] } ?? []
-                        selectionState.indices = selected
-                        /// The shared channel alone does not survive the trip to Data mode: the
-                        /// grid remounts and restores the tab's own stored selection over it,
-                        /// which a map click never wrote. Storing it here is the same half that
-                        /// #2667 added for a mode switch, and the cell rectangle is cleared
-                        /// because a shape names a row and no columns.
-                        coordinator.storeGridSelection(rows: selected, cells: .empty, forTab: tab.id)
-                    }
+                    columnLayout: tab.columnLayout
                 )
-                .id(tab.id)
             }
-        case .json:
-            ResultsJsonView(
-                tableRows: rows,
-                selectedRowIndices: selectionState.indices,
-                displayIDs: coordinator.displayIDs(forTab: tab.id),
-                deletedRowIDs: changeManager.deletedRowIDs,
-                valueFilter: tab.valueFilter,
-                dataRevision: coordinator.tabSessionRegistry.session(for: tab.id)?.dataRevision ?? 0,
-                displayRevision: coordinator.gridDisplayRevision,
-                columnLayout: tab.columnLayout
-            )
             .id(tab.id)
         case .grid:
             dataGridView(tab: tab)
@@ -833,8 +736,7 @@ struct MainEditorContentView: View {
         )
     }
 
-    /// Gathers what the resolver needs. The one place tab state is read for this decision, so the
-    /// conditions cannot drift apart the way they did while each arm tested its own combination.
+    // The one place tab state is read for this decision, so the conditions cannot drift apart again.
     private func resultPresentation(for tab: QueryTab, rows: TableRows) -> QueryResultPresentation {
         let activeResultSet = tab.display.activeResultSet
         var inputs = QueryResultInputs()
@@ -860,12 +762,10 @@ struct MainEditorContentView: View {
         inputs.executionStatusMessage = tab.execution.statusMessage
         inputs.hasAppliedFilters = tab.filterState.hasAppliedFilters
         inputs.isFilterPanelVisible = tab.filterState.isVisible
-        inputs.isFindBarVisible = tab.findState.isVisible
         return QueryResultPresentation(inputs: inputs)
     }
 
-    /// Shared by every mode whose `showsRowFilters` is true. Filtering rebuilds the query and
-    /// re-runs it, so a mode that renders this panel shows filtered rows without knowing about it.
+    // Filtering rebuilds and reruns the query, so a mode showing this panel gets filtered rows without knowing.
     @ViewBuilder
     private func rowFilterChrome(tab: QueryTab, rows: TableRows) -> some View {
         if tab.filterState.isVisible && tab.tabType == .table
@@ -887,8 +787,7 @@ struct MainEditorContentView: View {
         }
     }
 
-    /// Identified by its result set, so one plan's selection, zoom and scroll never carry onto the
-    /// next plan shown in the same place.
+    // Identified by its result set so one plan's selection, zoom and scroll never carry onto the next.
     private func queryPlanResultView(for resultSet: ResultSet, in tab: QueryTab) -> some View {
         QueryPlanResultView(
             rawText: resultSet.explainRawText ?? "",
@@ -905,9 +804,7 @@ struct MainEditorContentView: View {
         .id(resultSet.id)
     }
 
-    /// Whether the grid is the thing on screen, which is what decides if there is anything to jump
-    /// a column into. Asked of the resolver so it cannot disagree with what was actually rendered,
-    /// which is what a second hand-written copy of the condition used to do.
+    // Asked of the resolver so it cannot disagree with what was rendered, as a hand-written copy once did.
     private func showsGrid(tab: QueryTab, rows: TableRows) -> Bool {
         resultPresentation(for: tab, rows: rows).content == .grid
     }
@@ -924,93 +821,45 @@ struct MainEditorContentView: View {
         .frame(maxWidth: .infinity, maxHeight: .infinity)
     }
 
+    // Configuration is applied outside the update pass: the model publishes when it changes.
     @ViewBuilder
     private func dataGridView(tab: QueryTab) -> some View {
-        let refusal = coordinator.activeResultEditRefusal
-        let isEditable = coordinator.canEditActiveResult
-
-        let tabId = tab.id
-        DataGridView(
-            tableRowsProvider: { [coordinator] in
-                coordinator.tabSessionRegistry.existingTableRows(for: tabId) ?? TableRows()
-            },
-            tableRowsMutator: { [coordinator] mutate in
-                coordinator.mutateActiveTableRows(for: tabId) { rows in mutate(&rows) }
-            },
-            paginationOffsetProvider: { [coordinator] in
-                coordinator.tabManager.tabs.first(where: { $0.id == tabId })?.pagination.currentOffset ?? 0
-            },
-            changeManager: currentChangeManager,
-            isEditable: isEditable,
-            configuration: DataGridConfiguration(
-                connectionId: connection.id,
-                databaseType: connection.type,
-                tableName: tab.tableContext.tableName,
-                databaseName: tab.tableContext.databaseName,
-                schemaName: tab.tableContext.schemaName,
-                primaryKeyColumns: changeManager.primaryKeyColumns,
-                tabType: tab.tabType,
-                showRowNumbers: settingsManager.dataGrid.showRowNumbers,
-                hiddenColumns: tab.columnLayout.hiddenColumns,
-                appliesRowSortPreferences: true,
-                appliesRowCopyFormat: true,
-                supportsColumnSort: tab.tabType != .table
-                    || PluginManager.shared.supportsColumnSort(for: connection.type),
-                editRefusalMessage: refusal?.message
-            ),
-            displayFormats: coordinator.displayFormats(for: tab),
-            highlightRules: coordinator.highlightRules(for: tab),
-            delegate: dataTabDelegate,
-            selectedRowIndices: Binding(
-                get: { selectionState.indices },
-                set: { selectionState.indices = $0 }
-            ),
-            sortState: sortStateBinding(for: tab),
-            columnLayout: columnLayoutBinding(for: tab),
-            valueFilter: valueFilterBinding(for: tab),
-            displayOrderProvider: { [coordinator] in
-                coordinator.displayIDs(forTab: tabId)
-            },
-            displayState: coordinator.displayState(for: tab),
-            restoredRowSelection: tab.selectedRowIndices,
-            restoredCellSelection: tab.cellSelection,
-            onSelectionTeardown: { [coordinator] rows, cells in
-                coordinator.storeGridSelectionOnTeardown(rows: rows, cells: cells, forTab: tabId)
-            },
-            viewportPlacementProvider: { [coordinator] in
-                coordinator.takeViewportPlacement(forTab: tabId)
-            },
-            selectionSummary: coordinator.selectionSummary
-        )
-        .id(tabId)
-        .frame(maxHeight: .infinity, alignment: .top)
+        let model = displayedGridModel(for: tab)
+        let configuration = coordinator.gridConfiguration(for: tab)
+        let highlightRules = coordinator.highlightRules(for: tab)
+        DataGridView(model: model)
+            .id(tab.id)
+            .frame(maxHeight: .infinity, alignment: .top)
+            .onAppear {
+                model.configuration = configuration
+                focusGridIfRequested(model)
+            }
+            .onChange(of: configuration) { model.configuration = $0 }
+            .onChange(of: highlightRules) { _ in
+                model.display.cache.clearHighlights()
+                model.repaintAllRows()
+            }
     }
 
-    private func resolvedTableRows(for tab: QueryTab) -> TableRows {
-        coordinator.tabSessionRegistry.existingTableRows(for: tab.id) ?? TableRows()
+    private func displayedGridModel(for tab: QueryTab) -> DataGridModel {
+        let model = coordinator.gridModel(forTab: tab.id)
+        coordinator.prepareGridModelForDisplay(forTab: tab.id)
+        return model
     }
 
-    private func valueFilterBinding(for tab: QueryTab) -> Binding<GridValueFilterState> {
-        let tabId = tab.id
-        return Binding(
-            get: { tab.valueFilter },
-            set: { coordinator.setValueFilter($0, forTab: tabId) }
-        )
+    // An explicit open asks for the keyboard; the grid is in its window once this turn ends.
+    private func focusGridIfRequested(_ model: DataGridModel) {
+        guard coordinator.consumePendingGridFocus() else { return }
+        Task { @MainActor in
+            model.focus()
+        }
     }
 
-    private func sortStateBinding(for tab: QueryTab) -> Binding<SortState> {
-        Binding(
-            get: { tab.sortState },
-            set: { newValue in
-                if let index = tabManager.selectedTabIndex {
-                    tabManager.mutate(at: index) { $0.sortState = newValue }
-                }
-            }
-        )
+    private func resolvedTableRows(for tab: QueryTab) -> TableRows {
+        coordinator.tabSessionRegistry.existingTableRows(for: tab.id) ?? TableRows()
     }
 
-    /// The chart's choices belong to the tab, not to the result set: a page turn, a sort or a
-    /// re-execute builds a new `ResultSet`, and the axes have to outlive it.
+    // Owned by the tab: a page turn, sort or rerun builds a new `ResultSet`, and the axes must outlive it.
     private func chartConfigurationBinding(for tab: QueryTab) -> Binding<ResultChartConfiguration> {
         Binding(
             get: { tab.chartConfiguration },
@@ -1022,8 +871,7 @@ struct MainEditorContentView: View {
         )
     }
 
-    /// The map's choices belong to the tab for the same reason the chart's do: a page turn, a sort
-    /// or a re-execute builds a new `ResultSet`, and the chosen column has to outlive it.
+    // Owned by the tab like the chart's: a page turn, sort or rerun builds a new `ResultSet`, and the column must outlive it.
     private func mapConfigurationBinding(for tab: QueryTab) -> Binding<ResultMapConfiguration> {
         let tabId = tab.id
         return Binding(
@@ -1034,23 +882,9 @@ struct MainEditorContentView: View {
         )
     }
 
-    private func columnLayoutBinding(for tab: QueryTab) -> Binding<ColumnLayoutState> {
-        let tabId = tab.id
-        return Binding(
-            get: { tab.columnLayout },
-            set: { newValue in
-                coordinator.isUpdatingColumnLayout = true
-                coordinator.applyColumnGeometry(from: newValue, toTabId: tabId)
-                Task { @MainActor in
-                    coordinator.isUpdatingColumnLayout = false
-                }
-            }
-        )
-    }
-
     // MARK: - Status Bar
 
-    private func statusBar(tab: QueryTab) -> some View {
+    private func statusBar(tab: QueryTab, selectedRowCount: Int) -> some View {
         let resolvedRows = resolvedTableRows(for: tab)
         let structureFooter = coordinator.structureSessions[tab.id]?.footer ?? StructureFooterCapability()
         let isExecuting = coordinator.tabExecution.isBusy(tab.id)
@@ -1069,7 +903,7 @@ struct MainEditorContentView: View {
             model: ResultStatusModel(
                 snapshot: snapshot,
                 viewMode: tab.display.resultsViewMode,
-                selectedRowCount: selectionState.indices.count
+                selectedRowCount: selectedRowCount
             ),
             snapshot: snapshot,
             filterState: tab.filterState,
@@ -1134,12 +968,7 @@ struct MainEditorContentView: View {
         )
     }
 
-    /// Empty unless the resolver says the chooser is on screen, so the bar and the pane agree on
-    /// whether there is a choice to make.
-    ///
-    /// Asked with only the three fields that decide it rather than a full `resultPresentation`,
-    /// which would pull the tab's whole row buffer out of the session registry to answer a question
-    /// that does not depend on a single row.
+    // Only the three deciding fields, not a full `resultPresentation`, which would pull the whole row buffer for a row-free answer.
     private func resultSetMenuModel(for tab: QueryTab) -> ResultSetMenuModel {
         var selectorInputs = QueryResultInputs()
         selectorInputs.tabType = tab.tabType
@@ -1172,6 +1001,7 @@ struct MainEditorContentView: View {
             set: { newValue in
                 Task { @MainActor in
                     if let index = tabManager.selectedTabIndex {
+                        coordinator.commitActiveGridEdit()
                         tabManager.mutate(at: index) { $0.display.resultsViewMode = newValue }
                     }
                 }
@@ -1275,8 +1105,7 @@ extension MainEditorContentView {
 }
 
 fileprivate extension MainEditorContentView {
-    /// The editor is kept per tab on the coordinator, keyed by the tab's id rather than the type's
-    /// name, so a rename that retitles the tab keeps its queue.
+    // Keyed by tab id, not type name, so a rename that retitles the tab keeps its queue.
     @ViewBuilder
     func userTypeContent(tab: QueryTab, objectRef: DatabaseObjectRef) -> some View {
         Group {
diff --git a/apple/TablePro/Views/Main/Child/QueryTabGridStateStore.swift b/apple/TablePro/Views/Main/Child/QueryTabGridStateStore.swift
new file mode 100644
index 0000000000..7bedc57c19
--- /dev/null
+++ b/apple/TablePro/Views/Main/Child/QueryTabGridStateStore.swift
@@ -0,0 +1,212 @@
+//
+//  QueryTabGridStateStore.swift
+//  TablePro
+//
+
+import Foundation
+
+@MainActor
+final class QueryTabGridStateStore: DataGridStateStore {
+    private static let layoutPersistDelay: Duration = .milliseconds(500)
+
+    let tabId: UUID
+    private weak var coordinator: MainContentCoordinator?
+    private let persister: FileColumnLayoutPersister
+
+    // Kept here rather than on the tab on every click: a tab write re-renders every view of the window.
+    var selectionSnapshot: GridSelectionSnapshot
+
+    private var ephemeralFormats: (key: EphemeralFormatKey, formats: [ValueDisplayFormat?])?
+    private var pendingLayout: (layout: ColumnLayoutState, key: ColumnLayoutTableKey)?
+    private var layoutPersistTask: Task<Void, Never>?
+
+    init(
+        tabId: UUID,
+        coordinator: MainContentCoordinator,
+        persister: FileColumnLayoutPersister = .shared
+    ) {
+        self.tabId = tabId
+        self.coordinator = coordinator
+        self.persister = persister
+        self.selectionSnapshot = coordinator.tabManager.tabs.first { $0.id == tabId }?.selectionSnapshot ?? .empty
+    }
+
+    private var tab: QueryTab? {
+        coordinator?.tabManager.tabs.first { $0.id == tabId }
+    }
+
+    private var tableRows: TableRows {
+        coordinator?.tabSessionRegistry.existingTableRows(for: tabId) ?? TableRows()
+    }
+
+    var layoutScope: DataGridLayoutScope {
+        guard let tab, tab.tabType == .table, let key = coordinator?.columnLayoutTableKey(for: tab) else {
+            return .ephemeral
+        }
+        return .table(key)
+    }
+
+    // MARK: - Sort and value filter
+
+    // The tab takes the sort only once the reload it asks for is confirmed, so the write is a request.
+    var sortState: SortState {
+        get { tab?.sortState ?? SortState() }
+        set { coordinator?.requestSort(newValue, forTab: tabId) }
+    }
+
+    var valueFilter: GridValueFilterState {
+        get { tab?.valueFilter ?? GridValueFilterState() }
+        set {
+            guard let coordinator, tab?.valueFilter != newValue else { return }
+            coordinator.setValueFilter(newValue, forTab: tabId)
+            coordinator.gridDisplayRevision &+= 1
+        }
+    }
+
+    // MARK: - Column layout
+
+    var columnLayout: ColumnLayoutState {
+        get {
+            guard let tab else { return ColumnLayoutState() }
+            var layout = tab.columnLayout
+            switch layoutScope {
+            case .table(let key):
+                if let stored = pendingLayout?.layout ?? persister.load(for: key) {
+                    layout.columnWidths = stored.columnWidths
+                    layout.columnContentWidths = stored.columnContentWidths
+                    layout.columnOrder = stored.columnOrder
+                    layout.frozenColumnCount = stored.frozenColumnCount
+                }
+            case .ephemeral:
+                if let order = layout.columnOrder, !Self.canRestoreColumnOrder(order, columns: tableRows.columns) {
+                    layout.columnOrder = nil
+                }
+            }
+            return layout
+        }
+        set {
+            guard let coordinator, let current = tab?.columnLayout else { return }
+            var layout = newValue
+            // The getter hid an order saved for other columns; it stays for when those columns come back.
+            if case .ephemeral = layoutScope, layout.columnOrder == nil, let kept = current.columnOrder,
+               !Self.canRestoreColumnOrder(kept, columns: tableRows.columns) {
+                layout.columnOrder = kept
+            }
+            if current != layout {
+                coordinator.isUpdatingColumnLayout = true
+                coordinator.tabManager.mutate(tabId: tabId) { $0.columnLayout = layout }
+                Task { @MainActor [weak coordinator] in
+                    coordinator?.isUpdatingColumnLayout = false
+                }
+            }
+            guard case .table(let key) = layoutScope else { return }
+            if newValue.hasNoGeometry {
+                discardPendingLayout()
+                persister.clearGeometry(for: key)
+                return
+            }
+            schedulePersist(newValue, key: key)
+        }
+    }
+
+    // A saved order names columns, which identify one only while the names are unique and match the result's (#1565).
+    private static func canRestoreColumnOrder(_ order: [String], columns: [String]) -> Bool {
+        let names = Set(columns)
+        return names.count == columns.count && Set(order) == names
+    }
+
+    private func schedulePersist(_ layout: ColumnLayoutState, key: ColumnLayoutTableKey) {
+        layoutPersistTask?.cancel()
+        pendingLayout = (layout, key)
+        layoutPersistTask = Task { @MainActor [weak self] in
+            try? await Task.sleep(for: Self.layoutPersistDelay)
+            guard !Task.isCancelled else { return }
+            self?.flushPendingLayout()
+        }
+    }
+
+    func flushPendingLayout() {
+        layoutPersistTask?.cancel()
+        layoutPersistTask = nil
+        guard let pending = pendingLayout else { return }
+        pendingLayout = nil
+        persister.save(pending.layout, for: pending.key)
+    }
+
+    // For a table that is gone: a flush would write the layout back over the clear.
+    func discardPendingLayout() {
+        layoutPersistTask?.cancel()
+        layoutPersistTask = nil
+        pendingLayout = nil
+    }
+
+    // MARK: - Display formats
+
+    var displayFormats: [ValueDisplayFormat?] {
+        get {
+            guard let coordinator, let tab else { return [] }
+            if let ephemeralFormats, ephemeralFormats.key == EphemeralFormatKey(tab: tab, columns: tableRows.columns) {
+                return ephemeralFormats.formats
+            }
+            return coordinator.displayFormats(for: tab)
+        }
+        set {
+            guard let coordinator, let tab else { return }
+            let columns = tableRows.columns
+            guard case .table = layoutScope, let scope = tab.tableContext.scope(connectionId: coordinator.connectionId) else {
+                ephemeralFormats = (EphemeralFormatKey(tab: tab, columns: columns), newValue)
+                coordinator.gridDisplayRevision &+= 1
+                return
+            }
+            let current = coordinator.displayFormats(for: tab)
+            let storageKeys = ValueDisplayFormatColumnKey.storageKeys(for: columns)
+            for (index, storageKey) in storageKeys.enumerated() {
+                let format = index < newValue.count ? newValue[index] : nil
+                let previous = index < current.count ? current[index] : nil
+                guard format != previous else { continue }
+                ValueDisplayFormatService.shared.setOverride(format, columnKey: storageKey, scope: scope)
+            }
+            coordinator.gridDisplayRevision &+= 1
+        }
+    }
+
+    // MARK: - Viewport
+
+    var viewportAnchor: GridViewportPlacement? {
+        get {
+            guard let session = coordinator?.tabSessionRegistry.session(for: tabId),
+                  let stage = session.viewportStage,
+                  stage.bufferEpoch == session.bufferEpoch else { return nil }
+            return stage.placement
+        }
+        set {
+            guard let registry = coordinator?.tabSessionRegistry else { return }
+            guard let newValue else {
+                _ = registry.takeViewportPlacement(for: tabId)
+                return
+            }
+            registry.stageViewportPlacement(newValue, for: tabId)
+        }
+    }
+}
+
+private struct EphemeralFormatKey: Equatable {
+    let resultSetId: UUID?
+    let schemaVersion: Int
+    let columns: [String]
+
+    init(tab: QueryTab, columns: [String]) {
+        resultSetId = tab.display.activeResultSetId
+        schemaVersion = tab.schemaVersion
+        self.columns = columns
+    }
+}
+
+private extension ColumnLayoutState {
+    var hasNoGeometry: Bool {
+        columnWidths.isEmpty
+            && columnContentWidths?.isEmpty != false
+            && columnOrder == nil
+            && frozenColumnCount == 0
+    }
+}
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCommandActions+Focus.swift b/apple/TablePro/Views/Main/Extensions/MainContentCommandActions+Focus.swift
index b27cae6072..ae4db04a18 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCommandActions+Focus.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCommandActions+Focus.swift
@@ -6,21 +6,16 @@
 import AppKit
 
 internal extension MainContentCommandActions {
-    /// Focus Results goes through the grid's own coordinator rather than naming a view, because the
-    /// grid already owns the call and answers whether it took the keyboard.
-    ///
-    /// A collapsed result pane keeps its grid attached to the window, so focusing without expanding
-    /// first sends the keyboard to a table clipped to nothing.
+    // A collapsed result pane keeps its grid in the window, so focusing it unexpanded hands the keyboard to nothing.
     @discardableResult
     func focusActiveGrid() -> Bool {
         expandResultsIfCollapsed()
-        return coordinator?.dataTabDelegate?.tableViewCoordinator?.focusGrid() ?? false
+        return coordinator?.focusActiveGrid() ?? false
     }
 
-    /// A grid that is not in a window cannot take the keyboard, which is the state a query tab with
-    /// no result, and every result view other than the data grid, leaves behind.
+    // Only a mounted grid can take the keyboard; a query tab with no result and every other result view have none.
     var canFocusActiveGrid: Bool {
-        coordinator?.dataTabDelegate?.tableViewCoordinator?.tableView?.window != nil
+        coordinator?.selectedTabGridModel?.isMounted == true
     }
 
     private func expandResultsIfCollapsed() {
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ChangeGuard.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ChangeGuard.swift
index b1260ffbc3..b730595993 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ChangeGuard.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ChangeGuard.swift
@@ -2,21 +2,16 @@
 //  MainContentCoordinator+ChangeGuard.swift
 //  TablePro
 //
-//  Guard against data-destructive operations when unsaved changes exist.
-//  Provides a reusable confirmation gate for sort, pagination, and filter operations.
-//
 
 import AppKit
 import Foundation
 
 extension MainContentCoordinator {
-    /// Check for unsaved changes and prompt user to confirm discarding them.
-    /// Returns true if the caller is safe to proceed (no changes, or user chose to discard).
     func confirmDiscardChangesIfNeeded(
         action: DiscardAction,
         completion: @escaping (Bool) -> Void
     ) {
-        dataTabDelegate?.tableViewCoordinator?.commitActiveCellEdit()
+        commitActiveGridEdit()
         guard changeManager.hasChanges else {
             completion(true)
             return
@@ -36,17 +31,12 @@ extension MainContentCoordinator {
         }
     }
 
-    /// The same gate, for an operation that does NOT re-query.
-    ///
-    /// An edit is written into the tab's loaded rows as well as being recorded, so every caller of
-    /// the plain gate above gets away with clearing only the records: sort, pagination, the WHERE
-    /// filter and refresh all re-run the query and replace the buffer. A per-column value filter
-    /// narrows the rows already loaded, so the edited values would stay on screen with nothing
-    /// tracking them, and the next edit would capture an unsaved value as its baseline. (#2667)
+    // Not the plain gate: a value filter keeps the loaded rows, so edited values would stay on screen untracked (#2667).
     func confirmDiscardRestoringRowsIfNeeded(
         action: DiscardAction,
         completion: @escaping (Bool) -> Void
     ) {
+        commitActiveGridEdit()
         guard changeManager.hasChanges else {
             completion(true)
             return
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnJump.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnJump.swift
index de06db3f7c..4158c4095f 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnJump.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnJump.swift
@@ -6,41 +6,34 @@
 import AppKit
 import Foundation
 
-/// Where a Jump to Column panel was opened from. A menu command can switch the tab under the
-/// panel before Return, and a commit that resolved the tab at that moment would jump to the same
-/// index in an unrelated result, so the commit is checked against the origin instead.
+// Where a Jump to Column panel was opened. A menu command can switch the tab under the panel before
+// Return, so the commit is checked against the origin rather than resolved at that moment.
 struct ColumnJumpOrigin {
     let tabId: UUID
-    weak var grid: TableViewCoordinator?
+    weak var model: DataGridModel?
 }
 
 extension MainContentCoordinator {
     static let columnJumpPanelIdentity = "column-jump"
 
-    /// The one column list the Columns popover and Jump to Column both read, so hiding and
-    /// jumping never disagree about what the result holds.
+    // The one column list the Columns popover and Jump to Column both read.
     func columnCatalog(for tab: QueryTab, resultRows: TableRows) -> [GridColumnEntry] {
-        let mountedGrid = tab.id == tabManager.selectedTabId ? dataTabDelegate?.tableViewCoordinator : nil
-        return GridColumnCatalog.entries(
+        GridColumnCatalog.entries(
             resultColumns: resultRows.columns,
             columnTypes: resultRows.columnTypes,
             hiddenColumns: tab.columnLayout.hiddenColumns,
-            displayOrder: mountedGrid?.visibleColumnDataIndices(),
+            displayOrder: existingGridModel(forTab: tab.id)?.columns.columns.map(\.dataIndex),
             pickerColumns: columnsForVisibilityPicker(for: tab, resultColumns: resultRows.columns)
         )
     }
 
-    /// Whether the selected tab has a data grid on screen to jump in. A query result with no rows
-    /// shows an empty-result view instead of a grid, and a collapsed results pane hides it, so the
-    /// grid's own attachment is the fact, not the view mode.
+    // A query with no rows shows an empty-result view and a collapsed pane hides the grid, so the mount decides.
     var hasMountedDataGrid: Bool {
-        guard let tab = tabManager.selectedTab, !tab.display.isResultsCollapsed,
-              let grid = dataTabDelegate?.tableViewCoordinator else { return false }
-        return grid.tableView?.window != nil
+        guard let tab = tabManager.selectedTab, !tab.display.isResultsCollapsed else { return false }
+        return existingGridModel(forTab: tab.id)?.isMounted == true
     }
 
-    /// Invoking the command while its own panel is up closes it, the way Open Quickly toggles.
-    /// An Open Quickly panel is replaced rather than closed: the reader asked for columns.
+    // The command closes its own panel, the way Open Quickly toggles; an Open Quickly panel is replaced.
     func showColumnJump(seededWith query: String = "") {
         guard let quickSwitcherPanel else { return }
         guard !quickSwitcherPanel.isPresenting(Self.columnJumpPanelIdentity) else {
@@ -48,16 +41,16 @@ extension MainContentCoordinator {
             return
         }
         guard hasMountedDataGrid, let tab = tabManager.selectedTab,
-              let grid = dataTabDelegate?.tableViewCoordinator else { return }
+              let model = existingGridModel(forTab: tab.id) else { return }
         let resultRows = tabSessionRegistry.existingTableRows(for: tab.id) ?? TableRows()
         let entries = columnCatalog(for: tab, resultRows: resultRows)
         guard !entries.isEmpty else { return }
 
-        let origin = ColumnJumpOrigin(tabId: tab.id, grid: grid)
+        let origin = ColumnJumpOrigin(tabId: tab.id, model: model)
         let panelView = ColumnJumpPanelView(
             entries: entries,
             initialQuery: query,
-            cursorColumnIndex: grid.focusedDataColumnIndex,
+            cursorColumnIndex: model.activeCell?.column.dataIndex,
             onCommit: { [weak self] entry in
                 self?.quickSwitcherPanel?.dismiss()
                 self?.jumpToColumn(entry, from: origin)
@@ -66,30 +59,72 @@ extension MainContentCoordinator {
         quickSwitcherPanel.present(panelView, over: contentWindow, identity: Self.columnJumpPanelIdentity)
     }
 
-    /// A hidden column has to be shown before it can be reached, and on a table tab showing it
-    /// means fetching it, so the jump is parked on the grid and lands once the column is presented.
-    ///
-    /// The entry was listed against the result the panel opened over. A result-set switch or a
-    /// re-run in the same tab keeps the tab and the grid and replaces the columns, so an index is
-    /// trusted only while the column at it still carries the entry's name.
+    // A hidden column is shown first, which on a table tab means fetching it, so the jump waits for it.
+    // An index is trusted only while the column at it still carries the entry's name.
     func jumpToColumn(_ entry: GridColumnEntry, from origin: ColumnJumpOrigin) {
         guard hasMountedDataGrid,
               let tab = tabManager.selectedTab, tab.id == origin.tabId,
-              let grid = origin.grid,
-              dataTabDelegate?.tableViewCoordinator === grid else { return }
+              let model = origin.model,
+              existingGridModel(forTab: tab.id) === model else { return }
         if entry.isHidden {
             guard tab.columnLayout.hiddenColumns.contains(entry.name) else { return }
-            grid.pendingColumnJump = PendingColumnJump(
+            dataGridEntries[tab.id]?.adapter.pendingColumnJump = ColumnJumpRequest(
                 name: entry.name,
                 dataIndex: entry.dataIndex,
-                tableKey: grid.columnLayoutKey,
+                tableKey: columnLayoutTableKey(for: tab),
                 awaitsResultReplacement: tab.tabType == .table
             )
             showColumn(entry.name)
             return
         }
+        let columns = model.rows.columns
         guard let dataIndex = entry.dataIndex,
-              grid.identitySchema.columnName(for: dataIndex) == entry.name else { return }
-        grid.jumpToColumn(dataIndex: dataIndex)
+              columns.indices.contains(dataIndex),
+              columns[dataIndex] == entry.name else { return }
+        jumpToColumn(dataIndex: dataIndex, in: model, tabId: tab.id)
+    }
+
+    // Puts the active cell in the column on the active row, or the first visible row, and scrolls it into view.
+    @discardableResult
+    private func jumpToColumn(dataIndex: Int, in model: DataGridModel, tabId: UUID) -> Bool {
+        guard let displayColumn = model.columns.displayPosition(ofDataIndex: dataIndex),
+              let column = model.columns.column(at: displayColumn) else { return false }
+        dataGridEntries[tabId]?.adapter.pendingColumnJump = nil
+        model.commitEditing()
+        let row = model.selection.activeCell?.row
+            ?? model.selection.affectedRows.first
+            ?? model.viewportSample()?.row
+            ?? 0
+        if let rowID = model.rowID(at: row) {
+            model.selectCell(GridCoord(row: row, displayColumn: displayColumn))
+            model.reveal(rowID: rowID, columnID: column.id)
+        } else {
+            model.revealColumn(column.id)
+        }
+        model.focus()
+        return true
+    }
+
+    // A request waiting for its refetch lands only on a new result, and one whose column that result
+    // does not carry is dropped rather than left armed.
+    func consumePendingColumnJump(forTab tabId: UUID, contentReplaced: Bool) {
+        guard let entry = dataGridEntries[tabId],
+              let pending = entry.adapter.pendingColumnJump,
+              let tab = tabManager.tabs.first(where: { $0.id == tabId }) else { return }
+        guard pending.tableKey == columnLayoutTableKey(for: tab) else {
+            entry.adapter.pendingColumnJump = nil
+            return
+        }
+        guard contentReplaced || !pending.awaitsResultReplacement else { return }
+        let columns = entry.model.rows.columns
+        let dataIndex = pending.dataIndex.flatMap { index in
+            columns.indices.contains(index) && columns[index] == pending.name ? index : nil
+        } ?? columns.firstIndex(of: pending.name)
+        if let dataIndex, jumpToColumn(dataIndex: dataIndex, in: entry.model, tabId: tabId) {
+            return
+        }
+        if contentReplaced {
+            entry.adapter.pendingColumnJump = nil
+        }
     }
 }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnVisibility.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnVisibility.swift
index da830b3246..543e5a7ecc 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnVisibility.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ColumnVisibility.swift
@@ -42,16 +42,7 @@ extension MainContentCoordinator {
         changeColumnScope { $0 = Set(columns) }
     }
 
-    /// Every route that changes which columns are fetched, behind the same gate the WHERE filter
-    /// uses on the very same `rebuildTableQuery` call.
-    ///
-    /// Hiding or showing a column re-runs the table's query with a different column list, so the
-    /// rows are replaced and any unsaved edit goes with them. Sort, pagination and the WHERE filter
-    /// all confirm before doing that; this was the one reload that did it without asking. (#2667)
-    ///
-    /// The set is mutated inside the approved work, so declining leaves the column list alone as
-    /// well as the edits. Only the first change in a run prompts: confirming clears the changes, so
-    /// every later toggle finds nothing to lose and passes straight through.
+    // Confirms like sort, pagination and the WHERE filter: re-running with a new column list drops unsaved edits (#2667).
     private func changeColumnScope(_ mutate: @escaping (inout Set<String>) -> Void) {
         confirmDiscardRestoringRowsIfNeeded(action: .columnVisibility) { [weak self] confirmed in
             guard confirmed, let self else { return }
@@ -77,11 +68,6 @@ extension MainContentCoordinator {
         mutateSelectedTabHiddenColumns(persist: false) { $0 = restored }
     }
 
-    func applyColumnGeometry(from geometry: ColumnLayoutState, toTabId tabId: UUID) {
-        guard let index = tabManager.tabs.firstIndex(where: { $0.id == tabId }) else { return }
-        tabManager.mutate(at: index) { $0.columnLayout.applyGeometry(from: geometry) }
-    }
-
     func clearColumnLayoutForSelectedTable() {
         guard let target = selectedColumnLayoutClearTarget() else { return }
         clearColumnLayout(target)
@@ -94,9 +80,11 @@ extension MainContentCoordinator {
     }
 
     func clearColumnLayout(_ target: ColumnLayoutClearTarget) {
-        if tabManager.selectedTabId == target.tabId,
-           dataTabDelegate?.tableViewCoordinator?.columnLayoutKey == target.tableKey {
-            dataTabDelegate?.tableViewCoordinator?.resetColumnGeometry()
+        if let entry = dataGridEntries[target.tabId],
+           let tab = tabManager.tabs.first(where: { $0.id == target.tabId }),
+           columnLayoutTableKey(for: tab) == target.tableKey {
+            entry.store.discardPendingLayout()
+            entry.model.updateColumnLayout { $0.resetGeometry() }
         }
         FileColumnLayoutPersister.shared.clearGeometry(for: target.tableKey)
         guard let index = tabManager.tabs.firstIndex(where: { $0.id == target.tabId }),
@@ -106,9 +94,7 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Reset clears the hidden set along with the widths, so it re-queries too and takes the same
-    /// confirmation. The width half is not undone by declining, because nothing about a width can
-    /// invalidate an edit; only the refetch can.
+    // Clearing the hidden set re-queries, so reset confirms too; declining keeps the width reset, since widths cannot void edits.
     func resetColumns() {
         confirmDiscardRestoringRowsIfNeeded(action: .columnVisibility) { [weak self] confirmed in
             guard confirmed, let self else { return }
@@ -118,8 +104,12 @@ extension MainContentCoordinator {
 
     private func applyColumnReset() {
         guard let index = tabManager.selectedTabIndex else { return }
-        dataTabDelegate?.tableViewCoordinator?.resetColumnGeometry()
         let tab = tabManager.tabs[index]
+        // Through the model, which rebuilds its columns: a query tab's requery reloads nothing, so it alone shows them again.
+        if let entry = dataGridEntries[tab.id] {
+            entry.store.discardPendingLayout()
+            entry.model.updateColumnLayout { $0 = ColumnLayoutState() }
+        }
         if let key = columnLayoutTableKey(for: tab) {
             FileColumnLayoutPersister.shared.clear(for: key)
         }
@@ -128,7 +118,7 @@ extension MainContentCoordinator {
     }
 
     // A temporary table's layout is not kept: the key would be the permanent table's of the same name.
-    private func columnLayoutTableKey(for tab: QueryTab) -> ColumnLayoutTableKey? {
+    func columnLayoutTableKey(for tab: QueryTab) -> ColumnLayoutTableKey? {
         guard !tab.tableContext.isTemporary, let tableName = tab.tableContext.tableName, !tableName.isEmpty else {
             return nil
         }
@@ -156,19 +146,15 @@ extension MainContentCoordinator {
         guard let index = tabManager.selectedTabIndex else { return }
         var hidden = tabManager.tabs[index].columnLayout.hiddenColumns
         mutate(&hidden)
-        let presentedRunChanged = hidden != tabManager.tabs[index].columnLayout.hiddenColumns
-        tabManager.mutate(at: index) { tab in
-            tab.columnLayout.hiddenColumns = hidden
-            /// A stored cell rectangle is a set of display positions in the presented run, and
-            /// hiding a column renumbers that run. Clamping cannot catch it: a position that is
-            /// still in range now names a different column, so the rectangle would come back
-            /// pointing at data the reader never selected. A mounted grid drops its own selection
-            /// on the same event; this is that rule for a tab whose grid is not mounted. (#2667)
-            guard presentedRunChanged, !tab.cellSelection.isEmpty else { return }
-            tab.cellSelection = .empty
+        guard hidden != tabManager.tabs[index].columnLayout.hiddenColumns else { return }
+        // Through the model first, which rebuilds its columns and keeps the selection by column identity.
+        existingGridModel(forTab: tabManager.tabs[index].id)?.updateColumnLayout { $0.hiddenColumns = hidden }
+        if tabManager.tabs[index].columnLayout.hiddenColumns != hidden {
+            tabManager.mutate(at: index) { $0.columnLayout.hiddenColumns = hidden }
         }
         if persist {
             persistTabHiddenColumns(tabManager.tabs[index])
         }
+        consumePendingColumnJump(forTab: tabManager.tabs[index].id, contentReplaced: false)
     }
 }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Discard.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Discard.swift
index 92aa925092..9289878f49 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Discard.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Discard.swift
@@ -14,6 +14,7 @@ extension MainContentCoordinator {
         pendingTruncates: inout Set<DatabaseTreeTableRef>,
         pendingDeletes: inout Set<DatabaseTreeTableRef>
     ) {
+        commitActiveGridEdit()
         rowEditingCoordinator.handleDiscard(
             pendingTruncates: &pendingTruncates,
             pendingDeletes: &pendingDeletes
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+DocumentEditing.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+DocumentEditing.swift
index 0a1ec6c5ed..323e2b9eb8 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+DocumentEditing.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+DocumentEditing.swift
@@ -6,13 +6,7 @@
 import Foundation
 
 extension MainContentCoordinator {
-    /// Whether the selected tab is a collection whose engine writes whole documents.
-    ///
-    /// One definition for every place that offers Insert Document or Edit Document: the Edit menu,
-    /// the row menu and the empty-space menu. Only a table tab, because the write ends by reloading
-    /// the tab and a query tab's result is not reloaded that way, so the change would not appear. A
-    /// tab with staged grid edits refuses it, because a reload over staged edits asks to discard them
-    /// in a sheet behind this one.
+    // Table tabs only: the write ends by reloading the tab. Staged grid edits refuse it, since that reload would ask to discard them.
     var documentEditingAvailable: Bool {
         guard canEditActiveResult,
               PluginManager.shared.supportsDocumentEditing(for: connection.type),
@@ -34,26 +28,17 @@ extension MainContentCoordinator {
         activeSheet = .documentEditor(DocumentEditorRequest(table: table, scope: scope))
     }
 
-    /// What the driver finds the document on a grid row by, read through the display order so a
-    /// sort or a value filter cannot hand back another row's document. Nil for a row the driver
-    /// gave none, which is a row Edit Document is not offered on.
-    func documentLocator(forDisplayRow displayRow: Int) -> String? {
+    // What the driver finds the row's document by; nil for a row it gave none, where Edit Document is not offered.
+    func documentLocator(for rowID: RowID) -> String? {
         guard documentEditingAvailable, let tab = tabManager.selectedTab else { return nil }
-        let tableRows = tabSessionRegistry.tableRows(for: tab.id)
-        guard let row = DisplayRowMapping.row(
-            forDisplay: displayRow,
-            displayIDs: activeGridDisplayIDs,
-            in: tableRows
-        ) else { return nil }
-        return tableRows.rowLocator(for: row.id)
+        return tabSessionRegistry.tableRows(for: tab.id).rowLocator(for: rowID)
     }
 
-    func canEditDocument(atDisplayRow displayRow: Int) -> Bool {
-        documentLocator(forDisplayRow: displayRow) != nil
+    func canEditDocument(rowID: RowID) -> Bool {
+        documentLocator(for: rowID) != nil
     }
 
-    /// Opens the editor on the document a locator names. The locator is resolved by the caller at
-    /// the moment the command was chosen, so a reload in between cannot move it to another row.
+    // The caller resolves the locator when the command is chosen, so a reload in between can't move it to another row.
     func presentEditDocument(locator: String) {
         guard documentEditingAvailable,
               let table = tabManager.selectedTab?.tableContext.tableName,
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ExecuteAll.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ExecuteAll.swift
index 3611d1e297..520eea9ae1 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ExecuteAll.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+ExecuteAll.swift
@@ -7,6 +7,7 @@ import Foundation
 
 extension MainContentCoordinator {
     func runAllStatements(extraCapabilities: CallerCapabilities = []) {
+        commitActiveGridEdit()
         queryExecutionCoordinator.runAllStatements(extraCapabilities: extraCapabilities)
     }
 
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift
index f3029f2d6a..ebc823b1b9 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift
@@ -14,9 +14,7 @@ private let fkNavigationLogger = Logger(subsystem: "com.TablePro", category: "FK
 extension MainContentCoordinator {
     // MARK: - Foreign Key Navigation
 
-    /// The JSON inspector's own route to the same navigation. It holds a `JSONForeignKeyRef`,
-    /// which is a `ForeignKeyInfo` without the identity and the referential actions, because a node
-    /// tree cannot hold a type whose `==` is a fresh `UUID`.
+    // The JSON inspector's route: a node tree can't hold ForeignKeyInfo, whose == compares a fresh UUID.
     func navigateToFKReference(reference: JSONForeignKeyRef, value: String) {
         navigateToFKReference(
             value: value,
@@ -31,14 +29,7 @@ extension MainContentCoordinator {
         )
     }
 
-    /// Navigate to the referenced table filtered by the FK value.
-    ///
-    /// The choice is `ReferenceNavigationPlanner`'s, so it can be read and tested in one place. It
-    /// never re-points the selected tab at a different table. A tab already on the referenced table
-    /// is re-filtered, which is a move within the table the reader is in and which Back undoes.
-    /// Retargeting used to be guarded by a predicate of its own, which knew about unsaved edits but
-    /// not about applied filters, a sort or pinned results, so the arrow in a cell took over a tab
-    /// the sidebar would have left alone and the reader lost the rows they were reading.
+    // Never retargets the selected tab: the old guard ignored filters, sort and pins, so a cell arrow lost the reader's rows.
     func navigateToFKReference(value: String, fkInfo: ForeignKeyInfo, intent: ReferenceOpenIntent) {
         let referencedTable = fkInfo.referencedTable
         let referencedColumn = fkInfo.referencedColumn
@@ -56,11 +47,7 @@ extension MainContentCoordinator {
             return
         }
 
-        /// The referenced table's own database and schema, not the raw catalog value. An engine
-        /// with no schema layer names the referenced database in the slot its catalog calls a
-        /// schema, and carrying that through gave a table reached by a key a different identity
-        /// from the same table opened from the sidebar: its own filters, its own column layout, no
-        /// tab to reuse, and a rename that never found it.
+        // Resolved scope, not the raw catalog value: schema-less engines put the database there, giving the table a second identity.
         let target = ForeignKeyTargetScope.resolve(
             origin: sourceScope,
             referencedDatabase: fkInfo.referencedDatabase,
@@ -85,17 +72,13 @@ extension MainContentCoordinator {
             for: ReferenceNavigationContext(
                 intent: intent,
                 selectedTabShowsTarget: showsTarget,
-                /// The discard alert clears staged cell edits and nothing else, so re-querying
-                /// under a staged structure edit would promise something this path cannot keep.
-                /// Back and Forward stand down on the same tab for the same reason.
+                // The discard alert clears only staged cell edits, so a staged structure edit rules out re-querying (Back/Forward too).
                 selectedTabAcceptsRefilter: selectedTab.map { !hasStagedStructureEdits(in: $0) } ?? false,
                 anotherTabShowsReference: existing != nil
             )
         )
 
-        /// Both jumps that leave the tab keep it. The reader navigated away from it rather than
-        /// clicking past it, so the next sidebar click must not retarget it; `openTableTab` promotes
-        /// before it hands off for the same reason. Re-filtering stays on the tab, so it does not.
+        // Jumps that leave the tab promote it, so the next sidebar click can't retarget it; re-filtering stays on the tab.
         switch plan {
         case .refilterSelectedTab:
             refilterSelectedTab(with: filter, showsReferenceAlready: selectedTab.map {
@@ -151,9 +134,7 @@ extension MainContentCoordinator {
             isVisible: true,
             filterLogicMode: .and
         )
-        /// This payload is only built once no open tab could take the jump, so it must land in a
-        /// tab of its own. Reusing one would write the FK filter over filters the user applied
-        /// there, and leave the grid on rows the new filter never ran against.
+        // Built only when no open tab could take the jump; reusing one would write the FK filter over the user's own filters.
         return EditorTabPayload(
             connectionId: connection.id,
             tabType: .table,
@@ -166,31 +147,6 @@ extension MainContentCoordinator {
         )
     }
 
-    /// Toggle FK preview for the currently focused cell in the data grid.
-    /// Called from the menu command system (Settings > Keyboard rebindable).
-    /// `focusedColumn` is a position in `tableView.tableColumns`, which carries the row-number
-    /// column and a hidden spacer before the data, and which the reader can reorder. Subtracting a
-    /// fixed offset from it named a different column than the one they were on, or none at all, so
-    /// this resolves it by column identity the way the key-equivalent path already does.
-    func toggleFKPreviewForFocusedCell() {
-        guard let tableView = NSApp.keyWindow?.firstResponder as? KeyHandlingTableView,
-              let coordinator = tableView.coordinator,
-              tableView.selectedRow >= 0,
-              tableView.presentsDataColumn(at: tableView.focusedColumn),
-              let columnIndex = DataGridView.dataColumnIndex(
-                  for: tableView.focusedColumn,
-                  in: tableView,
-                  schema: coordinator.identitySchema
-              )
-        else { return }
-        coordinator.toggleForeignKeyPreview(
-            tableView: tableView,
-            row: tableView.selectedRow,
-            column: tableView.focusedColumn,
-            columnIndex: columnIndex
-        )
-    }
-
     private func matchesFKTarget(_ tab: QueryTab, table: String, database: String, schema: String?) -> Bool {
         tab.tabType == .table
             && tab.tableContext.tableName == table
@@ -204,21 +160,14 @@ extension MainContentCoordinator {
             && lhs.value == rhs.value
     }
 
-    /// Whether this tab is already showing exactly this reference and nothing else. One definition,
-    /// because the reuse search and the history both have to agree on what "already here" means.
-    ///
-    /// Asked of what the rows were fetched with, never of `appliedFilters`, which resolves from the
-    /// panel's editable draft. Typing `id = 42` into a tab showing `id = 7` and not pressing Apply
-    /// made that tab answer yes, and revealing it runs no query, so the reader landed on the rows
-    /// for 7 while the app reported it had found the reference.
+    // Asks what the rows were fetched with, not appliedFilters, which reads the unapplied draft and claimed a false match.
     private func showsOnlyFKPredicate(_ tab: QueryTab, filter: TableFilter) -> Bool {
         let applied = tab.filterState.executedFilters
         guard applied.count == 1 else { return false }
         return isSameFKPredicate(applied[0], filter)
     }
 
-    /// A tab already showing exactly this reference. Matching the filter too keeps a click on a
-    /// different row from re-filtering a tab the user opened for another one.
+    // Matching the filter too keeps a click on a different row from re-filtering a tab opened for another one.
     private func openFKTargetTab(
         table: String,
         database: String,
@@ -234,9 +183,7 @@ extension MainContentCoordinator {
             return (self, match.id)
         }
 
-        /// Hosted coordinators, not `allActiveCoordinators()`, which is a registry of every
-        /// coordinator SwiftUI has built and can hold one whose window is gone. A reveal has to
-        /// land somewhere the reader can see.
+        // Hosted coordinators, not allActiveCoordinators(), which can hold one whose window is gone.
         for sibling in hostedTabRouting.coordinators(connectionId) where sibling !== self {
             guard let match = sibling.tabManager.tabs.first(where: matches) else { continue }
             return (sibling, match.id)
@@ -244,16 +191,9 @@ extension MainContentCoordinator {
         return nil
     }
 
-    /// Re-points the tab the reader is already on at another row of the same table.
-    ///
-    /// Everything happens inside one discard guard. The pair this replaced ran `applyFilters`,
-    /// which defers behind the alert, beside `setFKFilter`, which does not, so refusing the alert
-    /// left the panel showing an applied filter the grid was never re-queried for and pushed a
-    /// history entry for a jump that never happened, dropping the forward stack with it.
+    // One discard guard: applyFilters deferred behind the alert but setFKFilter didn't, so a refusal left a stale filter.
     private func refilterSelectedTab(with filter: TableFilter, showsReferenceAlready: Bool) {
-        /// Re-filtering the tab in place is a jump like any other, so it goes on the history.
-        /// Clicking the reference the tab is already showing is not, and recording it would stack
-        /// identical entries a reader has to press Back through.
+        // Not recorded when the tab already shows this reference, or Back would step through identical entries.
         let departing = showsReferenceAlready ? nil : captureNavigationEntry()
         confirmDiscardChangesIfNeeded(action: .filter) { [weak self] confirmed in
             guard let self, confirmed else { return }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridDisplay.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridDisplay.swift
index 7ae13eb2c3..4e453a18d1 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridDisplay.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridDisplay.swift
@@ -10,232 +10,37 @@ import Foundation
 import TableProPluginKit
 import TableProUtilities
 
-/// A resolved display order plus the inputs it was resolved from.
-///
-/// `rowSetRevision` is ticked by `TabSessionRegistry` whenever rows arrive, leave or are replaced,
-/// and never for a cell edit. An edit that takes a row out of the filter's match therefore leaves it
-/// where it is until one of the three inputs here moves, which is what the grid shows, and every
-/// reader that maps a display position through this order lands on the row the grid has at that
-/// position. The display formats are one of those inputs because the filter matches formatted text,
-/// so changing a column's format re-resolves the order the way changing the filter does.
-struct DisplayOrderCacheEntry {
-    let rowSetRevision: Int
-    let valueFilter: GridValueFilterState
-    let displayFormats: [ValueDisplayFormat?]
-    let displayIDs: [RowID]?
-
-    func matches(
-        rowSetRevision: Int,
-        valueFilter: GridValueFilterState,
-        displayFormats: [ValueDisplayFormat?]
-    ) -> Bool {
-        self.rowSetRevision == rowSetRevision
-            && self.valueFilter == valueFilter
-            && self.displayFormats == displayFormats
-    }
-}
-
-/// A tab's formatted-cell text, kept across the grid remounts a tab switch causes, plus the inputs
-/// that decided it.
-struct DisplayStateCacheEntry {
-    let identity: DataGridDisplayIdentity
-    let state: DataGridDisplayState
-    var lastUsed: Int
-}
-
 extension MainContentCoordinator {
-    /// The formatted text and viewport anchor for a tab's result, kept here because the grid that
-    /// derives them is destroyed and rebuilt on every tab switch.
-    ///
-    /// A stale entry is replaced rather than repaired: the cache is keyed by row id, row ids are
-    /// positional, and a new page reuses the ids of the one before it, so anything that can change
-    /// what a position holds has to be part of the identity. It keys on `bufferEpoch` rather than
-    /// `dataRevision` for exactly that reason: an in-place edit keeps every row id, and the grid
-    /// already drops the one row it touched, so replacing the whole entry there would re-format the
-    /// page after every keystroke that commits. (#2424)
-    func displayState(for tab: QueryTab) -> DataGridDisplayState {
-        let settings = AppSettingsManager.shared.dataGrid
-        let tableRows = tabSessionRegistry.existingTableRows(for: tab.id)
-        let identity = DataGridDisplayIdentity(
-            bufferEpoch: tabSessionRegistry.session(for: tab.id)?.bufferEpoch ?? 0,
-            resultSetId: tab.display.activeResultSetId,
-            columns: tableRows?.columns ?? [],
-            columnTypes: tableRows?.columnTypes ?? [],
-            displayFormats: displayFormats(for: tab),
-            dateFormat: settings.dateFormat,
-            nullDisplay: settings.nullDisplay,
-            smartValueDetection: settings.enableSmartValueDetection,
-            systemTimeZoneGeneration: DateFormattingService.shared.systemTimeZoneGeneration
-        )
-
-        displayStateClock &+= 1
-        if let cached = displayStateCache[tab.id], cached.identity == identity {
-            displayStateCache[tab.id]?.lastUsed = displayStateClock
-            return cached.state
-        }
-        let state = DataGridDisplayState()
-        displayStateCache[tab.id] = DisplayStateCacheEntry(
-            identity: identity,
-            state: state,
-            lastUsed: displayStateClock
-        )
-        pruneDisplayStateCache()
-        return state
-    }
-
-    /// Each entry holds a whole result's formatted text, budgeted at 64 MB by `RowDisplayCache`, so
-    /// the tabs the user is actually moving between keep theirs and the rest give it back. The
-    /// budget is the one inactive row data already uses, so the two do not disagree about how many
-    /// background tabs are worth keeping.
-    private func pruneDisplayStateCache() {
-        let budget = MemoryPressureAdvisor.budgetForInactiveTabs() + 1
-        guard displayStateCache.count > budget else { return }
-        let ordered = displayStateCache.sorted { $0.value.lastUsed > $1.value.lastUsed }
-        for entry in ordered.dropFirst(budget) {
-            displayStateCache.removeValue(forKey: entry.key)
-        }
-    }
-
-    /// Keeps a grid's selection on its tab, so returning to the tab does not start with nothing
-    /// selected.
-    ///
-    /// `handleTabChange` has always restored `selectedRowIndices` on the way in, but nothing ever
-    /// wrote it: outside a paste, its only writers set it to empty, so every switch back replayed an
-    /// empty set over the reader's selection. This is the missing half, and it is driven by the
-    /// grid's own teardown rather than by the tab switch, because the grid is also destroyed when
-    /// the tab changes result mode, which is not a tab switch at all. (#2667)
-    /// The check is made before `mutate`, not inside it. An `inout` access to an array element runs
-    /// the array's setter whether or not the block writes anything, so guarding inside would still
-    /// invalidate every observer of `tabs` on the way out of a grid that had nothing selected.
-    func storeGridSelection(rows: Set<Int>, cells: GridSelection, forTab tabId: UUID) {
-        guard let tab = tabManager.tabs.first(where: { $0.id == tabId }),
-              tab.selectedRowIndices != rows || tab.cellSelection != cells else { return }
-        tabManager.mutate(tabId: tabId) { tab in
-            tab.selectedRowIndices = rows
-            tab.cellSelection = cells
-        }
-    }
-
-    /// The grid's own teardown, which is authoritative only while its tab is still the selected one.
-    ///
-    /// A result-mode switch destroys the grid without changing tabs, and there the table view still
-    /// holds what the reader selected. A tab switch does not: `handleTabChange` repoints the shared
-    /// `GridSelectionState` at the incoming tab while the outgoing grid is still mounted and bound to
-    /// it, so `syncSelection` clears the outgoing table view on the way out and the teardown reads an
-    /// empty selection (measured). That case is captured in `handleTabChange` instead, before the
-    /// repoint. (#2667)
-    func storeGridSelectionOnTeardown(rows: Set<Int>, cells: GridSelection, forTab tabId: UUID) {
-        guard tabManager.selectedTabId == tabId else { return }
-        storeGridSelection(rows: rows, cells: cells, forTab: tabId)
-    }
-
-    /// What the mounted data grid has selected right now.
-    ///
-    /// Only ever one grid is mounted, so this needs no tab argument; callers decide which tab the
-    /// answer belongs to. `handleTabChange` reads it for the tab it is leaving, which is still the
-    /// mounted one at the point it runs.
-    func mountedGridSelection() -> (rows: Set<Int>, cells: GridSelection)? {
-        guard let grid = dataTabDelegate?.tableViewCoordinator,
-              let tableView = grid.tableView else { return nil }
-        return (Set(tableView.selectedRowIndexes), grid.selectionController.selection)
-    }
-
-    /// The rows the grid is displaying, in display order, or nil when that is the storage order.
-    ///
-    /// Resolved from the tab rather than from the mounted grid. SwiftUI destroys an
-    /// `NSViewRepresentable`'s coordinator the moment the representable leaves the view tree, so
-    /// reading the order off `TableViewCoordinator` returned nil in JSON, Structure and Chart mode
-    /// and silently degraded every caller to storage order. (#2251)
+    // The rows the grid shows, in display order, or nil when that is the storage order. Read from the
+    // tab's model, which resolves the order with no grid mounted (#2251).
     func displayIDs(forTab tabId: UUID) -> [RowID]? {
-        guard let tab = tabManager.tabs.first(where: { $0.id == tabId }) else { return nil }
-        guard tab.valueFilter.isActive else { return nil }
-
-        let session = tabSessionRegistry.session(for: tabId)
-        let rowSetRevision = session?.rowSetRevision ?? 0
-        let formats = displayFormats(for: tab)
-
-        if let cached = displayOrderCache[tabId],
-           cached.matches(rowSetRevision: rowSetRevision, valueFilter: tab.valueFilter, displayFormats: formats) {
-            return cached.displayIDs
-        }
-
-        let resolved = GridDisplayOrderResolver.resolve(
-            tableRows: session?.tableRows ?? TableRows(),
-            valueFilter: tab.valueFilter,
-            displayFormats: formats,
-            databaseType: connection.type
-        )
-        displayOrderCache[tabId] = DisplayOrderCacheEntry(
-            rowSetRevision: rowSetRevision,
-            valueFilter: tab.valueFilter,
-            displayFormats: formats,
-            displayIDs: resolved
-        )
-        return resolved
-    }
-
-    /// Resolves the order now, against the rows as they stand, and stores it for every later reader.
-    ///
-    /// The order is a function of the values the rows held when the filter or the row set last
-    /// changed, not of the values they hold when someone asks. Resolving it lazily makes the answer
-    /// depend on whether anything happened to read it before the edit: the first read after an edit
-    /// that takes a row out of the filter's match drops that row, while the grid goes on showing it,
-    /// and every display position from there on names a different row than the grid has.
-    @discardableResult
-    func refreshDisplayOrder(forTab tabId: UUID) -> [RowID]? {
-        displayOrderCache.removeValue(forKey: tabId)
-        return displayIDs(forTab: tabId)
+        guard let tab = tabManager.tabs.first(where: { $0.id == tabId }), tab.valueFilter.isActive else { return nil }
+        return gridModel(forTab: tabId).displayedRowIDs
     }
 
     func setValueFilter(_ valueFilter: GridValueFilterState, forTab tabId: UUID) {
         guard tabManager.tabs.first(where: { $0.id == tabId })?.valueFilter != valueFilter else { return }
         tabManager.mutate(tabId: tabId) { $0.valueFilter = valueFilter }
-        refreshDisplayOrder(forTab: tabId)
     }
 
-    /// Re-reading the same source can move or drop columns, so the filter follows its columns by name.
-    /// The mounted grid's mirror takes the result before the full replace, or its own prune of the old
-    /// copy would write that back over the tab.
+    // Re-reading the same source can move or drop columns, so the filter follows its columns by name.
     func carryValueFilter(onto columns: [String], forTab tabId: UUID) {
         guard let current = tabManager.tabs.first(where: { $0.id == tabId })?.valueFilter,
               current.isActive else { return }
-        /// The format cache keys on the result, which is replaced only after these rows are installed,
-        /// so it still holds the outgoing columns' formats by position.
+        // Keyed on the result, which is replaced only after these rows are installed.
         displayFormatsCache.removeValue(forKey: tabId)
         let carried = current.remapped(toColumns: columns)
-        if carried != current {
-            displayOrderCache.removeValue(forKey: tabId)
-            tabManager.mutate(tabId: tabId) { $0.valueFilter = carried }
-        }
-        if tabManager.selectedTabId == tabId {
-            dataTabDelegate?.tableViewCoordinator?.adoptValueFilter(carried)
-        }
+        guard carried != current else { return }
+        tabManager.mutate(tabId: tabId) { $0.valueFilter = carried }
     }
 
-    /// Drops a value filter whose rows have been replaced wholesale.
-    ///
-    /// The filter stores the displayed strings the user picked out of the loaded rows, so it means
-    /// nothing once those rows are gone. Left in place it narrows an unrelated result to nothing,
-    /// and in JSON mode there is not even a header indicator to explain why.
-    ///
-    /// A mounted grid holds its own mirror of the filter and is told about the clear here rather
-    /// than at the next view update, because `setActiveTableRows` drives the grid's full reload on
-    /// the very next line. Left to the view update, that reload would resolve the new rows through
-    /// the old filter, and pruning the old filter against the new columns would write it back onto
-    /// the tab that was just cleared.
+    // The filter holds displayed strings picked out of rows that are gone, so on new rows it narrows to nothing.
     func clearValueFilter(forTab tabId: UUID) {
-        displayOrderCache.removeValue(forKey: tabId)
-        if tabManager.selectedTabId == tabId {
-            dataTabDelegate?.tableViewCoordinator?.adoptValueFilter(GridValueFilterState())
-        }
         guard tabManager.tabs.first(where: { $0.id == tabId })?.valueFilter.isActive == true else { return }
         tabManager.mutate(tabId: tabId) { $0.valueFilter.clearAll() }
     }
 
-    /// The per-column display formats for a tab's result, cached on the inputs that decide them.
-    ///
-    /// Lives here rather than in the view because the display order is matched on formatted values,
-    /// and that has to resolve with no view mounted.
+    // Resolved here because the display order matches formatted values with no grid mounted.
     func displayFormats(for tab: QueryTab) -> [ValueDisplayFormat?] {
         let settings = AppSettingsManager.shared.dataGrid
         let service = ValueDisplayFormatService.shared
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridFocus.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridFocus.swift
index ba06eb60ad..10bca66439 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridFocus.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridFocus.swift
@@ -6,8 +6,9 @@
 import Foundation
 
 internal extension MainContentCoordinator {
-    func focusActiveGrid() {
-        dataTabDelegate?.tableViewCoordinator?.focusGrid()
+    @discardableResult
+    func focusActiveGrid() -> Bool {
+        selectedTabGridModel?.focus() ?? false
     }
 
     func consumePendingGridFocus() -> Bool {
@@ -16,10 +17,8 @@ internal extension MainContentCoordinator {
         return true
     }
 
-    /// Focus the active grid now if it is already attached, otherwise defer to the grid
-    /// as it appears. Use for explicit-open gestures where the target grid may or may not
-    /// be rebuilt (e.g. promoting a preview tab).
+    // For an explicit open: focus a grid already on screen, or let the grid take it as it mounts.
     func requestGridFocus() {
-        pendingGridFocusOnOpen = !(dataTabDelegate?.tableViewCoordinator?.focusGrid() ?? false)
+        pendingGridFocusOnOpen = !focusActiveGrid()
     }
 }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridModels.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridModels.swift
new file mode 100644
index 0000000000..268fc780cf
--- /dev/null
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridModels.swift
@@ -0,0 +1,254 @@
+//
+//  MainContentCoordinator+GridModels.swift
+//  TablePro
+//
+
+import Combine
+import Foundation
+import TableProUtilities
+
+// The Structure and Create Table owners answer which of their grids is on screen.
+@MainActor
+protocol ActiveGridModelProviding: AnyObject {
+    var activeGridModel: DataGridModel? { get }
+}
+
+struct DataTabGridEntry {
+    let model: DataGridModel
+    let adapter: DataTabGridAdapter
+    let store: QueryTabGridStateStore
+    var lastUsed: Int
+    var displayInputs: DataTabDisplayInputs?
+}
+
+// What decided a model's formatted text, which nothing invalidates while the grid is unmounted.
+struct DataTabDisplayInputs: Equatable {
+    let dateFormat: DateFormatOption
+    let nullDisplay: String
+    let smartValueDetection: Bool
+    let systemTimeZoneGeneration: Int
+    let overridesVersion: Int
+}
+
+extension MainContentCoordinator {
+    // MARK: - Models
+
+    func gridModel(forTab tabId: UUID) -> DataGridModel {
+        displayStateClock &+= 1
+        if let model = dataGridEntries[tabId]?.model {
+            dataGridEntries[tabId]?.lastUsed = displayStateClock
+            return model
+        }
+        let store = QueryTabGridStateStore(tabId: tabId, coordinator: self)
+        let configuration = tabManager.tabs.first { $0.id == tabId }.map(gridConfiguration(for:)) ?? DataGridConfiguration()
+        let model = DataGridModel(store: store, configuration: configuration, selectionSummary: selectionSummary)
+        let adapter = DataTabGridAdapter(tabId: tabId, coordinator: self)
+        adapter.attach(model)
+        model.dataSource = adapter
+        model.actions = adapter
+        dataGridEntries[tabId] = DataTabGridEntry(
+            model: model,
+            adapter: adapter,
+            store: store,
+            lastUsed: displayStateClock,
+            displayInputs: currentDisplayInputs
+        )
+        model.reloadRows()
+        return model
+    }
+
+    func existingGridModel(forTab tabId: UUID) -> DataGridModel? {
+        dataGridEntries[tabId]?.model
+    }
+
+    var selectedTabGridModel: DataGridModel? {
+        tabManager.selectedTabId.flatMap(existingGridModel(forTab:))
+    }
+
+    // The one selection source: the data tab's model in Data, JSON and Map, the Structure or Create Table grid otherwise.
+    var activeGridModel: DataGridModel? {
+        guard let tab = tabManager.selectedTab else { return nil }
+        switch GridSelectionOwner.resolve(tabType: tab.tabType, resultsViewMode: tab.display.resultsViewMode) {
+        case .dataGrid:
+            return gridModel(forTab: tab.id)
+        case .schemaGrid:
+            return activeGridModelProvider(for: tab)?.activeGridModel
+        case .none:
+            return nil
+        }
+    }
+
+    var activeDataGridModel: DataGridModel? {
+        guard let tab = tabManager.selectedTab,
+              GridSelectionOwner.resolve(tabType: tab.tabType, resultsViewMode: tab.display.resultsViewMode) == .dataGrid
+        else { return nil }
+        return gridModel(forTab: tab.id)
+    }
+
+    func activeGridModelProvider(for tab: QueryTab) -> (any ActiveGridModelProviding)? {
+        let owner: AnyObject? = tab.tabType == .createTable ? createTableDrafts[tab.id] : structureSessions[tab.id]
+        return owner as? any ActiveGridModelProviding
+    }
+
+    func releaseGridModel(forTab tabId: UUID, persistingLayout: Bool = true) {
+        guard let entry = dataGridEntries.removeValue(forKey: tabId) else { return }
+        if persistingLayout {
+            entry.store.flushPendingLayout()
+        } else {
+            entry.store.discardPendingLayout()
+        }
+        entry.model.discardEditing()
+    }
+
+    func releaseAllGridModels() {
+        for tabId in Array(dataGridEntries.keys) {
+            releaseGridModel(forTab: tabId)
+        }
+    }
+
+    func flushColumnLayoutPersistence() {
+        for entry in dataGridEntries.values {
+            entry.store.flushPendingLayout()
+        }
+    }
+
+    // MARK: - Row changes
+
+    // Every replacement of a tab's rows reaches its model, mounted or not.
+    func reloadGridModel(forTab tabId: UUID) {
+        guard let model = existingGridModel(forTab: tabId) else { return }
+        model.reloadRows()
+        consumePendingColumnJump(forTab: tabId, contentReplaced: true)
+    }
+
+    func applyGridDelta(_ delta: Delta, forTab tabId: UUID) {
+        guard let model = existingGridModel(forTab: tabId), delta != .none else { return }
+        model.apply(delta)
+        if delta == .columnsReplaced || delta == .fullReplace {
+            consumePendingColumnJump(forTab: tabId, contentReplaced: delta == .fullReplace)
+        }
+    }
+
+    // MARK: - Editing
+
+    // The tab whose edits the shared change manager holds. A switch repoints it after it starts.
+    var changeManagerTabId: UUID? {
+        tabSwitchOutgoingTabId ?? tabManager.selectedTabId
+    }
+
+    @discardableResult
+    func commitActiveGridEdit() -> Bool {
+        guard let tab = tabManager.selectedTab else { return true }
+        var committed = existingGridModel(forTab: tab.id)?.commitEditing() ?? true
+        if let schemaModel = activeGridModelProvider(for: tab)?.activeGridModel {
+            committed = schemaModel.commitEditing() && committed
+        }
+        return committed
+    }
+
+    var isEditingActiveGrid: Bool {
+        guard let tab = tabManager.selectedTab else { return false }
+        return existingGridModel(forTab: tab.id)?.isEditing == true
+            || activeGridModelProvider(for: tab)?.activeGridModel?.isEditing == true
+    }
+
+    func observeChangeManagerForGridRepaint() -> AnyCancellable {
+        changeManager.$reloadVersion
+            .removeDuplicates()
+            .dropFirst()
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in self?.selectedTabGridModel?.repaintAllRows() }
+    }
+
+    // MARK: - Sort
+
+    func requestSort(_ sort: SortState, forTab tabId: UUID) {
+        guard tabManager.selectedTabId == tabId else { return }
+        handleSortStateChanged(sort)
+    }
+
+    // MARK: - Configuration
+
+    func gridConfiguration(for tab: QueryTab) -> DataGridConfiguration {
+        let isSelected = tab.id == tabManager.selectedTabId
+        let isEditable = isSelected && canEditActiveResult
+        var configuration = DataGridConfiguration()
+        configuration.primaryKeyColumns = tab.tableContext.primaryKeyColumns
+        configuration.showRowNumbers = AppSettingsManager.shared.dataGrid.showRowNumbers
+        configuration.appliesRowSortPreferences = true
+        configuration.appliesRowCopyFormat = true
+        configuration.supportsColumnSort = tab.tabType != .table || supportsColumnSort
+        configuration.isEditable = isEditable
+        configuration.editRefusalMessage = isSelected ? activeResultEditRefusal?.message : nil
+        configuration.traits = DataGridEngineTraits(
+            databaseType: connection.type,
+            immutableColumns: Set(services.pluginManager.immutableColumns(for: connection.type)),
+            usesTrueFalseBooleans: services.pluginManager.usesTrueFalseBooleans(for: connection.type),
+            stringLiteralPrefix: SQLStringLiteralPrefix.forDatabaseType(connection.type),
+            cellWriterSupport: changeManager.cellWriterSupport,
+            supportsFieldRemoval: changeManager.supportsFieldRemoval,
+            connectionScope: scope(for: tab)
+        )
+        configuration.commands = gridCommands(for: tab, isSelected: isSelected, isEditable: isEditable)
+        return configuration
+    }
+
+    private func gridCommands(for tab: QueryTab, isSelected: Bool, isEditable: Bool) -> Set<DataGridCommand> {
+        var commands: Set<DataGridCommand> = [
+            .hideColumns, .showRowsAsJSON, .exportResults, .navigateForeignKey,
+            .highlightValues, .displayAs, .freezeColumns, .valueFilter
+        ]
+        if isEditable {
+            commands.formUnion([.addRow, .deleteRows, .undoDelete])
+            // A duplicate copies values the result set alone cannot vouch for until the schema arrives.
+            if tabSessionRegistry.existingTableRows(for: tab.id)?.hasAuthoritativeSchema == true {
+                commands.insert(.duplicateRows)
+            }
+            if tab.tabType == .table { commands.insert(.pasteRows) }
+        }
+        if isSelected, canFilterRows { commands.insert(.filterWithColumn) }
+        if tab.tableContext.tableName != nil { commands.insert(.copyAsSQL) }
+        if tab.tabType == .table, !tab.tableContext.primaryKeyColumns.isEmpty { commands.insert(.loadUnloadedValues) }
+        if findCoordinator.offersSearchAllRows(forTab: tab.id) { commands.insert(.searchAllRows) }
+        if isSelected, canClearActiveQueryResults { commands.insert(.clearResults) }
+        return commands
+    }
+
+    // MARK: - Display caches
+
+    var currentDisplayInputs: DataTabDisplayInputs {
+        let settings = AppSettingsManager.shared.dataGrid
+        return DataTabDisplayInputs(
+            dateFormat: settings.dateFormat,
+            nullDisplay: settings.nullDisplay,
+            smartValueDetection: settings.enableSmartValueDetection,
+            systemTimeZoneGeneration: DateFormattingService.shared.systemTimeZoneGeneration,
+            overridesVersion: ValueDisplayFormatService.shared.overridesVersion
+        )
+    }
+
+    // Formatted text kept by an unmounted model goes stale when the settings it was formatted with move.
+    func prepareGridModelForDisplay(forTab tabId: UUID) {
+        let inputs = currentDisplayInputs
+        guard let entry = dataGridEntries[tabId], entry.displayInputs != inputs else { return }
+        entry.model.display.cache.removeAll()
+        dataGridEntries[tabId]?.displayInputs = inputs
+    }
+
+    // Each model holds a whole result's formatted text, so only the tabs in use keep theirs.
+    func pruneGridDisplayCaches() {
+        let budget = MemoryPressureAdvisor.budgetForInactiveTabs() + 1
+        guard dataGridEntries.count > budget else { return }
+        let ordered = dataGridEntries.sorted { $0.value.lastUsed > $1.value.lastUsed }
+        for (tabId, entry) in ordered.dropFirst(budget) where !entry.model.isMounted {
+            entry.model.display.cache.removeAll()
+            dataGridEntries[tabId]?.displayInputs = nil
+        }
+    }
+}
+
+extension DataGridModel {
+    var displayedRowIDs: [RowID]? {
+        order.filteredIDs
+    }
+}
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridViewport.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridViewport.swift
index 4b09e7f7ca..fffc3eb546 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridViewport.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+GridViewport.swift
@@ -6,10 +6,6 @@
 import Foundation
 
 extension MainContentCoordinator {
-    func takeViewportPlacement(forTab tabId: UUID) -> GridViewportPlacement? {
-        tabSessionRegistry.takeViewportPlacement(for: tabId)
-    }
-
     func restoredRowAnchor(forTab tabId: UUID) -> [String: String]? {
         tabManager.tabs.first(where: { $0.id == tabId })?.restoredRowAnchor
     }
@@ -19,14 +15,13 @@ extension MainContentCoordinator {
         tabManager.mutate(tabId: tabId) { $0.restoredRowAnchor = nil }
     }
 
-    /// A query tab's grid stays where AppKit leaves it after a run; only a re-read of its own result
-    /// asks to keep the place and the selection.
+    // A query tab's grid stays where AppKit leaves it after a run; only a re-read of its own result keeps place and selection.
     func isGridMounted(forTab tabId: UUID, acceptsQueryTab: Bool = false) -> Bool {
         guard tabManager.selectedTabId == tabId,
               let tab = tabManager.selectedTab,
               tab.tabType == .table || (acceptsQueryTab && tab.tabType == .query),
               tab.display.resultsViewMode == .data else { return false }
-        return dataTabDelegate?.tableViewCoordinator != nil
+        return existingGridModel(forTab: tabId)?.isMounted == true
     }
 
     func viewportKeyColumns(forTab tabId: UUID) -> [String] {
@@ -42,15 +37,16 @@ extension MainContentCoordinator {
         guard intent == .keepPlace || keepsSelection,
               let tableRows = tabSessionRegistry.existingTableRows(for: tabId),
               !tableRows.rows.isEmpty else { return .top }
-        let sample = intent == .keepPlace ? dataTabDelegate?.tableViewCoordinator?.viewportSample() : nil
+        let model = existingGridModel(forTab: tabId)
+        let sample = intent == .keepPlace ? viewportSample(of: model) : nil
         guard sample != nil || keepsSelection else { return .top }
 
         let snapshot = GridViewportResolver.snapshot(
             of: tableRows,
-            displayIDs: displayIDs(forTab: tabId),
-            firstVisibleDisplayRow: sample?.firstVisibleRow ?? 0,
+            displayIDs: model?.displayedRowIDs,
+            firstVisibleDisplayRow: sample?.row ?? 0,
             firstVisibleOffset: sample?.offset ?? 0,
-            selectedDisplayRows: keepsSelection ? Array(selectionState.indices) : [],
+            selectedDisplayRows: keepsSelection ? Array(model?.selection.affectedRows ?? IndexSet()) : [],
             keyColumns: keyColumns,
             isCellModified: { [changeManager] rowID, column in
                 changeManager.isCellModified(rowID: rowID, columnIndex: column)
@@ -58,4 +54,14 @@ extension MainContentCoordinator {
         )
         return sample == nil ? snapshot.selectionOnly : snapshot
     }
+
+    // The mounted grid's first visible row, else the anchor the grid saved when it was last unmounted.
+    private func viewportSample(of model: DataGridModel?) -> (row: Int, offset: CGFloat)? {
+        guard let model else { return nil }
+        if let live = model.viewportSample() { return live }
+        guard let anchor = model.store.viewportAnchor,
+              let rowID = anchor.firstVisibleRow,
+              let row = model.displayIndex(of: rowID) else { return nil }
+        return (row, anchor.firstVisibleOffset)
+    }
 }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+NavigationHistory.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+NavigationHistory.swift
index d4cb4e7845..bd00b048c8 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+NavigationHistory.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+NavigationHistory.swift
@@ -13,13 +13,7 @@ private let navigationHistoryLogger = Logger(subsystem: "com.TablePro", category
 extension MainContentCoordinator {
     // MARK: - Availability
 
-    /// Back is refused once the tab is showing something other than a table, because stepping back
-    /// would have nothing to put on the forward stack in its place.
-    ///
-    /// Unsaved cell edits do NOT refuse it. Going back does replace the tab's content and would
-    /// take them with it, but that is what the discard alert is for, and `step(back:)` routes
-    /// through the same one refresh, sort, pagination and filter already use. Refusing instead left
-    /// Back dim over a destination that still existed, with nothing saying why.
+    // Unsaved cell edits do not refuse Back: `step(back:)` goes through the discard alert; refusing left Back dim with no reason.
     var canNavigateBack: Bool {
         guard let tabId = navigableTabId else { return false }
         return navigationHistories[tabId]?.canGoBack ?? false
@@ -37,12 +31,7 @@ extension MainContentCoordinator {
         return tab.id
     }
 
-    /// The half of `selectedTabHoldsProtectedContent` navigation cannot offer to discard.
-    ///
-    /// Staged structure edits are the only one that survives the `tabType == .table` requirement
-    /// alongside cell edits: `holdsQueryWork` is false off a query tab and the `.createTable` arm
-    /// cannot be reached. They stay a refusal because the discard alert clears `changeManager` and
-    /// nothing else, so offering to discard them would be a promise this path cannot keep.
+    // Staged structure edits block: the discard alert clears only `changeManager`, so offering to discard them is a broken promise.
     private var selectedTabBlocksNavigation: Bool {
         guard let tab = tabManager.selectedTab else { return true }
         return hasStagedStructureEdits(in: tab)
@@ -50,11 +39,7 @@ extension MainContentCoordinator {
 
     // MARK: - Recording
 
-    /// What the selected tab is showing right now, or nil when it is not showing a table.
-    ///
-    /// Capturing and recording are two calls rather than one because a retarget can fail. Recording
-    /// what a tab was showing when it never left would push a duplicate onto Back and, worse, drop
-    /// the whole forward stack for a navigation that did not happen.
+    // Capture and commit are separate because a retarget can fail; recording a non-move dupes Back and drops the forward stack.
     func captureNavigationEntry() -> TabNavigationEntry? {
         guard let tab = tabManager.selectedTab,
               tab.tabType == .table,
@@ -78,31 +63,21 @@ extension MainContentCoordinator {
         )
     }
 
-    /// Records a location the selected tab has now left, once the retarget that left it succeeded.
-    ///
-    /// Every navigation that retargets a tab in place calls this, because those are the only ones
-    /// that overwrite a view the reader has no other route back to. A jump that opens its own tab
-    /// records nothing: the tab it came from is still open, and the new tab starts with an empty
-    /// history, the way Command-clicking a link does.
+    // Only in-place retargets record; a jump that opens its own tab leaves the source open and starts with an empty history.
     func commitNavigationEntry(_ entry: TabNavigationEntry?) {
         guard let entry, let tabId = tabManager.selectedTabId else { return }
         navigationHistories[tabId, default: TabNavigationHistory()].record(entry)
     }
 
-    /// The primary-key values of the row the reader is on, so returning lands on that row rather
-    /// than at the top of the page.
-    ///
-    /// The selected index is a display position, so it is resolved to a row through the grid's own
-    /// mapping before anything is read off it: a per-column value filter makes display order and
-    /// storage order diverge, and indexing the buffer directly would read a different row (#1837).
+    // The key of the row the reader is on, so returning lands on that row rather than at the top (#1837).
     private func capturePrimaryKeyAnchor(for tab: QueryTab) -> [String: String]? {
         let keyColumns = tab.tableContext.primaryKeyColumns
         guard !keyColumns.isEmpty,
-              let gridCoordinator = dataTabDelegate?.tableViewCoordinator,
-              let displayIndex = selectionState.indices.min() else { return nil }
+              let model = existingGridModel(forTab: tab.id),
+              let displayIndex = model.selection.affectedRows.first,
+              let row = model.row(at: displayIndex) else { return nil }
 
-        let tableRows = tabSessionRegistry.tableRows(for: tab.id)
-        guard let row = gridCoordinator.displayRow(at: displayIndex, in: tableRows) else { return nil }
+        let tableRows = model.rows
 
         return NavigationRowAnchor.build(
             keyColumns: keyColumns,
@@ -124,13 +99,7 @@ extension MainContentCoordinator {
         step(back: false)
     }
 
-    /// Asks before it discards, through the alert the other reload paths use. With nothing staged
-    /// the guard completes synchronously with `true`, so an ordinary step never defers a turn.
-    ///
-    /// The departing entry is captured *before* the guard on purpose. Discarding clears the change
-    /// records but leaves the edited values in `TableRows`, so a capture afterwards cannot tell a
-    /// staged key from a saved one and would anchor the forward stack on a value the user just
-    /// threw away.
+    // Captures before the discard guard: discarding keeps edited values in `TableRows`, so a later capture anchors on dropped keys.
     private func step(back: Bool) {
         let departing = captureNavigationEntry()
         confirmDiscardChangesIfNeeded(action: .navigation) { [weak self] confirmed in
@@ -139,11 +108,7 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Moves one entry and puts it back on the tab, or leaves the history exactly as it was.
-    ///
-    /// The stacks are mutated on a copy and only written back once the restore has actually landed.
-    /// Moving them first would strand the reader if the retarget failed: the entry they asked for
-    /// would be gone and Forward would point at the view they are still looking at.
+    // Stacks change on a copy, written back only once the restore lands, so a failed retarget leaves the history untouched.
     private func commitStep(back: Bool, from departing: TabNavigationEntry?) {
         guard let tabId = navigableTabId,
               var history = navigationHistories[tabId],
@@ -160,12 +125,7 @@ extension MainContentCoordinator {
         navigationHistoryLogger.debug("navigated to \(entry.tableName, privacy: .public)")
     }
 
-    /// Puts a recorded location back on the selected tab.
-    ///
-    /// The sequence is `reuseActiveTab`'s, so a restore and an ordinary retarget reach the grid the
-    /// same way. The difference is the state written between the retarget and the load: the
-    /// recorded filters instead of the table's saved defaults, and the recorded sort and page
-    /// through the pending fields the first load already knows how to consume.
+    // Follows `reuseActiveTab`'s sequence, but loads the recorded filters, sort and page instead of the table's saved defaults.
     private func restore(_ entry: TabNavigationEntry, in tabId: UUID) -> Bool {
         do {
             try tabManager.replaceTabContent(
@@ -187,9 +147,7 @@ extension MainContentCoordinator {
         discardRowsForRetarget(resultsViewMode: entry.resultsViewMode)
         guard let (tab, tabIndex) = tabManager.selectedTabAndIndex, tab.id == tabId else { return false }
 
-        /// The page is always carried, not only when it is past the first. `replaceTabContent`
-        /// resets pagination to the app's default page size, so a view recorded on page one of a
-        /// 500-row page would otherwise come back in pages of a different size.
+        // Always carry the page: `replaceTabContent` resets to the default page size, so a recorded page would come back resized.
         tabManager.mutate(at: tabIndex) { tab in
             tab.filterState = entry.filterState
             tab.pendingRestoredSort = entry.sortColumns.isEmpty ? nil : entry.sortColumns
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift
index d66e15145f..244e8e2069 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift
@@ -72,7 +72,7 @@ extension MainContentCoordinator {
               tab.tabType == .table,
               tab.display.resultsViewMode != .structure else { return }
 
-        dataTabDelegate?.tableViewCoordinator?.commitActiveCellEdit()
+        commitActiveGridEdit()
         guard changeManager.hasChanges || hasPendingTableOps else {
             reloadTableTab(at: tabIndex)
             return
@@ -92,10 +92,7 @@ extension MainContentCoordinator {
 
     func reloadTableTab(at tabIndex: Int) {
         stopExecution(for: tabManager.tabs[tabIndex].id)
-        /// A refresh asks for the table as it is now, so the exact count the user requested earlier
-        /// describes a table that may have moved on. Retiring it here is what lets the automatic
-        /// count re-derive a total, which it otherwise refuses to do rather than downgrade an exact
-        /// count to an estimate.
+        // A refresh retires the earlier exact count, else the automatic count refuses to re-derive rather than downgrade it to an estimate.
         tabManager.mutate(at: tabIndex) { $0.pagination.retireDerivedRowCount() }
         rebuildTableQuery(at: tabIndex)
         runQuery(viewport: .keepPlace)
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+RowOperations.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+RowOperations.swift
index 2f1adc30d5..d5359844b6 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+RowOperations.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+RowOperations.swift
@@ -7,19 +7,13 @@ import Foundation
 import TableProPluginKit
 
 extension MainContentCoordinator {
-    /// Whether the selected tab can take a new row.
-    ///
-    /// One definition, because the answer drives two controls: the toolbar item that inserts the row
-    /// and the **Add Row** item on the data grid's empty-space menu.
+    // One definition for both the toolbar item and the data grid's empty-space Add Row item.
     var canAddRow: Bool {
         guard canEditActiveResult, let tab = tabManager.selectedTab else { return false }
         guard tab.tableContext.tableName != nil else { return false }
-        /// Only the data grid takes a row. `addNewRow()` resolves its target through
-        /// `GridSelectionOwner`, which answers `.none` in Chart mode and `.schemaGrid` in Structure
-        /// mode, so without this the command is either inert or adds a column under a row's name.
+        // `GridSelectionOwner` answers `.none` in Chart and `.schemaGrid` in Structure, so elsewhere Add Row is inert or adds a column.
         guard tab.display.resultsViewMode == .data else { return false }
-        /// A new row is pre-filled from the schema's account of which columns the server fills in,
-        /// so the command waits for that account rather than staging NULL into an identity column.
+        // A new row pre-fills server-filled columns from the schema, so wait for it rather than stage NULL into an identity column.
         return tabSessionRegistry.tableRows(for: tab.id).hasAuthoritativeSchema
     }
 
@@ -27,12 +21,16 @@ extension MainContentCoordinator {
         rowEditingCoordinator.addNewRow()
     }
 
-    func deleteSelectedRows(indices: Set<Int>) {
-        rowEditingCoordinator.deleteSelectedRows(indices: indices)
+    func deleteRows(_ rowIDs: [RowID]) {
+        rowEditingCoordinator.deleteRows(rowIDs)
     }
 
-    func duplicateSelectedRow(index: Int) {
-        rowEditingCoordinator.duplicateSelectedRow(index: index)
+    func undoRowDeletions(_ rowIDs: [RowID]) {
+        rowEditingCoordinator.undoRowDeletions(rowIDs)
+    }
+
+    func duplicateRow(_ rowID: RowID) {
+        rowEditingCoordinator.duplicateRow(rowID)
     }
 
     func handleUndoResult(_ result: UndoResult) {
@@ -71,27 +69,15 @@ extension MainContentCoordinator {
         rowEditingCoordinator.stageInspectorFieldRemoval(columnIndex: columnIndex, rowIDs: rowIDs)
     }
 
-    func copySelectedRowsToClipboard(indices: Set<Int>) {
-        rowEditingCoordinator.copySelectedRowsToClipboard(indices: indices)
-    }
-
-    func copySelectedRowsWithHeaders(indices: Set<Int>) {
-        rowEditingCoordinator.copySelectedRowsWithHeaders(indices: indices)
+    func copyRowsToClipboard(_ rowIDs: [RowID], includeHeaders: Bool = false) {
+        rowEditingCoordinator.copyRowsToClipboard(rowIDs, includeHeaders: includeHeaders)
     }
 
-    func copySelectedRowsAsJson(indices: Set<Int>) {
-        rowEditingCoordinator.copySelectedRowsAsJson(indices: indices)
+    func copyRowsAsJson(_ rowIDs: [RowID]) {
+        rowEditingCoordinator.copyRowsAsJson(rowIDs)
     }
 
     func pasteRows() {
         rowEditingCoordinator.pasteRows()
     }
-
-    func updateCellInTab(rowIndex: Int, columnIndex: Int, value: String?) {
-        rowEditingCoordinator.updateCellInTab(
-            rowIndex: rowIndex,
-            columnIndex: columnIndex,
-            value: PluginCellValue.fromOptional(value)
-        )
-    }
 }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+SidebarSave.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+SidebarSave.swift
index d78df27930..38e1b2bfe9 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+SidebarSave.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+SidebarSave.swift
@@ -28,32 +28,23 @@ extension MainContentCoordinator {
         return try changeManager.generateSQL(for: changes)
     }
 
-    // Each row keeps which fields it has none of, so a removal is written as one and a value typed into a missing
-    // field is compared against a field that is not there.
+    // Each row keeps its missing fields, so a removal writes as one and a typed value compares against an absent field.
     private func sidebarEditChanges(editedFields: [InspectorFieldEdit]) -> [RowChange] {
         guard let tab = tabManager.selectedTab,
-            !selectionState.indices.isEmpty,
             tab.tableContext.tableName != nil,
-            GridSelectionOwner.resolve(
-                tabType: tab.tabType,
-                resultsViewMode: tab.display.resultsViewMode
-            ) == .dataGrid
+            let model = activeDataGridModel,
+            !model.selection.isEmpty
         else {
             return []
         }
 
         guard !editedFields.isEmpty else { return [] }
 
-        let tableRows = tabSessionRegistry.tableRows(for: tab.id)
+        let tableRows = model.rows
         let writes = editedFields.compactMap { sidebarWrite(for: $0, in: tableRows) }
         guard !writes.isEmpty else { return [] }
-        let displayIDs = activeGridDisplayIDs
-        return selectionState.indices.sorted().compactMap { rowIndex -> RowChange? in
-            guard let resolvedRow = DisplayRowMapping.row(
-                forDisplay: rowIndex,
-                displayIDs: displayIDs,
-                in: tableRows
-            ) else { return nil }
+        return model.selection.affectedRows.compactMap { displayRow -> RowChange? in
+            guard let resolvedRow = model.row(at: displayRow) else { return nil }
             let originalRow = Array(resolvedRow.values)
             return RowChange(
                 rowID: resolvedRow.id,
@@ -79,9 +70,7 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Typed text is read for its column, as the grid reads a cell: a function name on a date column is the
-    /// function, and text a NOT NULL column can hold neither as itself nor as NULL writes nothing. An explicit
-    /// NULL stays NULL, and SQL picked from the menu is already the vocabulary's spelling.
+    // Typed text is read for its column as the grid reads a cell (a date function stays a function); explicit NULL stays NULL.
     private func sidebarWrite(
         for field: InspectorFieldEdit,
         in tableRows: TableRows
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabClosing.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabClosing.swift
index c09b02ff6c..49fd8a17f4 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabClosing.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabClosing.swift
@@ -6,24 +6,12 @@
 import Foundation
 
 extension MainContentCoordinator {
-    /// The path that means "the user closed these tabs themselves", which, with moving the last tab
-    /// to another connection, is the consent `clearForUserClosedAllTabs` requires. Every automatic
-    /// path leaves the saved state alone, because an empty tab list can equally mean a session was
-    /// lost or the app is quitting, and treating that as a delete throws away tabs nobody closed.
-    ///
-    /// Closing tabs never closes the window: the window hosts every open connection now, so the
-    /// connection is simply left on its empty state.
-    ///
-    /// Consent to close is not consent to lose work. Callers that can reach a tab holding unsaved
-    /// work ask first, through `MainContentCommandActions.closeTabAwaiting(id:)`.
+    // User-initiated, the consent `clearForUserClosedAllTabs` needs; automatic paths never clear saved tabs.
     func closeTabsByUser(ids: [UUID]) {
-        dataTabDelegate?.tableViewCoordinator?.flushPendingColumnLayoutPersistence()
+        flushColumnLayoutPersistence()
         for id in ids {
             guard let tab = tabManager.tabs.first(where: { $0.id == id }) else { continue }
-            /// The closing tab's own save point. A tab switch saves the tab it leaves, but a close
-            /// removes the tab before the selection moves, so nothing else writes the rows the
-            /// reader left in the filter bar. An applied filter was written when it was applied;
-            /// rows that were never applied have only this.
+            // A close removes the tab before the selection moves, so this is the only save of filter rows never applied.
             saveLastFilters(of: tab)
             RecentlyClosedTabStore.shared.push(tab: tab, connection: connection)
             releaseResources(of: tab)
@@ -34,18 +22,16 @@ extension MainContentCoordinator {
         persistence.clearForUserClosedAllTabs()
     }
 
-    /// Not a close: the tab is not going away, so nothing goes to Reopen Closed Tab. The source view is
-    /// usually unparented by now, so its structure-change save will not fire and this save is the only one.
+    // Not a close, so nothing goes to Reopen Closed Tab; the unparented source view will not save, so this is the only save.
     internal func takeTabForMove(id: UUID) -> QueryTab? {
         guard canMoveTabToConnection(id),
               let tab = tabManager.tabs.first(where: { $0.id == id }) else { return nil }
         let moved = enrichedForPersistence(tab)
-        /// The live caret is the moved tab's. Closing selects a neighbour without its editor mounting,
-        /// so the save below would otherwise write that caret into the neighbour.
+        // The live caret is the moved tab's: closing selects a neighbour without mounting its editor, so the save would write it there.
         if tabManager.selectedTabId == id {
             cursorPositions = []
         }
-        dataTabDelegate?.tableViewCoordinator?.flushPendingColumnLayoutPersistence()
+        flushColumnLayoutPersistence()
         releaseResources(of: tab)
         releaseExecution(of: tab)
         tabSessionRegistry.unregister(id: id)
@@ -53,29 +39,18 @@ extension MainContentCoordinator {
         cleanupTabCaches(openTabIds: Set(tabManager.tabs.map(\.id)))
         services.schemaProviderRegistry.reclaimUnheldProviders(for: connectionId)
         persistence.saveAggregated()
-        /// Moving the last tab out is the user emptying this connection, the same consent closing it
-        /// gives. Left on disk, the tab would come back here on the next restore as a duplicate.
+        // Moving the last tab out empties the connection like closing it; left on disk, the tab would restore here as a duplicate.
         if Self.aggregatedTabs(for: connectionId).isEmpty {
             persistence.clearForUserClosedAllTabs()
         }
         return moved
     }
 
-    /// The object these tabs show is gone, which is not the user closing them. Nothing goes to Reopen
-    /// Closed Tab, which could only reopen onto an error, and the saved tab set is never cleared,
-    /// because an emptied tab list is not consent to forget it.
+    // Not a user close: nothing goes to Reopen Closed Tab (it would reopen onto an error) and the saved tab set is kept.
     func closeTabsForRemovedObjects(ids: [UUID]) {
-        /// Discarded rather than flushed, which is what the user-close path does. The object is
-        /// gone and the adoption has already cleared its saved settings, so a write from the
-        /// teardown would put the layout back after the clear.
-        ///
-        /// Only when the closed tabs include the selected one, because that is the only tab with a
-        /// mounted grid: a pending width belongs to it, and dropping an unrelated table would
-        /// otherwise throw away a resize the reader had just made somewhere else.
-        if let selectedId = tabManager.selectedTabId, ids.contains(selectedId) {
-            dataTabDelegate?.tableViewCoordinator?.discardPendingColumnLayoutPersistence()
-        }
         for id in ids {
+            // Discarded, not flushed: the object is gone and its saved layout was cleared, so a write would put it back.
+            releaseGridModel(forTab: id, persistingLayout: false)
             guard let tab = tabManager.tabs.first(where: { $0.id == id }) else { continue }
             releaseResources(of: tab)
             releaseExecution(of: tab)
@@ -84,13 +59,12 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Drops the per-tab caches of tabs that are no longer open. Every one of these is keyed by
-    /// tab id, so a stale entry does not merely waste memory: the next tab to be handed that id
-    /// would read another tab's state.
+    // All keyed by tab id, so a stale entry would hand another tab's state to the next tab given that id.
     func cleanupTabCaches(openTabIds: Set<UUID>) {
         prune(&displayFormatsCache, keeping: openTabIds)
-        prune(&displayOrderCache, keeping: openTabIds)
-        prune(&displayStateCache, keeping: openTabIds)
+        for tabId in Array(dataGridEntries.keys) where !openTabIds.contains(tabId) {
+            releaseGridModel(forTab: tabId)
+        }
         prune(&tableMetadataCache, keeping: openTabIds)
         prune(&createTableDrafts, keeping: openTabIds)
         prune(&userTypeEditors, keeping: openTabIds)
@@ -103,21 +77,14 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Rewrites the dictionary only when something has actually gone, because assigning a filtered
-    /// copy back is what a plain `filter` would cost on every tab change.
+    // Rewrites only when something went, so a tab change does not pay for a filtered copy every time.
     private func prune<Value>(_ cache: inout [UUID: Value], keeping openTabIds: Set<UUID>) {
         guard cache.keys.contains(where: { !openTabIds.contains($0) }) else { return }
         cache = cache.filter { openTabIds.contains($0.key) }
     }
 
-    /// A retarget keeps the tab's id and throws away everything the id used to mean, so the
-    /// per-tab caches keyed on that id now describe a table the tab no longer shows. Left behind,
-    /// the structure session goes on reporting staged ALTERs, which raises an unsaved-changes prompt
-    /// naming the previous table and offers to apply its statements from a tab that cannot show
-    /// them. `selectedTabHoldsProtectedContent` is what stops a tab holding real work being
-    /// retargeted at all; this is what keeps the caches honest once one without work has been.
+    // A retarget keeps the id, so stale caches (staged ALTERs) would prompt to apply the previous table's changes.
     func releaseRetargetedTabState(for tabId: UUID) {
-        displayStateCache.removeValue(forKey: tabId)
         tableMetadataCache.removeValue(forKey: tabId)
         tabSessionRegistry.forgetFreshness(for: tabId)
         structureSessions.removeValue(forKey: tabId)?.releaseViewWiring()
@@ -130,15 +97,7 @@ extension MainContentCoordinator {
         toolbarState.hasTypeChanges = false
     }
 
-    /// A closed tab has to take its coordinator-side state with it, and this is the only place that
-    /// can: `handleTabChange` snapshots a tab by looking it up in `tabManager.tabs`, and by the time
-    /// it runs the tab is already gone. So it must happen before `tabManager.closeTab(id:)`, which
-    /// is also what makes the selected-tab test meaningful, since that call reassigns the selection.
-    ///
-    /// Left behind, the change manager keeps the closed tab's edits and the table name they were
-    /// written against. Nothing clears it, so the connection goes on reporting unsaved work with no
-    /// tabs to show for it, and the next Save resolves its scope through `browseScope` and runs
-    /// those statements against whatever database the sidebar has since moved to.
+    // Before `closeTab(id:)`, which hides the tab from `handleTabChange`; stale edits would later save to the wrong database.
     private func releaseResources(of tab: QueryTab) {
         tabsWithStagedPrincipals.remove(tab.id)
         structureSessions.removeValue(forKey: tab.id)?.releaseViewWiring()
@@ -146,7 +105,7 @@ extension MainContentCoordinator {
         userTypeEditors.removeValue(forKey: tab.id)
         erDiagramModels.removeValue(forKey: tab.id)
         navigationHistories.removeValue(forKey: tab.id)
-        displayStateCache.removeValue(forKey: tab.id)
+        releaseGridModel(forTab: tab.id)
         tableMetadataCache.removeValue(forKey: tab.id)
         guard isSelectedTab(tab) else { return }
         changeManager.clearChangesAndUndoHistory()
@@ -156,15 +115,7 @@ extension MainContentCoordinator {
         toolbarState.hasTypeChanges = false
     }
 
-    /// Ends what the tab was running, on the same terms a retarget does.
-    ///
-    /// A closed tab used to keep its claim in the registry, so the window went on reporting the
-    /// work as running until the query it could no longer show came back. Reopen Closed Tab hands
-    /// the restored tab the id it had before, which is enough for the orphan to be mistaken for the
-    /// reopened tab's own load and for that load to be refused as a duplicate.
-    ///
-    /// The query handle is this tab's own, so it goes down with the tab. No ownership check is
-    /// needed any more: a handle keyed by tab cannot belong to another one.
+    // A closed tab kept its registry claim, so a reopened tab with the same id had its load refused as a duplicate.
     internal func releaseExecution(of tab: QueryTab) {
         reportEndedExecutions(tabExecution.invalidate(tab.id, reason: .abandoned).map { [$0] } ?? [])
         cancelTableLoad(for: tab.id)
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabStatePersistence.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabStatePersistence.swift
index ff047a7377..87e404a2e9 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabStatePersistence.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabStatePersistence.swift
@@ -5,15 +5,14 @@
 
 import Foundation
 
-/// The view-layer half of `SessionTabStatePersisting`. One coordinator is enough to ask, because
-/// `saveAggregatedSync()` collects the tabs of every window on the connection, not just its own.
+// One coordinator is enough to ask: saveAggregatedSync() collects the tabs of every window on the connection.
 @MainActor
 internal final class SessionTabStatePersister: SessionTabStatePersisting {
     internal func persistTabState(for connectionId: UUID) {
         let coordinators = MainContentCoordinator.allActiveCoordinators()
             .filter { $0.connectionId == connectionId }
         for coordinator in coordinators {
-            coordinator.dataTabDelegate?.tableViewCoordinator?.flushPendingColumnLayoutPersistence()
+            coordinator.flushColumnLayoutPersistence()
         }
         coordinators.first?.persistence.saveAggregatedSync()
     }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabSwitch.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabSwitch.swift
index 06fb49c1e6..d89a25e631 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabSwitch.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TabSwitch.swift
@@ -26,7 +26,13 @@ extension MainContentCoordinator {
             "[switch] handleTabChange start from=\(oldTabId?.uuidString ?? "nil", privacy: .public) to=\(newTabId?.uuidString ?? "nil", privacy: .public) connId=\(self.connectionId, privacy: .public) tabsCount=\(self.tabManager.tabs.count)"
         )
         isHandlingTabSwitch = true
+        // The change manager holds the outgoing tab's edits until the restore below, so an open cell editor commits there (H2).
+        tabSwitchOutgoingTabId = oldTabId
+        if let oldTabId {
+            commitGridEdit(ofTab: oldTabId)
+        }
         defer {
+            tabSwitchOutgoingTabId = nil
             isHandlingTabSwitch = false
             Self.lifecycleLogger.debug(
                 "[switch] handleTabChange done to=\(newTabId?.uuidString ?? "nil", privacy: .public) elapsedMs=\(Int(Date().timeIntervalSince(start) * 1_000))"
@@ -37,32 +43,12 @@ extension MainContentCoordinator {
         if let oldId = oldTabId,
            let oldIndex = tabManager.tabs.firstIndex(where: { $0.id == oldId })
         {
-            /// The second half of the condition is the fix. Gated on `hasChanges` alone, an undo was
-            /// never recorded: the tab kept the snapshot a previous switch had saved, so switching
-            /// back restored the edit the reader had just taken back and the tab went on reporting
-            /// unsaved work. Writing the empty snapshot is what clears it.
-            ///
-            /// Still conditional, because `mutate` takes the element `inout` and so runs the array's
-            /// setter whether or not the block writes: an unconditional write would fire `tabs`'
-            /// `didSet` over every open tab on every switch, for nothing.
-            ///
-            /// Safe to take the snapshot from the change manager here because nothing has repointed
-            /// it yet: every other `configureForTable` and `restoreState` caller is either the
-            /// incoming block below or guarded to the selected tab, and this runs synchronously
-            /// from the selection change with no suspension in between.
+            // Also checks the tab's snapshot: on `hasChanges` alone an undo kept a stale snapshot that restored the undone edit on return.
             if changeManager.hasChanges || tabManager.tabs[oldIndex].pendingChanges.hasChanges {
                 let savedState = changeManager.saveState()
                 tabManager.mutate(at: oldIndex) { $0.pendingChanges = savedState }
             }
-            // One editor serves every query tab, so `cursorPositions` describes the outgoing tab
-            // only until the switch completes. Persistence writes the live caret for the selected
-            // tab alone, so a caret not captured here is gone once the editor has consumed the
-            // tab's restored value.
-            //
-            // Only a tab whose own restored caret is already consumed can be written, because the
-            // query editor subtree has no `.id(tab.id)`: selecting a restored tab reuses the same
-            // editor without re-installing it, so `cursorPositions` can still describe the tab
-            // before it. Overwriting there would destroy the very caret this is meant to keep.
+            // One editor serves every query tab with no `.id(tab.id)`, so write only once this tab's restored caret has been consumed.
             let outgoing = tabManager.tabs[oldIndex]
             if outgoing.tabType == .query,
                outgoing.restoredCursorOffset == nil,
@@ -73,23 +59,16 @@ extension MainContentCoordinator {
                     $0.restoredCursorLength = range.length
                 }
             }
-            /// Before the restore below repoints `selectionState` at the incoming tab. The outgoing
-            /// grid is still mounted and still bound to that shared channel, so the repoint clears
-            /// its table view and its own teardown then has nothing left to report. (#2667)
-            if let live = mountedGridSelection() {
-                storeGridSelection(rows: live.rows, cells: live.cells, forTab: oldId)
-            }
             filterCoordinator.saveLastFilters(of: tabManager.tabs[oldIndex])
         }
         let saveMs = Int(Date().timeIntervalSince(saveStart) * 1_000)
 
-        // Defer to the next run-loop tick so the synchronous switch path
-        // stays cheap; the sort + budget calculation is non-trivial on
-        // connections with many open tabs.
+        // Deferred a tick: the sort and budget calculation is costly with many open tabs.
         if tabManager.tabs.count > 2 {
             let activeIds: Set<UUID> = Set([oldTabId, newTabId].compactMap { $0 })
             Task { @MainActor [weak self] in
                 self?.evictInactiveTabs(excluding: activeIds)
+                self?.pruneGridDisplayCaches()
             }
         }
 
@@ -99,14 +78,11 @@ extension MainContentCoordinator {
             let newTab = tabManager.tabs[newIndex]
             let newRows = tabSessionRegistry.tableRows(for: newId)
 
-            selectionState.indices = newTab.selectedDisplayRows
             toolbarState.isTableTab = newTab.tabType == .table
             toolbarState.isResultsCollapsed = newTab.display.isResultsCollapsed
             syncQueryToolbarState(for: newTab)
 
-            /// Consumed once restored. The change manager is the selected tab's edits from here, and
-            /// a copy left on the tab went stale with the first undo: it went on reporting edits the
-            /// reader had taken back, and a reload put off for them never ran.
+            // Consumed once restored: a copy left on the tab went stale with the first undo and kept reporting undone edits.
             let pendingState = newTab.pendingChanges
             if pendingState.hasChanges {
                 changeManager.restoreState(
@@ -119,6 +95,7 @@ extension MainContentCoordinator {
                     columnTypeNames: newRows.columnTypeNames
                 )
                 tabManager.mutate(at: newIndex) { $0.pendingChanges = TabChangeSnapshot() }
+                tabSwitchOutgoingTabId = nil
             } else {
                 changeManager.configureForTable(
                     tableName: newTab.tableContext.tableName ?? "",
@@ -131,6 +108,7 @@ extension MainContentCoordinator {
                     columnTypeNames: newRows.columnTypeNames,
                     triggerReload: false
                 )
+                tabSwitchOutgoingTabId = nil
             }
 
             let restoreMs = Int(Date().timeIntervalSince(restoreStart) * 1_000)
@@ -138,11 +116,7 @@ extension MainContentCoordinator {
                 "[switch] handleTabChange phases: saveOutgoing=\(saveMs)ms restoreIncoming=\(restoreMs)ms"
             )
 
-            // No `reloadVersion` bump here. It is the change manager's throw-away-and-fetch-again
-            // signal and it is shared by every tab in the window, so bumping it on a switch told
-            // the incoming grid its rows had changed and made it re-format the whole result. The
-            // reload a switch does need is already forced by the freshly mounted grid's zero row
-            // count, and a real content change still arrives through `configureForTable`. (#2424)
+            // No `reloadVersion` bump: it is window-wide, and bumping it on a switch re-formatted the incoming grid's whole result (#2424).
             let needsReload = needsRowReload(newId)
             lazyLoadCurrentTabIfNeeded()
             TabSwitchTracer.shared.selectionApplied(
@@ -152,10 +126,7 @@ extension MainContentCoordinator {
                 isShowing: { [weak manager = tabManager] in manager?.isShowing(newId) ?? false }
             )
         } else {
-            /// An entry with no tab of its own. The outgoing tab's edits were saved onto it above,
-            /// and the live copy goes: the change manager is the selected tab's, and with none
-            /// selected a Save would write those rows against the database now on screen.
-            selectionState.indices = []
+            // No tab selected: drop the live copy, or a Save would write the outgoing tab's rows against the database now on screen.
             changeManager.configureForTable(
                 tableName: "",
                 columns: [],
@@ -171,6 +142,12 @@ extension MainContentCoordinator {
         }
     }
 
+    private func commitGridEdit(ofTab tabId: UUID) {
+        existingGridModel(forTab: tabId)?.commitEditing()
+        guard let tab = tabManager.tabs.first(where: { $0.id == tabId }) else { return }
+        activeGridModelProvider(for: tab)?.activeGridModel?.commitEditing()
+    }
+
     // For a tab that comes on screen without a selection change, before its pane restarts any load.
     func arrivingRows(for tabId: UUID) -> TabSwitchRows {
         guard let tab = tabManager.tabs.first(where: { $0.id == tabId }) else { return .resident }
@@ -189,12 +166,7 @@ extension MainContentCoordinator {
         TableLoadTracer.shared.activeToken(for: tabId) != nil
     }
 
-    /// What the toolbar's Run, Explain, Format and Favorite items validate against.
-    ///
-    /// Execution state is deliberately not among these: `TabExecutionRegistry` is the single answer
-    /// to "is something running", and its own documentation records that a hand-kept mirror of that
-    /// is what let the titlebar report a query which had already ended (#2342). The toolbar reads
-    /// it live through `isSelectedTabExecuting`.
+    // No execution state here: a hand-kept mirror let the titlebar show an ended query (#2342), so the toolbar reads the registry.
     func syncQueryToolbarState(for tab: QueryTab) {
         toolbarState.isQueryTab = tab.tabType == .query
         toolbarState.hasQueryText = tab.tabType == .query && tab.hasQueryText
@@ -209,20 +181,12 @@ extension MainContentCoordinator {
         syncQueryToolbarState(for: tab)
     }
 
-    /// Whether the tab the toolbar is pointed at has a query in flight, asked of the registry each
-    /// time rather than stored.
     var isSelectedTabExecuting: Bool {
         guard let tabId = tabManager.selectedTabId else { return false }
         return tabExecution.isExecuting(tabId)
     }
 
-    /// Whether dropping this tab's rows is safe, which is exactly whether `canAutoLoadTableTab`
-    /// will bring them back. The two answers have to agree: a tab evicted without a route back to
-    /// its rows shows an empty grid until the user refreshes it by hand.
-    ///
-    /// Table tabs qualify because their rows follow from their generated query. Query tabs do not,
-    /// a pinned result shares the buffer it would lose, and a tab with an execution, a load task or
-    /// a page fetch in flight would have the result land on a buffer that moved out from under it.
+    // Must agree with `canAutoLoadTableTab`: a tab evicted with no route back to its rows shows an empty grid until refreshed.
     func canEvictReloadableTableRows(_ tab: QueryTab) -> Bool {
         guard tab.id != tabManager.selectedTabId,
               tab.tabType == .table,
@@ -254,7 +218,7 @@ extension MainContentCoordinator {
             tab.loadEpoch &+= 1
         }
         tabSessionRegistry.evict(for: tabId)
-        displayStateCache.removeValue(forKey: tabId)
+        reloadGridModel(forTab: tabId)
         return true
     }
 
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsMutation.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsMutation.swift
index fcec52a80b..869d72a70b 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsMutation.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsMutation.swift
@@ -18,9 +18,7 @@ extension MainContentCoordinator {
         _ mutate: (inout TableRows) -> Delta
     ) -> Delta {
         let delta = tabSessionRegistry.updateTableRows(for: tabId, mutate)
-        if delta.changesRowSet {
-            refreshDisplayOrder(forTab: tabId)
-        }
+        applyGridDelta(delta, forTab: tabId)
         return delta
     }
 
@@ -43,12 +41,13 @@ extension MainContentCoordinator {
         } else {
             resetViewStateForNewSource(tabId: tabId)
         }
+        // Staged before the model reloads: the mounted grid applies it, selection included, on that reload.
         if gridIsMounted {
             let placement = GridViewportResolver.placement(
                 for: intent,
                 from: snapshot,
                 in: tableRows,
-                displayIDs: displayIDs(forTab: tabId),
+                displayIDs: resolvedDisplayIDs(of: tableRows, forTab: tabId),
                 keyColumns: keyColumns
             )
             tabSessionRegistry.stageViewportPlacement(placement, for: tabId)
@@ -56,16 +55,21 @@ extension MainContentCoordinator {
         if !tableRows.rows.isEmpty {
             clearRestoredRowAnchor(forTab: tabId)
         }
-        notifyFullReplaceIfActive(tabId: tabId)
+        notifyFullReplace(tabId: tabId)
+    }
+
+    // The order the incoming rows will show in, before the model has reloaded onto them.
+    private func resolvedDisplayIDs(of tableRows: TableRows, forTab tabId: UUID) -> [RowID]? {
+        guard let tab = tabManager.tabs.first(where: { $0.id == tabId }), tab.valueFilter.isActive else { return nil }
+        return GridDisplayOrderResolver.resolve(
+            tableRows: tableRows,
+            valueFilter: tab.valueFilter,
+            displayFormats: dataGridEntries[tabId]?.store.displayFormats ?? displayFormats(for: tab),
+            databaseType: connection.type
+        )
     }
 
-    /// The one place a whole `TableRows` is installed into the shared buffer.
-    ///
-    /// Reconciling the view mode belongs here rather than at each caller, because a result set
-    /// switch and a re-seed replace the rows just as completely as a fresh execution does: a tab
-    /// left on Map that switches to a result with no geometry column is stranded exactly the same
-    /// way. An incremental edit goes through `mutateActiveTableRows` instead and never changes
-    /// which modes the result can offer.
+    // Mode reconciliation lives here: a result switch or re-seed strands a Map tab like a fresh run does. Edits never change modes.
     private func installTableRows(_ tableRows: TableRows, for tabId: UUID) {
         tabSessionRegistry.setTableRows(tableRows, for: tabId)
         let spatialColumns = SpatialColumn.columns(in: tableRows)
@@ -73,12 +77,7 @@ extension MainContentCoordinator {
         reconcileResultsViewMode(against: tableRows, spatialColumns: spatialColumns, for: tabId)
     }
 
-    /// Keeps the tab on a mode it can still offer.
-    ///
-    /// A mode that leaves `availableModes` takes its own switcher segment and every View menu item
-    /// with it, and those items carry no key equivalent, so nothing is left to press: the tab is
-    /// stranded until another statement happens to restore the mode. A succeeding non-SELECT
-    /// installs an empty `TableRows` and does exactly that.
+    // A mode leaving `availableModes` takes its segment and View menu items (no key equivalent), stranding the tab, as a non-SELECT does.
     private func reconcileResultsViewMode(
         against tableRows: TableRows,
         spatialColumns: [SpatialColumn],
@@ -101,10 +100,7 @@ extension MainContentCoordinator {
         tabManager.mutate(tabId: tabId) { $0.display.resultsViewMode = reconciled }
     }
 
-    /// Switching result sets replaces what the grid shows and what an edit would be written to, so
-    /// it takes the same unsaved-changes gate as sorting, paging and filtering. Without the gate a
-    /// pending edit set outlives the switch and `handleColumnsChange` refuses to rebuild the change
-    /// manager while it exists, which leaves the grid writing to the outgoing result's table.
+    // Same unsaved-changes gate as sorting: `handleColumnsChange` won't rebuild with pending edits, so the grid would write to the old table.
     func switchActiveResultSet(to resultSetId: UUID?, in tabId: UUID) {
         guard let tabIdx = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               tabManager.tabs[tabIdx].display.activeResultSetId != resultSetId else { return }
@@ -116,16 +112,7 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Takes the reader to the statement a result came from, when they moved to a different result.
-    ///
-    /// This is the reverse of the run: a statement produces a result, so selecting the result says which statement to
-    /// look at. It is only ever a response to the reader picking a result, which is what the HIG allows; nothing here
-    /// runs on its own. Re-selecting the result already showing does nothing, because the reader is comparing pinned
-    /// results rather than asking to be taken anywhere, and scrolling the editor under them would be an answer to a
-    /// question they did not ask.
-    ///
-    /// The caret moves without taking first responder, so focus stays wherever the reader put it and the
-    /// caret-statement band follows for free.
+    // Only on the reader picking another result (HIG). Moves the caret without taking first responder, so focus stays put.
     private func revealStatement(behind resultSetId: UUID?, in tabId: UUID) {
         guard let tabIdx = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               tabManager.tabs[tabIdx].tabType == .query,
@@ -136,7 +123,7 @@ extension MainContentCoordinator {
         requestStatementJump(anchor, in: tabId)
     }
 
-    /// The switch itself, for callers that have already decided the outgoing result is going away.
+    // No discard gate: for callers that already decided the outgoing result is going away.
     func applyResultSetSwitch(to resultSetId: UUID?, in tabId: UUID) {
         guard let tabIdx = tabManager.tabs.firstIndex(where: { $0.id == tabId }) else { return }
         flushBufferToActiveResult(tabId: tabId, pinnedOnly: false)
@@ -146,12 +133,10 @@ extension MainContentCoordinator {
         resetViewStateForNewSource(tabId: tabId)
         syncLoadMoreState(from: incoming, at: tabIdx)
         adoptOrigin(of: incoming, at: tabIdx)
-        notifyFullReplaceIfActive(tabId: tabId)
+        notifyFullReplace(tabId: tabId)
     }
 
-    /// The shared row buffer holds whatever the active result is showing, and it is the only copy
-    /// that page loads, Fetch All and cell edits write to. Handing it back before it is replaced is
-    /// what keeps a result the user can return to from serving rows it never produced.
+    // The shared buffer is the only copy page loads, Fetch All and edits write to, so hand it back before replacing it.
     func flushBufferToActiveResult(tabId: UUID, pinnedOnly: Bool) {
         guard let idx = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               let active = tabManager.tabs[idx].display.activeResultSet,
@@ -160,28 +145,16 @@ extension MainContentCoordinator {
         active.tableRows = tabSessionRegistry.tableRows(for: tabId)
     }
 
-    /// Re-points the shared buffer at whatever result just became active.
-    ///
-    /// A plan or an error result carries no rows, and leaving the previous result's rows in the
-    /// buffer means the next flush hands them to it, after which it renders a data grid instead of
-    /// its plan or its error.
-    ///
-    /// It replaces the rows as wholly as a result switch does, so it takes the same full-replace
-    /// path. The grid skips its update while a cell editor or viewer is open, and only the full
-    /// replace closes them, so a failed Run All over an open viewer otherwise kept the previous
-    /// result's headings and selection under the error.
+    // A plan or error result has no rows: left in the buffer, the previous rows get flushed into it and it renders as a grid.
     func seedBufferFromActiveResult(tabId: UUID) {
         guard let idx = tabManager.tabs.firstIndex(where: { $0.id == tabId }) else { return }
         let rows = tabManager.tabs[idx].display.activeResultSet?.tableRows ?? TableRows()
         installTableRows(rows, for: tabId)
         resetViewStateForNewSource(tabId: tabId)
-        notifyFullReplaceIfActive(tabId: tabId)
+        notifyFullReplace(tabId: tabId)
     }
 
-    /// A tab's table context describes its newest execution, so moving to another result has to
-    /// move the context onto that result's own table. The change manager is rebuilt here rather
-    /// than through the `schemaVersion` observer, because that observer refuses to run while
-    /// unsaved edits exist and would leave the manager pointed at the outgoing table (#2243).
+    // Rebuilds the change manager here, not via the `schemaVersion` observer, which refuses to run with unsaved edits (#2243).
     private func adoptOrigin(of resultSet: ResultSet, at tabIdx: Int) {
         guard tabManager.tabs[tabIdx].tabType == .query else { return }
         let origin = resultSet.origin
@@ -209,8 +182,7 @@ extension MainContentCoordinator {
         )
     }
 
-    /// A value filter stores displayed strings picked out of the outgoing source, so on an unrelated
-    /// result it narrows to nothing. A query tab's grid sort goes too: the new rows carry no ORDER BY.
+    // A value filter holds strings from the outgoing source, so it narrows an unrelated result to nothing; new rows carry no ORDER BY.
     private func resetViewStateForNewSource(tabId: UUID) {
         clearValueFilter(forTab: tabId)
         tabManager.mutate(tabId: tabId) { tab in
@@ -220,31 +192,17 @@ extension MainContentCoordinator {
         resetSelection(tabId: tabId)
     }
 
-    /// Row selection is a set of display positions into the rows being replaced, so it means nothing
-    /// after them. A re-read of the same source puts it back by key through the viewport placement.
+    // Row ids are positional per page. A re-read of the same source restores the selection by key via the viewport placement.
     private func resetSelection(tabId: UUID) {
-        tabManager.mutate(tabId: tabId) { tab in
-            guard !tab.selectedRowIndices.isEmpty || !tab.cellSelection.isEmpty else { return }
-            tab.selectedRowIndices = []
-            tab.cellSelection = .empty
-        }
-        guard let idx = tabManager.selectedTabIndex,
-              idx < tabManager.tabs.count,
-              tabManager.tabs[idx].id == tabId else { return }
-        /// The cell selection is what the published row selection is derived from, so leaving it
-        /// behind here would let the next publish reinstate rows the new result does not have.
-        dataTabDelegate?.tableViewCoordinator?.selectionController.clear()
-        dataTabDelegate?.tableViewCoordinator?.clearRowSelection()
-        if !selectionState.indices.isEmpty {
-            selectionState.indices = []
+        if tabManager.tabs.first(where: { $0.id == tabId })?.selectionSnapshot.isEmpty == false {
+            tabManager.mutate(tabId: tabId) { $0.selectionSnapshot = .empty }
         }
+        guard let entry = dataGridEntries[tabId] else { return }
+        entry.store.selectionSnapshot = .empty
+        entry.model.clearSelection()
     }
 
-    /// Orders a result that has no query of its own to send again, over the rows the grid already holds.
-    ///
-    /// A SQL Server batch can return a result no single statement stands behind, or one read by a statement that
-    /// needs a variable the batch declared. Re-running with `ORDER BY` would mean re-sending the whole script, writes
-    /// and all, so the rows are ordered here instead.
+    // A SQL Server batch result may have no single statement behind it, and re-running with ORDER BY would resend writes, so sort here.
     func sortHeldRows(by state: SortState, tabId: UUID) {
         confirmDiscardChangesIfNeeded(action: .sort) { [weak self] confirmed in
             guard let self, confirmed else { return }
@@ -276,13 +234,10 @@ extension MainContentCoordinator {
         }
     }
 
-    private func notifyFullReplaceIfActive(tabId: UUID) {
-        guard let idx = tabManager.selectedTabIndex,
-              idx < tabManager.tabs.count,
-              tabManager.tabs[idx].id == tabId else { return }
-
+    private func notifyFullReplace(tabId: UUID) {
+        let isSelected = tabManager.selectedTabId == tabId
         let tracer = TableLoadTracer.shared
-        let token = tracer.applyingToken
+        let token = isSelected ? tracer.applyingToken : nil
         if let token {
             tracer.stage(
                 .gridReloadBegin,
@@ -290,7 +245,7 @@ extension MainContentCoordinator {
                 detail: "rows=\(tabSessionRegistry.tableRows(for: tabId).rows.count)"
             )
         }
-        dataTabDelegate?.tableViewCoordinator?.applyFullReplace()
+        reloadGridModel(forTab: tabId)
         if let token { tracer.stage(.gridReloadEnd, token: token) }
     }
 }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsRefresh.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsRefresh.swift
index 700136ca79..74b9acd5d0 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsRefresh.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsRefresh.swift
@@ -9,13 +9,7 @@ import Combine
 import Foundation
 
 extension MainContentCoordinator {
-    /// Marks every addressed table tab stale, reloads the selected one now when the plan allows, and
-    /// has the structure of each fetched again.
-    ///
-    /// Nothing here asks a question. The change was made somewhere else, maybe in another window, so
-    /// a tab holding edits or an open cell overlay keeps them, and its rows, until they are gone, and
-    /// a structure holding staged edits keeps those. The tab that made the change is left out of the
-    /// rows plan only: it reloads its own rows, and its structure is fetched like any other.
+    // Asks nothing: the change came from elsewhere, so tabs with edits or overlays keep them; the source tab reloads its own rows.
     func refreshTableTabs(
         for change: TableFreshness.Change,
         excluding originTabId: UUID? = nil,
@@ -44,10 +38,7 @@ extension MainContentCoordinator {
         refreshStructure(ofTabs: addressed)
     }
 
-    /// Runs the reload the selected tab put off while its cell overlay or its edits were in the way,
-    /// once they are gone. The plan is asked again rather than remembered, so whatever the user
-    /// started meanwhile, a new overlay, an edit or a load of the tab's own, still stands in the way.
-    /// A grid torn down with its window closes its overlay too, and that starts nothing.
+    // The plan is asked again, not remembered, so anything the user started meanwhile still blocks the reload.
     func resumeDeferredTableRefresh() {
         guard !isTearingDown,
               let selectedState = selectedTabRefreshState,
@@ -60,10 +51,7 @@ extension MainContentCoordinator {
         )
     }
 
-    /// Edits go without a Discard too: the last one undone, a cell typed back to what it held, a
-    /// deleted row restored. Each leaves the change manager clean, which is when a reload put off for
-    /// them can run. Heard a turn later, because the manager publishes before it stores the value, and
-    /// a switch or a save that cleaned it has started the tab's own load by then.
+    // Heard a turn later: the manager publishes before it stores, and by then a cleaning switch or save has started the load.
     func resumeWhenEditsClear() -> AnyCancellable {
         changeManager.$hasChanges
             .removeDuplicates()
@@ -73,8 +61,7 @@ extension MainContentCoordinator {
             .sink { [weak self] _ in self?.resumeDeferredTableRefresh() }
     }
 
-    /// A change that names no single table reaches every table tab in its scope, and can have
-    /// changed the columns of a table no tab shows, so every column list cached for scoping goes.
+    // A scope-wide change can alter columns of tables no tab shows, so every cached column list goes.
     func applyDataRefresh(_ request: DataRefreshRequest) {
         guard request.connectionId == connectionId else { return }
         schemaColumns.removeAll()
@@ -83,9 +70,7 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Structure the user is not editing is fetched again: now for the one on screen, on its next
-    /// mount for the rest. A structure holding staged edits keeps them and the old baseline, and is
-    /// fetched once they are applied, undone or discarded.
+    // A structure with staged edits keeps them and the old baseline until they are applied, undone or discarded.
     func refreshStructure(ofTabs tabs: [QueryTab]) {
         let selectedId = tabManager.selectedTabId
         for tab in tabs {
@@ -99,15 +84,11 @@ extension MainContentCoordinator {
         }
     }
 
-    /// The named table's column list, cached for scoping a tab opened on it later.
     func forgetSchemaColumns(of change: DatabaseObjectChange) {
         schemaColumns.remove(schemaColumnsKey(change.name, scope: change.scope))
     }
 
-    /// The columns cached for building a table's column-scoped query describe the definition before
-    /// the change, and a reload builds its SQL from them before it fetches anything: kept, they would
-    /// name a dropped column in the select list and leave out an added one. The reload's own
-    /// definition fetch stores the new set.
+    // A reload builds its SQL from these cached columns before fetching, so stale ones would select a dropped column.
     private func forgetSchemaColumns(ofTabs tabs: [QueryTab]) {
         for tab in tabs {
             guard let tableName = tab.tableContext.tableName else { continue }
@@ -140,7 +121,7 @@ extension MainContentCoordinator {
         guard let tab = tabManager.selectedTab else { return nil }
         let holdsEdits = changeManager.hasChanges
             || tab.pendingChanges.hasChanges
-            || dataTabDelegate?.tableViewCoordinator?.hasOpenCellOverlay == true
+            || isEditingActiveGrid
         return TableRowsRefreshPlan.SelectedTabState(id: tab.id, holdsEdits: holdsEdits, load: selectedTabLoad(tab.id))
     }
 
@@ -154,7 +135,7 @@ extension MainContentCoordinator {
         return tabExecution.isBusy(tabId) ? .extending : .idle
     }
 
-    /// Written only when there is a count to retire, because every write fires `tabs`' `didSet`.
+    // Written only when set, because every write fires tabs' didSet.
     private func retireDerivedRowCountIfSet(forTab tabId: UUID) {
         guard let pagination = tabManager.tabs.first(where: { $0.id == tabId })?.pagination,
               pagination.totalRowCount != nil || pagination.isApproximateRowCount else { return }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+UnloadedValues.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+UnloadedValues.swift
index 48c1b46fe2..f3bd273ecc 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+UnloadedValues.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+UnloadedValues.swift
@@ -43,23 +43,24 @@ extension MainContentCoordinator {
 
     // False while the rows' unloaded values load; `retry` runs once every one has arrived.
     func unloadedValuesAreLoaded(
-        displayRows: Set<Int>,
+        rowIDs: [RowID],
         columns: IndexSet? = nil,
         retry: @escaping @MainActor () -> Void
     ) -> Bool {
         guard let tab = tabManager.selectedTab else { return true }
-        let positions = displayRows.sorted()
-        let shownIDs = shownRowIDs(at: positions, tabId: tab.id)
         let rows = tabSessionRegistry.tableRows(for: tab.id)
-        let ids = shownIDs.compactMap { $0 }
-            .filter { id in rows.row(withID: id)?.unloadedColumns.keys.contains { columns?.contains($0) ?? true } == true }
+        let ids = rowIDs.filter { id in
+            rows.row(withID: id)?.unloadedColumns.keys.contains { columns?.contains($0) ?? true } == true
+        }
         guard !ids.isEmpty else { return true }
         let tabId = tab.id
+        // Row ids are positional per page, so a new buffer makes the same ids name other rows.
+        let epoch = tabSessionRegistry.session(for: tabId)?.bufferEpoch
         Task { @MainActor [weak self] in
             guard let self else { return }
             let loaded = await self.loadUnloadedValues(tabId: tabId, rowIDs: ids, columns: columns)
             guard loaded, self.tabManager.selectedTabId == tabId,
-                  self.shownRowIDs(at: positions, tabId: tabId) == shownIDs else {
+                  self.tabSessionRegistry.session(for: tabId)?.bufferEpoch == epoch else {
                 NSSound.beep()
                 return
             }
@@ -68,19 +69,9 @@ extension MainContentCoordinator {
         return false
     }
 
-    private func shownRowIDs(at positions: [Int], tabId: UUID) -> [RowID?] {
-        let rows = tabSessionRegistry.tableRows(for: tabId)
-        let displayIDs = activeGridDisplayIDs
-        return positions.map { DisplayRowMapping.row(forDisplay: $0, displayIDs: displayIDs, in: rows)?.id }
-    }
-
-    func loadInspectorRowValues(tabId: UUID, displayRow: Int) async {
+    func loadInspectorRowValues(tabId: UUID, rowID: RowID) async {
         guard tabManager.selectedTabId == tabId,
-              let row = DisplayRowMapping.row(
-                  forDisplay: displayRow,
-                  displayIDs: activeGridDisplayIDs,
-                  in: tabSessionRegistry.tableRows(for: tabId)
-              ),
+              let row = tabSessionRegistry.tableRows(for: tabId).row(withID: rowID),
               row.hasUnloadedValues else { return }
         await loadUnloadedValues(tabId: tabId, rowIDs: [row.id])
     }
@@ -148,7 +139,6 @@ extension MainContentCoordinator {
         mutateActiveTableRows(for: tabId) { $0.fillUnloaded(read.values) }
         if tabManager.selectedTabId == tabId {
             changeManager.adoptLoadedValues(read.values)
-            repaintFilledCells(read.values, tabId: tabId)
         } else {
             tabManager.mutate(tabId: tabId) { $0.pendingChanges.adoptLoadedValues(read.values) }
         }
@@ -211,23 +201,6 @@ extension MainContentCoordinator {
         return read
     }
 
-    // The fill reports storage positions, and the grid reads a delta's rows as display positions.
-    private func repaintFilledCells(_ values: [RowID: [Int: PluginCellValue]], tabId: UUID) {
-        let rows = tabSessionRegistry.tableRows(for: tabId)
-        let displayIDs = activeGridDisplayIDs
-        var positions: Set<CellPosition> = []
-        for (id, cells) in values {
-            guard let displayRow = DisplayRowMapping.displayIndex(forRowID: id, displayIDs: displayIDs, in: rows) else {
-                continue
-            }
-            for column in cells.keys {
-                positions.insert(CellPosition(row: displayRow, column: column))
-            }
-        }
-        guard !positions.isEmpty else { return }
-        dataTabDelegate?.tableViewCoordinator?.applyDelta(.cellsChanged(positions))
-    }
-
     func rowsWithUnloadedValues() -> Set<RowID> {
         guard let tabId = tabManager.selectedTab?.id else { return [] }
         return Set(tabSessionRegistry.tableRows(for: tabId).rows.lazy.filter(\.hasUnloadedValues).map(\.id))
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+WindowLifecycle.swift b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+WindowLifecycle.swift
index 85e5c78726..d19feeaa42 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+WindowLifecycle.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentCoordinator+WindowLifecycle.swift
@@ -2,11 +2,7 @@
 //  MainContentCoordinator+WindowLifecycle.swift
 //  TablePro
 //
-//  Window-lifecycle handlers invoked by TabWindowController's NSWindowDelegate
-//  methods. windowDidBecomeKey is intentionally lightweight (focus state,
-//  sidebar sync, and a file check that stats off the main actor) per Apple's
-//  documentation; visibility-scoped lazy-load lives in MainEditorContentView's
-//  `.task(id:)` modifier.
+//  windowDidBecomeKey stays light per Apple's docs; visibility-scoped lazy load lives in MainEditorContentView's .task(id:).
 //
 
 import AppKit
@@ -17,13 +13,7 @@ import TableProPluginKit
 extension MainContentCoordinator {
     // MARK: - Window Delegate Dispatch
 
-    /// Called from `TabWindowController.windowDidBecomeKey(_:)`.
-    /// Updates focus state, refreshes file-based schema if stale, starts a check of
-    /// each file-backed tab against its file on disk, and syncs the sidebar selection
-    /// to the active tab. The one query-related action here is
-    /// consuming a deferred restore load: a restored background tab loads its data
-    /// the first time its window becomes key. All other lazy-load is owned by
-    /// `MainEditorContentView`'s `.task(id:)` modifier.
+    // The one query action here: a restored background tab loads its data the first time its window becomes key.
     func handleWindowDidBecomeKey() {
         let t0 = Date()
         Self.lifecycleLogger.debug(
@@ -45,9 +35,6 @@ extension MainContentCoordinator {
         )
     }
 
-    /// Called from `TabWindowController.windowDidResignKey(_:)`.
-    /// Schedules a 5s-delayed eviction of row data in inactive tabs; a fresh
-    /// `windowDidBecomeKey` cancels the eviction before it fires.
     func handleWindowDidResignKey() {
         Self.lifecycleLogger.debug(
             "[switch] coordinator.handleWindowDidResignKey connId=\(self.connectionId, privacy: .public)"
@@ -65,20 +52,15 @@ extension MainContentCoordinator {
         }
     }
 
-    /// Called from `TabWindowController.windowWillClose(_:)`.
-    /// Synchronous teardown — no grace period, no delayed Task. Writes tab
-    /// state to disk, releases SwiftUI-scoped right-panel state, then
-    /// disconnects the session if this was the last window for the connection.
+    // Synchronous on purpose: no grace period, no delayed Task.
     func handleWindowWillClose() {
         let t0 = Date()
         Self.lifecycleLogger.info(
             "[close] coordinator.handleWindowWillClose connId=\(self.connectionId, privacy: .public) tabs=\(self.tabManager.tabs.count)"
         )
 
-        /// Never clears: a window closing says nothing about whether the user wants these tabs
-        /// kept, and every connection in the window reaches here. Discarding saved state is
-        /// `closeTabsByUser`'s job alone.
-        dataTabDelegate?.tableViewCoordinator?.flushPendingColumnLayoutPersistence()
+        // Never clears: closing a window says nothing about keeping its tabs; only closeTabsByUser discards saved state.
+        flushColumnLayoutPersistence()
         if !MainContentCoordinator.isAppTerminating, !isTearingDown {
             persistence.saveAggregatedSync()
         }
@@ -95,8 +77,6 @@ extension MainContentCoordinator {
         )
     }
 
-    /// Announce the active tab title to VoiceOver when the window becomes key,
-    /// so assistive-technology users get the same context the window title gives.
     private func announceActiveTabToVoiceOver() {
         guard let title = tabManager.selectedTab?.title, !title.isEmpty else { return }
         NSAccessibility.post(
@@ -129,13 +109,7 @@ extension MainContentCoordinator {
 
     // MARK: - Sidebar Sync
 
-    /// Mark the object the selected tab is showing in this window's object tree, or nothing when
-    /// that tab belongs to a container the tree is not listing. Reads tables fresh from the
-    /// DatabaseManager because the schema load is async and may complete after focus changes.
-    ///
-    /// The mark is a function of four inputs, so every one of them calls this: the selected tab,
-    /// the browsed container, the object list, and the window becoming key. Recomputing on only
-    /// some of them is what left a stale mark on a row in another database (#2217).
+    // Every input the mark depends on (tab, container, objects, key window) calls this; skipping one left a stale mark (#2217).
     func syncSidebarObjectSelection() {
         let selectedTab = tabManager.selectedTab
         let selection = SidebarObjectSelection.resolve(
@@ -151,13 +125,7 @@ extension MainContentCoordinator {
 
     // MARK: - Lazy Load
 
-    /// Lowers the flag `discardRowsForRetarget` raised, for a load that is not going to run.
-    ///
-    /// The flag is raised synchronously with the row buffer being emptied, so the bar never reads a
-    /// cleared tab as a settled empty result. Every path that then declines to start the load has to
-    /// lower it again, or the bar keeps a spinner and a fully disabled pagination cluster for a tab
-    /// that is not loading anything, until the next successful load or `Cmd+.`. A load that is
-    /// already in flight is not a decline, and must leave the flag alone.
+    // Every path that declines the load must lower the flag, or the bar keeps a spinner; an in-flight load leaves it alone.
     func declineTableLoad(for tabId: UUID) {
         tabManager.mutate(tabId: tabId) { $0.pagination.isLoading = false }
     }
@@ -183,8 +151,7 @@ extension MainContentCoordinator {
             connectionId: connectionId
         )
 
-        /// A trace the in-flight load still owns stays open, because that load is the one that will
-        /// close it. Only a trace this call minted is closed here.
+        // The in-flight load closes the trace it owns; only a trace this call minted is closed here.
         func noteLoadAlreadyInFlight() {
             guard carriedToken == nil else { return }
             tracer.anomaly(.loadAlreadyInFlight, token: traceToken)
@@ -198,12 +165,7 @@ extension MainContentCoordinator {
 
         clearAbandonedExecutingFlagIfNeeded(for: tab)
 
-        /// The task slot above stops answering the moment the load hands off to an execution:
-        /// `executeQueryInternal` supersedes, and `supersedeExecution` clears the very slot held by
-        /// the task it is running inside. Every later trigger for the same navigation then found an
-        /// empty slot and scheduled a second identical load, whose predecessor took the successor's
-        /// claim down with it on the way out (#2342). The registry owns the other half of the same
-        /// question, so both halves are asked, and neither alone is enough.
+        // The task slot empties once the load hands off to execution, so the registry is asked too, or a duplicate load ran (#2342).
         guard !tabExecution.isBusy(tab.id) else {
             noteLoadAlreadyInFlight()
             return
@@ -241,9 +203,7 @@ extension MainContentCoordinator {
         tableLoadTasks[tabId] = nil
     }
 
-    /// Becoming key ends the deferral whichever tab is selected. A link or an agent can select
-    /// another tab before the window comes forward, and a deferral left standing refused every
-    /// later load of that tab, including the table the user next opened into it.
+    // Ends the deferral whatever tab is selected: a link or agent can switch tabs first, and a leftover deferral blocked loads.
     func consumeDeferredRestoreLoadIfNeeded() {
         guard isKeyWindow, let deferredId = deferredRestoreLoadTabId else { return }
         deferredRestoreLoadTabId = nil
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift b/apple/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift
index b9571b453a..86bd465bca 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift
@@ -12,9 +12,7 @@ import TableProPluginKit
 extension MainContentView {
     // MARK: - Inspector Selection
 
-    /// Which grid owns the current selection. `GridSelectionState` is shared by the data
-    /// grid, the structure grid, and the new-table grid, so its indices only address the
-    /// data tab's rows when the data grid is the one on screen.
+    // Whose rows the active grid model's selection indexes: the data tab's, a schema grid's, or nobody's.
     var gridSelectionOwner: GridSelectionOwner {
         GridSelectionOwner.resolve(
             tabType: coordinator.tabManager.selectedTab?.tabType,
@@ -22,27 +20,27 @@ extension MainContentView {
         )
     }
 
+    private var dataGridModel: DataGridModel? {
+        gridSelectionOwner == .dataGrid ? coordinator.activeGridModel : nil
+    }
+
     var selectedInspectorRow: InspectorRow? {
         guard gridSelectionOwner == .schemaGrid,
-              let displayRow = coordinator.selectionState.indices.min() else { return nil }
+              let displayRow = coordinator.activeGridModel?.selection.affectedRows.first else { return nil }
         return coordinator.inspectorRowSource?.inspectorRow(atDisplayRow: displayRow)
     }
 
     // MARK: - Inspector Subject
 
-    /// Whether anything is selected for the inspector to show.
     var hasInspectableRow: Bool {
         switch gridSelectionOwner {
         case .schemaGrid: return selectedInspectorRow != nil
-        case .dataGrid: return !coordinator.selectionState.indices.isEmpty
+        case .dataGrid: return dataGridModel?.selection.isEmpty == false
         case .none: return false
         }
     }
 
-    /// What the inspector names above its fields.
-    ///
-    /// A schema grid's selection is a column definition, not a row of a result: it has no position
-    /// and no identity, so it gets its own case rather than being rendered as "Row 0 of 0".
+    // A schema grid's selection is a column definition with no position, so it is not named "Row 0 of 0".
     var inspectorSubject: InspectorSubject {
         switch gridSelectionOwner {
         case .schemaGrid:
@@ -61,34 +59,24 @@ extension MainContentView {
             }
             return dataRowSubject(table: table) ?? .tableOnly(table: table)
         case .none:
-            /// A chart, a dashboard or an ER diagram owns no grid, so there is no row to name. The
-            /// table still is the subject when the tab has one, which is what the table statistics
-            /// are shown under.
+            // A chart, a dashboard or a diagram owns no grid; the table is still the subject of its statistics.
             guard let table = qualifiedTableName else { return .empty }
             return .tableOnly(table: table)
         }
     }
 
     private func dataRowSubject(table: String) -> InspectorSubject? {
-        let indices = coordinator.selectionState.indices
-        guard !indices.isEmpty else { return nil }
-        if indices.count > 1 {
-            return .multipleRows(table: table, count: indices.count)
+        guard let model = dataGridModel else { return nil }
+        let rows = model.selection.affectedRows
+        guard let first = rows.first else { return nil }
+        if rows.count > 1 {
+            return .multipleRows(table: table, count: rows.count)
         }
-        guard let tab = coordinator.tabManager.selectedTab, let first = indices.min() else {
-            return .tableRow(table: table, position: nil)
-        }
-        let total = coordinator.activeGridDisplayIDs?.count
-            ?? coordinator.tabSessionRegistry.tableRows(for: tab.id).count
+        let total = model.rowCount
         guard total > 0 else { return .tableRow(table: table, position: nil) }
-        return .tableRow(
-            table: table,
-            position: InspectorSubject.RowPosition(index: first + 1, total: total)
-        )
+        return .tableRow(table: table, position: InspectorSubject.RowPosition(index: first + 1, total: total))
     }
 
-    /// Schema-qualified where the engine has schemas, so two tables of the same name in different
-    /// schemas do not read identically in the header.
     private var qualifiedTableName: String? {
         guard let table = currentTab?.tableContext.tableName else { return nil }
         guard let schema = currentTab?.tableContext.schemaName, !schema.isEmpty else { return table }
@@ -97,23 +85,15 @@ extension MainContentView {
 
     // MARK: - Selected Row for the JSON Tab
 
-    /// The same selection the details tab reads, carried as raw cell values.
-    ///
-    /// The JSON tab decides from the column's own type whether a value prints quoted, which the
-    /// formatted strings the details tab takes cannot answer. Only the data grid supplies it: the
-    /// schema grid's rows are label and value pairs with no types and no foreign keys.
+    // Raw cell values, so the JSON tab can quote by the column's own type. Only the data grid has types.
     var jsonRowSnapshotForSidebar: JSONRowSnapshot? {
-        guard gridSelectionOwner == .dataGrid,
+        guard let model = dataGridModel,
               let tab = coordinator.tabManager.selectedTab,
-              let firstDisplayIndex = coordinator.selectionState.indices.min(),
-              let scope = coordinator.scope(for: tab) else { return nil }
-        let tableRows = coordinator.tabSessionRegistry.tableRows(for: tab.id)
-        guard !tableRows.columns.isEmpty,
-              let row = DisplayRowMapping.row(
-                  forDisplay: firstDisplayIndex,
-                  displayIDs: coordinator.activeGridDisplayIDs,
-                  in: tableRows
-              ) else { return nil }
+              let firstDisplayIndex = model.selection.affectedRows.first,
+              let scope = coordinator.scope(for: tab),
+              let row = model.row(at: firstDisplayIndex) else { return nil }
+        let tableRows = model.rows
+        guard !tableRows.columns.isEmpty else { return nil }
 
         return JSONRowSnapshot(
             rowIdentity: "\(tab.id.uuidString)\u{001F}\(row.id)",
@@ -128,36 +108,29 @@ extension MainContentView {
 
     // MARK: - Sidebar Edit State
 
-    /// Determine if sidebar should be in editable mode
     var isSidebarEditable: Bool {
         if gridSelectionOwner == .schemaGrid {
             return selectedInspectorRow?.isEditable ?? false
         }
-        guard gridSelectionOwner == .dataGrid,
+        guard let model = dataGridModel,
               let tab = coordinator.tabManager.selectedTab,
               tab.tabType == .table || tab.tableContext.tableName != nil,
               coordinator.canEditActiveResult,
-              !coordinator.selectionState.indices.isEmpty else {
+              !model.selection.isEmpty else {
             return false
         }
         return true
     }
 
     var isSelectedRowDeleted: Bool {
-        guard gridSelectionOwner == .dataGrid,
-              let tabId = coordinator.tabManager.selectedTab?.id,
-              let firstIndex = coordinator.selectionState.indices.min(),
-              let row = DisplayRowMapping.row(
-                  forDisplay: firstIndex,
-                  displayIDs: coordinator.activeGridDisplayIDs,
-                  in: coordinator.tabSessionRegistry.tableRows(for: tabId)
-              ) else { return false }
-        return coordinator.changeManager.isRowDeleted(row.id)
+        guard let model = dataGridModel,
+              let first = model.selection.affectedRows.first,
+              let rowID = model.rowID(at: first) else { return false }
+        return coordinator.changeManager.isRowDeleted(rowID)
     }
 
     // MARK: - Sort State Binding
 
-    /// Binding for the current tab's sort state
     var sortStateBinding: Binding<SortState> {
         Binding(
             get: {
@@ -176,12 +149,12 @@ extension MainContentView {
 
     // MARK: - Results View Mode Binding
 
-    /// Binding for resultsViewMode state
     var resultsViewModeBinding: Binding<ResultsViewMode> {
         Binding(
             get: { coordinator.tabManager.selectedTab?.display.resultsViewMode ?? .data },
             set: { newValue in
                 if let index = coordinator.tabManager.selectedTabIndex {
+                    coordinator.commitActiveGridEdit()
                     coordinator.tabManager.mutate(at: index) { $0.display.resultsViewMode = newValue }
                 }
             }
@@ -190,7 +163,6 @@ extension MainContentView {
 
     // MARK: - Current Tab Accessor
 
-    /// Current selected tab for convenience
     var currentTab: QueryTab? {
         coordinator.tabManager.selectedTab
     }
@@ -219,15 +191,14 @@ struct InspectorTrigger: Equatable {
 }
 
 enum InspectorValueDisplayFormatResolver {
-    /// The window keeps one grid coordinator, so it can still be pointed at the previously
-    /// selected tab. Its formats are only meaningful while it holds this tab's columns.
+    // The model's formats include a Display As the grid applied without a table to save it under.
     @MainActor
     static func activeFormats(
-        from grid: TableViewCoordinator?,
+        from model: DataGridModel?,
         matching columns: [String]
     ) -> [ValueDisplayFormat?]? {
-        guard let grid, grid.tableRowsProvider().columns == columns else { return nil }
-        return grid.columnDisplayFormats
+        guard let model, model.rows.columns == columns else { return nil }
+        return model.store.displayFormats
     }
 
     static func resolve(
@@ -249,8 +220,7 @@ enum InspectorValueDisplayFormatResolver {
     }
 }
 
-/// Lightweight equatable value combining all pending-change sources
-/// for consolidated toolbar badge onChange observation.
+// One value so a single `onChange` drives the toolbar badge across every pending-change source.
 struct PendingChangeTrigger: Equatable {
     let hasDataChanges: Bool
     let pendingTruncates: Set<DatabaseTreeTableRef>
@@ -261,9 +231,7 @@ struct PendingChangeTrigger: Equatable {
     var selectedTabId: UUID?
     let isFileDirty: Bool
     let hasCreateTablePending: Bool
-    /// The fifth source. Without it staging a principal edit changes nothing this value can see, so
-    /// `updateToolbarPendingState()` is never re-run and the commit control stays dim however many
-    /// changes the Users & Roles tab holds.
+    // Without it a staged principal edit never re-runs `updateToolbarPendingState()`, so the commit control stays dim.
     let hasPrincipalChanges: Bool
     let hasTypeChanges: Bool
 }
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentView+EventHandlers.swift b/apple/TablePro/Views/Main/Extensions/MainContentView+EventHandlers.swift
index ce0aebb503..e7c1f83bff 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentView+EventHandlers.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentView+EventHandlers.swift
@@ -2,9 +2,6 @@
 //  MainContentView+EventHandlers.swift
 //  TablePro
 //
-//  Extension containing event handler methods for MainContentView.
-//  Extracted to reduce main view complexity.
-//
 
 import os
 import SwiftUI
@@ -29,9 +26,7 @@ extension MainContentView {
         updateWindowTitleAndFileState()
         let t2 = Date()
 
-        /// A tab selection change in a background window is usually a side effect rather than
-        /// navigation, a close refocusing its neighbour above all, and that window re-marks its own
-        /// object tree the moment it becomes key.
+        // In a background window this is usually a side effect (a close refocusing a neighbour); it re-marks once it is key.
         if coordinator.isKeyWindow {
             coordinator.syncSidebarObjectSelection()
         }
@@ -72,7 +67,7 @@ extension MainContentView {
     }
 
     func handleColumnsChange(newColumns: [String]?) {
-        // Skip during tab switch — handleTabChange already configures the change manager
+        // Skip during tab switch: handleTabChange already configures the change manager
         guard !coordinator.isHandlingTabSwitch else { return }
 
         if let newColumns = newColumns {
@@ -140,7 +135,7 @@ extension MainContentView {
         case .skip:
             return
         case .reuseActiveTab:
-            coordinator.selectionState.indices = []
+            coordinator.selectedTabGridModel?.clearSelection()
             coordinator.openTableTab(table, schema: ref.qualifyingSchema)
         case .openNewTab:
             coordinator.openTableTab(table, schema: ref.qualifyingSchema)
@@ -150,9 +145,7 @@ extension MainContentView {
     // MARK: - Sidebar Edit Handling
 
     func updateSidebarEditState() {
-        /// A selection change, a refresh or an undo rebuilds the fields under whatever was being
-        /// typed, so the run it was building ends here rather than folding the next keystroke into
-        /// a step that belongs to another row.
+        // A selection change, refresh or undo rebuilds the fields, so the typed run ends here, not in another row's step.
         coordinator.endInspectorEditRun()
         switch gridSelectionOwner {
         case .schemaGrid:
@@ -165,19 +158,15 @@ extension MainContentView {
             break
         }
 
-        let selectedIndices = coordinator.selectionState.indices
         guard let tab = coordinator.tabManager.selectedTab,
-            !selectedIndices.isEmpty
+              let model = coordinator.activeGridModel,
+              !model.selection.isEmpty
         else {
             clearSidebarEditState()
             return
         }
-        let tableRows = coordinator.tabSessionRegistry.tableRows(for: tab.id)
-
-        let displayIDs = coordinator.activeGridDisplayIDs
-        let selectedRows = selectedIndices.sorted().compactMap {
-            DisplayRowMapping.row(forDisplay: $0, displayIDs: displayIDs, in: tableRows)
-        }
+        let tableRows = model.rows
+        let selectedRows = model.selection.affectedRows.compactMap { model.row(at: $0) }
         let allRows = selectedRows.map { Array($0.values) }
 
         let columnTypes = tableRows.columnTypes.indices.compactMap { tableRows.editingColumnType(at: $0) }
@@ -204,7 +193,6 @@ extension MainContentView {
             }
         }
         trailingPaneState.inspector.editState.configure(
-            selectedRowIndices: selectedIndices,
             rowIDs: selectedRows.map(\.id),
             allRows: stringRows,
             absentCells: selectedRows.map(\.absentColumns),
@@ -266,8 +254,7 @@ extension MainContentView {
             capturedCoordinator.stageInspectorFieldRemoval(columnIndex: columnIndex, rowIDs: rowIDs)
         }
         trailingPaneState.inspector.editState.onDetachedFieldChanged = { columnIndex, newValue, rowIDs, isExpression in
-            /// A value window commits on every keystroke exactly as the field it detached from
-            /// does, so its typing folds into one undo step the same way.
+            // A value window commits per keystroke like its field, so its typing folds into one undo step the same way.
             capturedCoordinator.rowEditingCoordinator.stageInspectorFieldEdit(
                 columnIndex: columnIndex,
                 value: newValue,
@@ -278,13 +265,7 @@ extension MainContentView {
         }
     }
 
-    /// The per-column display formats the grid is applying, in column order.
-    ///
-    /// The inspector had no idea these existed: its values came from a raw pass that decoded bytes
-    /// with `isoLatin1` and passed text straight through, while the dead tuple path beside it
-    /// computed formatted values nothing displayed. Only the editor choice is taken from the
-    /// format; the value stays raw, because a save writes what the editor holds and a formatted
-    /// timestamp written back into an integer column would corrupt it.
+    // Only the editor comes from the format; the value stays raw, since a formatted timestamp saved back would corrupt it.
     private func inspectorDisplayFormats(
         for tab: QueryTab,
         columns: [String],
@@ -294,7 +275,7 @@ extension MainContentView {
         let scope = tab.tableContext.scope(connectionId: coordinator.connection.id)
         let storageKeys = ValueDisplayFormatColumnKey.storageKeys(for: columns)
         let activeFormats = InspectorValueDisplayFormatResolver.activeFormats(
-            from: coordinator.dataTabDelegate?.tableViewCoordinator,
+            from: coordinator.existingGridModel(forTab: tab.id),
             matching: columns
         )
         let storedFormats = activeFormats == nil
@@ -308,10 +289,7 @@ extension MainContentView {
                 columnType: index < types.count ? types[index] : nil,
                 databaseType: coordinator.connection.type
             )
-            /// `.raw` is what the resolver returns for "nobody chose a format", and it is also what
-            /// `FieldEditorResolver` reads as "skip JSON, PHP and image detection". Forwarding it
-            /// would take the content-driven editors away from every column that has no override,
-            /// which is nearly all of them, so absence stays nil.
+            // FieldEditorResolver also reads .raw as skip JSON, PHP and image detection, so no override stays nil.
             return resolved == .raw ? nil : resolved
         }
     }
@@ -330,11 +308,9 @@ extension MainContentView {
         trailingPaneState.inspector.editState.onDetachedFieldChanged = nil
     }
 
-    /// Populate the inspector from the grid that owns a schema selection, and send every
-    /// edit back to it so a change lands in its change manager exactly as an inline
-    /// grid edit does, with one undo step and one pending change.
+    // Edits go back to the owning grid so they land in its change manager with one undo step, like an inline edit.
     private func updateSchemaSidebarEditState() {
-        guard let displayRow = coordinator.selectionState.indices.min(),
+        guard let displayRow = coordinator.activeGridModel?.selection.affectedRows.first,
             let row = selectedInspectorRow
         else {
             clearSidebarEditState()
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift b/apple/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift
index 73c5f50ffc..4885f746c6 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift
@@ -12,14 +12,7 @@ import TableProPluginKit
 extension MainContentView {
     // MARK: - Helper Methods
 
-    /// What the Table Info load waits for, so it runs again once each of them moves.
-    ///
-    /// The load waits for the tab's rows. Without `hasRows`, a table tab that had just opened ran the
-    /// load before they arrived and never again, so the panel showed no numbers until the inspector
-    /// left the screen and came back. Whether rows arrived, not when: a page, a sort or a filter
-    /// runs the query again without changing the size or the row count, and a read per page would
-    /// count up to 100,001 rows on SQLite and run `collStats` on MongoDB each time. The whole
-    /// identity, not the name, because `tenant_a.orders` and `tenant_b.orders` are two tables.
+    // Keys on whether rows arrived, not when: a read per page would count up to 100,001 SQLite rows or run MongoDB `collStats`.
     struct TableInfoTaskKey: Hashable {
         let tabId: UUID
         let table: TableTabIdentity?
@@ -54,9 +47,7 @@ extension MainContentView {
         toolbarState.syncFromSession(for: connection)
     }
 
-    /// The banner appears without the user doing anything and macOS has no live region for it, so VoiceOver
-    /// hears it only through an announcement. Every window on the session shows the banner, and announcements
-    /// are app-wide, so only the key window speaks.
+    // macOS has no live region for the banner, so it is announced; announcements are app-wide, so only the key window speaks.
     func announceConnectionWarning(_ warning: String?) {
         guard let warning, coordinator.isKeyWindow else { return }
         AccessibilityAnnouncement.post(
@@ -110,8 +101,7 @@ extension MainContentView {
         updateAssistantContext()
     }
 
-    /// Built only once the assistant exists. The grid summary is for the chat, and a window whose
-    /// assistant was never revealed has nothing to tell.
+    // The grid summary is for the chat, so a window whose assistant was never revealed builds nothing.
     func updateAssistantContext() {
         guard trailingPaneState.assistant.isActivated else { return }
         let snapshot = coordinator.assistantEditorSnapshot
@@ -122,15 +112,12 @@ extension MainContentView {
         )
     }
 
-    /// Nil on a tab that has no table of its own. Read from the entry cached for this tab: a single
-    /// latest-wins slot showed a query tab, a dashboard, or a table of the same name in another
-    /// database the numbers of whichever table had loaded last.
+    // Per-tab cache: a single latest-wins slot showed whichever table loaded last, even on a query tab or another database.
     var tableMetadataForCurrentTab: TableMetadata? {
         currentTab.flatMap { coordinator.currentTableMetadata(for: $0) }
     }
 
-    /// The scope a structure row's type picker looks types up in: the tab's own database and
-    /// schema, never the sidebar's, because a tab bound to another database edits that one.
+    // The tab's own database and schema, never the sidebar's: a tab bound to another database edits that one.
     private var structureTypeScope: DatabaseScope? {
         guard let tab = currentTab, tab.tabType == .table || tab.tabType == .createTable else { return nil }
         let database = tab.tableContext.databaseName ?? coordinator.browseDatabaseName
@@ -197,36 +184,58 @@ extension MainContentView {
 // The inspector shows one row's values, so it loads that row's unloaded values while it is on screen.
 internal struct InspectorValueLoadModifier: ViewModifier {
     @ObservedObject var inspector: RowInspectorState
-    @ObservedObject var selection: GridSelectionState
+    let model: DataGridModel?
     let tabId: UUID?
-    let selectsDataRows: Bool
     let contentVersion: Int
-    let load: (UUID, Int) async -> Void
+    let load: (UUID, RowID) async -> Void
 
     func body(content: Content) -> some View {
-        content.task(id: key) {
-            guard let key else { return }
-            await load(key.tabId, key.displayRow)
+        content.background {
+            if let model, let tabId {
+                InspectorValueLoader(
+                    model: model,
+                    isOnScreen: inspector.isOnScreen,
+                    tabId: tabId,
+                    contentVersion: contentVersion,
+                    load: load
+                )
+            }
         }
     }
+}
+
+// Observes the grid model here, so a selection change redraws this and not the window's content view.
+private struct InspectorValueLoader: View {
+    @ObservedObject var model: DataGridModel
+    let isOnScreen: Bool
+    let tabId: UUID
+    let contentVersion: Int
+    let load: (UUID, RowID) async -> Void
+
+    var body: some View {
+        Color.clear
+            .frame(width: 0, height: 0)
+            .accessibilityHidden(true)
+            .task(id: key) {
+                guard let key else { return }
+                await load(key.tabId, key.rowID)
+            }
+    }
 
     private var key: Key? {
-        guard inspector.isOnScreen, selectsDataRows, let tabId, selection.indices.count == 1,
-              let displayRow = selection.indices.first else { return nil }
-        return Key(tabId: tabId, displayRow: displayRow, contentVersion: contentVersion)
+        guard isOnScreen, model.selection.affectedRows.count == 1,
+              let rowID = model.selectedRowIDs.first else { return nil }
+        return Key(tabId: tabId, rowID: rowID, contentVersion: contentVersion)
     }
 
     struct Key: Hashable {
         let tabId: UUID
-        let displayRow: Int
+        let rowID: RowID
         let contentVersion: Int
     }
 }
 
-/// Runs the Table Info load where the inspector's on-screen state is observed.
-///
-/// `MainContentView` does not observe the inspector, whose context changes on every selection, so a
-/// key built in its body never saw `isOnScreen` move. Observed here, only this modifier redraws.
+// `MainContentView` does not observe the inspector, so a key built in its body never saw `isOnScreen` move.
 internal struct TableInfoLoadModifier: ViewModifier {
     @ObservedObject var inspector: RowInspectorState
     let tab: QueryTab?
diff --git a/apple/TablePro/Views/Main/Extensions/MainContentView+Setup.swift b/apple/TablePro/Views/Main/Extensions/MainContentView+Setup.swift
index 9b7d3f2f60..6d1c4b77d1 100644
--- a/apple/TablePro/Views/Main/Extensions/MainContentView+Setup.swift
+++ b/apple/TablePro/Views/Main/Extensions/MainContentView+Setup.swift
@@ -40,7 +40,7 @@ extension MainContentView {
         if payload == nil || payload?.intent == .restoreOrDefault {
             await coordinator.restoreSavedTabs()
         }
-        /// Before the schema load, which can take seconds, so a move waiting on the restore lands now.
+        // Before the schema load, which can take seconds, so a move waiting on the restore lands now.
         coordinator.settleTabRestore()
         _ = await schemaLoad
     }
@@ -74,10 +74,7 @@ extension MainContentView {
 
     // MARK: - Command Actions Setup
 
-    /// One resolution of what is staged, so the commit control, its verb and Preview SQL's gate
-    /// cannot disagree. The arm this replaces never read `hasPrincipalChanges`, so a Users & Roles
-    /// tab with staged principals left both the toolbar's commit button and Cmd+S dim over work
-    /// `saveChanges()` already knew how to apply.
+    // One resolution of what is staged, so commit, its verb and Preview SQL agree; staged principals once left Cmd+S dim.
     func updateToolbarPendingState() {
         let kind = PendingChangeKind.resolve(
             tabType: tabManager.selectedTab?.tabType,
@@ -90,18 +87,11 @@ extension MainContentView {
         )
         toolbarState.pendingChange = kind
         toolbarState.hasPendingChanges = kind != nil
-        /// Preview SQL asks a narrower question than the commit control: a dirty query file and
-        /// staged principals both raise the commit and neither has grid SQL to show.
+        // Narrower than the commit: a dirty query file and staged principals raise the commit but have no grid SQL to show.
         toolbarState.hasDataPendingChanges = kind == .data || kind == .structure
     }
 
-    /// Update window title, proxy icon, and dirty dot based on the selected tab.
-    ///
-    /// This tree is the browse content, so it names the window as the browse content: `.content`
-    /// and `.browse` are what it is, not guesses. Whether it is the tree on screen is the window's
-    /// question, and its bindings drop a name or a file written from behind an agent conversation.
-    /// The edited dot is still written directly, because the unsaved work it reports is still in
-    /// the window while the conversation is drawn over it.
+    // The edited dot is written directly: the unsaved work it reports stays in the window under an agent conversation.
     func updateWindowTitleAndFileState() {
         let selectedTab = tabManager.selectedTab
         let resolved = WindowTitleResolver.resolveWindow(
@@ -123,7 +113,7 @@ extension MainContentView {
         viewWindow?.isDocumentEdited = selectedTab.map(coordinator.showsUnsavedIndicator) ?? false
     }
 
-    /// Configure the hosting NSWindow — called by WindowAccessor when the window is available.
+    // Called by WindowAccessor once the window exists.
     func configureWindow(_ window: NSWindow) {
         let start = Date()
         MainContentView.lifecycleLogger.info(
@@ -159,14 +149,11 @@ extension MainContentView {
     }
 
     func setupCommandActions() {
-        /// Called from `onAppear`, which a connection switch fires again. Building a second set of
-        /// actions left the hidden trailing pane holding the first, so every refresh and connect
-        /// broadcast was handled twice, and both trailing panes were rebuilt on every switch.
+        // `onAppear` refires on a connection switch; a second set of actions handled every broadcast twice and rebuilt both panes.
         guard commandActions == nil else { return }
         let actions = MainContentCommandActions(
             coordinator: coordinator,
             connection: connection,
-            selectionState: coordinator.selectionState,
             selectedTables: Binding(
                 get: { coordinator.windowSidebarState.selectedTables },
                 set: { coordinator.windowSidebarState.selectTables($0) }
diff --git a/apple/TablePro/Views/Main/MainContentCommandActions+BulkClose.swift b/apple/TablePro/Views/Main/MainContentCommandActions+BulkClose.swift
index 1204f69f88..daf9947399 100644
--- a/apple/TablePro/Views/Main/MainContentCommandActions+BulkClose.swift
+++ b/apple/TablePro/Views/Main/MainContentCommandActions+BulkClose.swift
@@ -9,8 +9,7 @@ import Foundation
 extension MainContentCommandActions {
     enum BatchCloseKind: Equatable {
         case all
-        /// Anchored explicitly, because a contextual menu acts on the tab under the pointer and
-        /// that is not always the selected one.
+        // Explicit: a contextual menu acts on the tab under the pointer, which is not always the selected one.
         case others(anchor: UUID)
         case otherDatabases
     }
@@ -50,8 +49,7 @@ extension MainContentCommandActions {
         return !tabsToClose(kind: .otherDatabases).isEmpty
     }
 
-    /// The entry this window shows, named the way this engine names containers. Comparing a
-    /// schema-switching engine's tabs against a database name classified nothing.
+    // Named the engine's way: a schema-switching engine's tabs compared against a database name classified nothing.
     var shownContainerName: String {
         coordinator?.tabManager.visibleContainer ?? coordinator?.browseCursorCoordinator.browsedContainer ?? ""
     }
@@ -63,11 +61,7 @@ extension MainContentCommandActions {
         )
     }
 
-    /// Tabs live in one window now, so a batch close is a list edit rather than a walk over
-    /// sibling windows. Closing every tab is still a window close, which already owns the save
-    /// prompt and the recovery capture, so that case is handed straight to it.
-    /// Closing every tab leaves the connection on its empty state rather than closing the window,
-    /// because the window is no longer this connection's window: it hosts all of them.
+    // A list edit, not a window close: the window hosts every connection, so closing all tabs leaves this one empty.
     private func runBatchClose(kind: BatchCloseKind) async {
         guard let coordinator else { return }
         let victims = tabsToClose(kind: kind)
@@ -78,25 +72,16 @@ extension MainContentCommandActions {
         coordinator.closeTabsByUser(ids: victims.map(\.id).filter { closable.contains($0) && unpinned.contains($0) })
     }
 
-    /// What a close should do about the work it is going to destroy.
     internal enum UnsavedWorkOutcome: Equatable {
         case cancel
-        /// The ids that may now be closed. Save leaves out any victim it could not actually save.
+        // Save leaves out any victim it could not actually save.
         case close(Set<UUID>)
     }
 
-    /// A partial close leaves the window open, so it cannot lean on the window's own prompt.
-    /// The question is asked once for the batch rather than once per tab, which is also what keeps
-    /// the sheets from queueing: `NSWindow.beginSheet` queues a second sheet behind the first rather
-    /// than presenting it, so N prompts would be answered one at a time with no way to see why.
-    ///
-    /// Save goes on to close. It used to save and then return false, which left the batch standing
-    /// after a successful save and made Save mean "cancel" on this path while it meant "close" on
-    /// the window path. And it used to run `saveSelectedTabWork()` whatever the victims were, so on
-    /// Close Other Tabs and Close Tabs for Other Databases, where the selected tab is never a
-    /// victim, Save wrote a bystander's changes and the close destroyed the victims' own.
+    // One prompt for the batch: NSWindow.beginSheet queues a second sheet behind the first instead of presenting it.
     internal func resolveUnsavedWork(in victims: [QueryTab]) async -> UnsavedWorkOutcome {
         let everything = Set(victims.map(\.id))
+        coordinator?.commitActiveGridEdit()
         guard hasUnsavedWork(among: victims) else { return .close(everything) }
 
         switch await confirmSaveChanges(unsavedWorkMessage(for: victims), closeAnchorWindow) {
@@ -109,9 +94,7 @@ extension MainContentCommandActions {
         }
     }
 
-    /// Save cannot reach a tab that is not on screen for grid edits, staged principals or a table
-    /// draft, so the alert says what will happen to those rather than promising a save it cannot
-    /// make: they stay open, and everything else closes.
+    // Save cannot reach off-screen grid edits, staged principals or table drafts; those tabs stay open and the alert says so.
     private func unsavedWorkMessage(for victims: [QueryTab]) -> String {
         guard let coordinator,
               victims.contains(where: { coordinator.savability(of: $0) == .mountedOnly })
@@ -126,13 +109,7 @@ extension MainContentCommandActions {
         )
     }
 
-    /// Saves each victim through the path that can reach it, and answers with the ones that are now
-    /// safe to close.
-    ///
-    /// A victim it cannot save keeps its tab: closing it would be the data loss the prompt exists to
-    /// prevent. That includes a file whose copy on disk changed underneath it, because the conflict
-    /// sheet is one window-level slot with no queue, and a second victim's conflict would overwrite
-    /// the first while both tabs closed behind it.
+    // A victim it cannot save keeps its tab, a file conflict too: the conflict sheet is one window-level slot with no queue.
     private func saveVictims(_ victims: [QueryTab]) async -> Set<UUID> {
         guard let coordinator else { return Set(victims.map(\.id)) }
         guard await applyStagedStructureEdits(in: victims) else { return [] }
@@ -161,14 +138,7 @@ extension MainContentCommandActions {
         return closable
     }
 
-    /// The pane on screen, saved through the one path that reaches all of it.
-    ///
-    /// Not every kind of unsaved work belongs to a tab: a staged TRUNCATE and an edit in the row
-    /// inspector belong to the connection, `savability` deliberately leaves them out, and
-    /// `saveSelectedTabWork` is the only thing that applies them. Skipping it because the selected
-    /// tab's own work looked clean is how Save came to close a connection with a staged TRUNCATE
-    /// still staged. An empty victim list is the whole connection, which is what the window-close
-    /// and disconnect paths ask about, and it goes through here too.
+    // Always runs: a staged TRUNCATE and inspector edits belong to the connection, and only saveSelectedTabWork applies them.
     private func saveWorkOnScreen(among victims: [QueryTab]) async -> Bool {
         guard let coordinator else { return true }
         let selected = coordinator.tabManager.selectedTab
@@ -177,18 +147,7 @@ extension MainContentCommandActions {
         return await saveSelectedTabWork()
     }
 
-    /// What the batch is about to destroy, not what the connection happens to hold.
-    ///
-    /// A close that names its victims used to be judged by `hasUnsavedWorkInConnection`, which walks
-    /// every tab of the connection: closing one database's tabs while another database had a dirty
-    /// one asked the user to save work the command was not going to touch, and Save then ran
-    /// `saveSelectedTabWork()` on whatever tab was selected, which could be that other database's.
-    /// An empty victim list still means the whole connection, which is what the window-close and
-    /// disconnect paths ask about.
-    ///
-    /// The connection-wide flags ride with the selected tab. The row inspector's edits and the
-    /// pending truncates and drops belong to the pane on screen, so they count exactly when that
-    /// pane's tab is one of the victims.
+    // Victims only (empty means the whole connection); connection-wide flags count only when the on-screen tab is a victim.
     func hasUnsavedWork(among victims: [QueryTab]) -> Bool {
         guard let coordinator, !victims.isEmpty else { return hasUnsavedWorkInConnection }
         if victims.contains(where: { coordinator.hasUnsavedWork(in: $0) }) { return true }
@@ -196,10 +155,7 @@ extension MainContentCommandActions {
         return coordinator.hasSidebarEdits || coordinator.hasPendingDestructiveTableOps
     }
 
-    /// Close All and Close Other Tabs act on the strip, which lists one entry: a close never takes
-    /// tabs the user cannot see. Close Tabs for Other Databases is the one that reaches behind the
-    /// other entries, and it takes every tab there, an empty one too, since each would keep its
-    /// entry listed. None of the three takes a pinned tab.
+    // Close All and Close Others act on the visible entry; Other Databases reaches every other entry, empty tabs too.
     private func tabsToClose(kind: BatchCloseKind) -> [QueryTab] {
         guard let coordinator else { return [] }
         let manager = coordinator.tabManager
@@ -211,9 +167,7 @@ extension MainContentCommandActions {
             return manager.visibleTabs.filter { $0.id != anchor && !$0.isPinned }
         case .otherDatabases:
             let current = shownContainerName
-            /// A tab that cannot name its container is not in another one, it is in every one, and
-            /// `containerName` returning nil compared against a non-optional name made every such
-            /// tab foreign.
+            // A tab with no container name is in every container, not another one; nil compared to a name made it foreign.
             return manager.tabs.filter { tab in
                 guard !tab.isPinned, let name = manager.containerName(of: tab) else { return false }
                 return name != current
diff --git a/apple/TablePro/Views/Main/MainContentCommandActions+Documents.swift b/apple/TablePro/Views/Main/MainContentCommandActions+Documents.swift
index 63343c5163..f97b9b60c1 100644
--- a/apple/TablePro/Views/Main/MainContentCommandActions+Documents.swift
+++ b/apple/TablePro/Views/Main/MainContentCommandActions+Documents.swift
@@ -15,13 +15,13 @@ extension MainContentCommandActions {
     }
 
     func editDocument() {
-        guard let displayRow = singleSelectedDataGridRow,
-              let locator = coordinator?.documentLocator(forDisplayRow: displayRow) else { return }
+        guard let rowID = singleSelectedDataGridRowID,
+              let locator = coordinator?.documentLocator(for: rowID) else { return }
         coordinator?.presentEditDocument(locator: locator)
     }
 
     var canEditDocument: Bool {
-        guard let displayRow = singleSelectedDataGridRow else { return false }
-        return coordinator?.canEditDocument(atDisplayRow: displayRow) ?? false
+        guard let rowID = singleSelectedDataGridRowID else { return false }
+        return coordinator?.canEditDocument(rowID: rowID) ?? false
     }
 }
diff --git a/apple/TablePro/Views/Main/MainContentCommandActions+PanelVisibility.swift b/apple/TablePro/Views/Main/MainContentCommandActions+PanelVisibility.swift
index 44086fee18..52fdee2c75 100644
--- a/apple/TablePro/Views/Main/MainContentCommandActions+PanelVisibility.swift
+++ b/apple/TablePro/Views/Main/MainContentCommandActions+PanelVisibility.swift
@@ -6,8 +6,7 @@
 import Foundation
 import TableProPluginKit
 
-/// Read-side of the panel toggles. Each one reads the same state its `toggle` writes,
-/// so the menu title describes what the command will actually do.
+// Each reads the state its toggle writes, so the menu title matches what the command does.
 extension MainContentCommandActions {
     var isFilterBarVisible: Bool {
         guard let coordinator, let index = coordinator.tabManager.selectedTabIndex else { return false }
@@ -25,19 +24,13 @@ extension MainContentCommandActions {
     }
 }
 
-/// The result's view mode, which the results header switches and the View menu mirrors.
-///
-/// The switcher used to be the only route to JSON and Chart mode, so those views were reachable by
-/// mouse alone. A menu command is also what the HIG asks of any control that is not in the menu bar.
+// The switcher was the only route to JSON and Chart; the HIG wants a menu command for any control not in the menu bar.
 extension MainContentCommandActions {
     var resultsViewMode: ResultsViewMode? {
         coordinator?.tabManager.selectedTab?.display.resultsViewMode
     }
 
-    /// Recomputed here rather than read off the status bar's snapshot, because the View menu has
-    /// to validate while no status bar is on screen. Both call sites take the same inputs, the
-    /// tab's own geometry columns included, so the menu and the switcher can never disagree about
-    /// whether Map is offered.
+    // Recomputed, not read from the status bar: the View menu validates while no status bar is on screen.
     var availableResultsViewModes: [ResultsViewMode] {
         guard let coordinator, let tab = coordinator.tabManager.selectedTab else { return [] }
         let tableRows = coordinator.tabSessionRegistry.existingTableRows(for: tab.id)
@@ -53,6 +46,7 @@ extension MainContentCommandActions {
     func setResultsViewMode(_ mode: ResultsViewMode) {
         guard let coordinator, let tabId = coordinator.tabManager.selectedTab?.id else { return }
         guard availableResultsViewModes.contains(mode) else { return }
+        coordinator.commitActiveGridEdit()
         coordinator.tabManager.mutate(tabId: tabId) { $0.display.resultsViewMode = mode }
     }
 }
diff --git a/apple/TablePro/Views/Main/MainContentCommandActions.swift b/apple/TablePro/Views/Main/MainContentCommandActions.swift
index 2692c0e247..a58475ef42 100644
--- a/apple/TablePro/Views/Main/MainContentCommandActions.swift
+++ b/apple/TablePro/Views/Main/MainContentCommandActions.swift
@@ -2,10 +2,6 @@
 //  MainContentCommandActions.swift
 //  TablePro
 //
-//  Provides command actions for MainContentView, reached through MainContentCoordinator.
-//  Menu commands and toolbar buttons call methods directly instead of posting notifications.
-//  Retains NotificationCenter subscribers only for legitimate multi-listener broadcasts.
-//
 
 import AppKit
 import Combine
@@ -17,7 +13,7 @@ import TableProSQLGrammar
 import TableProUtilities
 import UniformTypeIdentifiers
 
-/// Provides command actions for MainContentView, reached through `MainContentCoordinator.commandActions`.
+// Menu and toolbar commands call methods directly; NotificationCenter stays only for multi-listener broadcasts.
 @MainActor
 final class MainContentCommandActions: ObservableObject {
     nonisolated private static let logger = Logger(subsystem: "com.TablePro", category: "MainContentCommandActions")
@@ -37,14 +33,12 @@ final class MainContentCommandActions: ObservableObject {
 
     // MARK: - Bindings
 
-    private let selectionState: GridSelectionState
     private let selectedTables: Binding<Set<DatabaseTreeTableRef>>
     private let pendingTruncates: Binding<Set<DatabaseTreeTableRef>>
     private let pendingDeletes: Binding<Set<DatabaseTreeTableRef>>
     private let tableOperationOptions: Binding<[DatabaseTreeTableRef: TableOperationOptions]>
     private let trailingPaneState: TrailingPaneState
 
-    /// The window this instance belongs to — used for key-window guards.
     weak var window: NSWindow? {
         didSet {
             guard window !== oldValue else { return }
@@ -54,24 +48,20 @@ final class MainContentCommandActions: ObservableObject {
 
     // MARK: - State
 
-    /// Whether a text input holds first responder in this instance's window.
-    /// Stored rather than computed so Observation wakes the menu when focus
-    /// crosses that boundary; `NSWindow.firstResponder` publishes no change.
+    // Stored, not computed: NSWindow.firstResponder publishes no change, so Observation could not wake the menu.
     @Published var focusOwnsTextInput = false
 
     let textInputFocusObserver = OSAllocatedUnfairLock<(any NSObjectProtocol)?>(uncheckedState: nil)
 
     var isTextInputFocusCheckScheduled = false
 
-    /// Asks whether to save a tab being closed. The alert by default, a scripted answer in a test.
+    // A var so a test can script the answer instead of showing the alert.
     var confirmSaveChanges: (String, NSWindow?) async -> AlertHelper.SaveConfirmationResult = { message, window in
         await AlertHelper.confirmSaveChanges(message: message, window: window)
     }
 
-    /// Task handles for async notification observers; cancelled on deinit.
     private var notificationTasks: [Task<Void, Never>] = []
 
-    /// Combine subscriptions for typed AppEvents publishers.
     private var eventCancellables: Set<AnyCancellable> = []
 
     // MARK: - Initialization
@@ -79,7 +69,6 @@ final class MainContentCommandActions: ObservableObject {
     init(
         coordinator: MainContentCoordinator,
         connection: DatabaseConnection,
-        selectionState: GridSelectionState,
         selectedTables: Binding<Set<DatabaseTreeTableRef>>,
         pendingTruncates: Binding<Set<DatabaseTreeTableRef>>,
         pendingDeletes: Binding<Set<DatabaseTreeTableRef>>,
@@ -88,7 +77,6 @@ final class MainContentCommandActions: ObservableObject {
     ) {
         self.coordinator = coordinator
         self.connection = connection
-        self.selectionState = selectionState
         self.selectedTables = selectedTables
         self.pendingTruncates = pendingTruncates
         self.pendingDeletes = pendingDeletes
@@ -109,8 +97,6 @@ final class MainContentCommandActions: ObservableObject {
 
     // MARK: - Async Notification Helper
 
-    /// Creates a Task that iterates an async notification sequence and calls the handler.
-    /// The task is stored for cancellation on deinit.
     private func observe(
         _ name: Notification.Name,
         handler: @escaping @MainActor (Notification) -> Void
@@ -124,16 +110,13 @@ final class MainContentCommandActions: ObservableObject {
         notificationTasks.append(task)
     }
 
-    /// The window being key is no longer enough: every connection it hosts shares that window, so
-    /// a broadcast gated on it alone ran once per connection and opened a file in all of them.
-    /// Only the connection on screen answers.
+    // Key window alone is not enough: every connection shares it, so a broadcast opened a file in all of them.
     private func isVisibleInKeyWindow() -> Bool {
         guard let window = self.window, window.isKeyWindow else { return false }
         guard let host = window.contentViewController as? MainSplitViewController else { return true }
         return host.workspaces.selected?.sessionState?.coordinator === coordinator
     }
 
-    /// Like `observe(_:handler:)` but only runs the handler when this instance's window is key.
     private func observeKeyWindowOnly(
         _ name: Notification.Name,
         handler: @escaping @MainActor (Notification) -> Void
@@ -144,7 +127,6 @@ final class MainContentCommandActions: ObservableObject {
         }
     }
 
-    /// Subscribes to an `AppCommands` publisher and only runs the handler when this instance's window is key.
     private func observeKeyWindowOnly<Payload>(
         _ publisher: PassthroughSubject<Payload, Never>,
         handler: @escaping @MainActor (Payload) -> Void
@@ -156,11 +138,6 @@ final class MainContentCommandActions: ObservableObject {
 
     // MARK: - Save Action
 
-    /// Writes the inspector's pending edits.
-    ///
-    /// This used to be stored back on the panel's state as an `onSave` closure that only this type
-    /// ever set and only this type ever called; no view read it, despite a comment saying the panel
-    /// did. Calling the coordinator directly is the same work with one fewer hop.
     private func saveInspectorEdits() {
         let editState = trailingPaneState.inspector.editState
         Task { [weak self] in
@@ -191,13 +168,10 @@ final class MainContentCommandActions: ObservableObject {
         observeKeyWindowOnly(AppCommands.shared.exportQueryResults) { [weak self] _ in self?.exportQueryResults() }
     }
 
-    // MARK: - Row Operations (Group A — Called Directly)
+    // MARK: - Row Operations (Group A: Called Directly)
 
     func addNewRow() {
-        // The structure tab routes through StructureGridDelegate, which inserts
-        // a column / index / FK row depending on the active Structure sub-tab.
-        // The data tab routes through MainContentCoordinator.addNewRow which
-        // calls RowEditingCoordinator.addNewRow (data-only).
+        // Structure inserts a column, index or FK row by sub-tab; the data path adds data rows only.
         switch selectionOwner {
         case .schemaGrid: coordinator?.structureActions?.addRow?()
         case .dataGrid: coordinator?.addNewRow()
@@ -205,17 +179,13 @@ final class MainContentCommandActions: ObservableObject {
         }
     }
 
-    private func resolvedRowSelection() -> Set<Int> {
-        coordinator?.dataTabDelegate?.tableViewCoordinator?.currentRowSelection() ?? selectionState.indices
+    // The rows the data grid's model has selected, in display order; empty when another grid owns the selection.
+    private var selectedDataRowIDs: [RowID] {
+        guard dataGridOwnsSelection else { return [] }
+        return coordinator?.activeGridModel?.selectedRowIDs ?? []
     }
 
-    /// `selectionState` is shared with the structure and new-table grids, and nothing clears it when
-    /// the result mode changes, so its indices only mean something once this says whose grid they
-    /// came from. Every row command routes through it rather than re-deriving the answer.
-    ///
-    /// A Create Table tab publishes into the same channel but has no structure handler behind it,
-    /// so claiming ownership there would make its commands silently inert and would shadow the
-    /// table-deletion fallback the sidebar still needs. Ownership counts only where someone can act.
+    // A Create Table tab has no structure handler; claiming its selection would make commands inert and shadow sidebar delete.
     private var selectionOwner: GridSelectionOwner {
         let owner = GridSelectionOwner.resolve(
             tabType: coordinator?.tabManager.selectedTab?.tabType,
@@ -227,57 +197,49 @@ final class MainContentCommandActions: ObservableObject {
 
     private var dataGridOwnsSelection: Bool { selectionOwner == .dataGrid }
 
-    /// The display position of the one data-grid row a single-row command acts on, or nil when the
-    /// data grid does not own the selection or it holds other than one row.
-    var singleSelectedDataGridRow: Int? {
-        guard dataGridOwnsSelection else { return nil }
-        let indices = resolvedRowSelection()
-        guard indices.count == 1 else { return nil }
-        return indices.first
+    // The one data-grid row a single-row command acts on, or nil when the selection holds other than one row.
+    var singleSelectedDataGridRowID: RowID? {
+        let rowIDs = selectedDataRowIDs
+        guard rowIDs.count == 1 else { return nil }
+        return rowIDs.first
     }
 
-    func deleteSelectedRows(rowIndices: Set<Int>? = nil) {
-        let fromDataGrid = rowIndices != nil
-
+    func deleteSelectedRows() {
         if selectionOwner == .schemaGrid {
             coordinator?.structureActions?.removeRow?()
             return
         }
 
-        let indices = dataGridOwnsSelection ? (rowIndices ?? resolvedRowSelection()) : []
-        if !indices.isEmpty {
-            coordinator?.deleteSelectedRows(indices: indices)
-        } else if !fromDataGrid, !selectedTables.wrappedValue.isEmpty {
-            /// Through the sidebar's own path rather than a second copy of it. Staging the queue
-            /// here directly skipped the confirmation `batchToggleDelete` raises, so Delete from
-            /// the menu bar queued a drop with no dialog while the sidebar's Delete asked first.
+        let rowIDs = selectedDataRowIDs
+        if !rowIDs.isEmpty {
+            coordinator?.deleteRows(rowIDs)
+        } else if !selectedTables.wrappedValue.isEmpty {
+            // Through the sidebar's own path, which asks before it queues a drop.
             coordinator?.sidebarViewModel?.batchToggleDelete(refs: Array(selectedTables.wrappedValue))
         }
     }
 
     func duplicateRow() {
-        guard dataGridOwnsSelection else { return }
-        let indices = selectionState.indices
-        guard let selectedIndex = indices.first, indices.count == 1 else { return }
-        coordinator?.duplicateSelectedRow(index: selectedIndex)
+        guard let rowID = singleSelectedDataGridRowID else { return }
+        coordinator?.duplicateRow(rowID)
     }
 
     func copySelectedRows() {
         switch selectionOwner {
         case .schemaGrid: coordinator?.structureActions?.copyRows?()
-        case .dataGrid: coordinator?.copySelectedRowsToClipboard(indices: resolvedRowSelection())
+        case .dataGrid: coordinator?.copyRowsToClipboard(selectedDataRowIDs)
         case .none: break
         }
     }
 
     func copySelectedRowsWithHeaders() {
         guard dataGridOwnsSelection else { return }
-        coordinator?.copySelectedRowsWithHeaders(indices: resolvedRowSelection())
+        coordinator?.copyRowsToClipboard(selectedDataRowIDs, includeHeaders: true)
     }
 
     func copySelectedRowsAsJson() {
         guard dataGridOwnsSelection else { return }
-        coordinator?.copySelectedRowsAsJson(indices: resolvedRowSelection())
+        coordinator?.copyRowsAsJson(selectedDataRowIDs)
     }
 
     func pasteRows() {
@@ -290,14 +252,10 @@ final class MainContentCommandActions: ObservableObject {
 
     // MARK: - Per-Window State (replaces AppState.shared for menu enablement)
 
-    /// Answered by the window that owns this instance, because only its `ConnectionWindowPhase`
-    /// can tell a window that is dialing or has failed from one that is connected. This object
-    /// existing proves nothing: it is kept alive across a lost session so a reconnect can restore
-    /// the user's tabs.
+    // Only the window's ConnectionWindowPhase knows; this object outlives a lost session so a reconnect can restore tabs.
     var isConnected: Bool { coordinator?.splitViewController?.isConnected ?? false }
     var isQueryExecuting: Bool { coordinator?.isSelectedTabBusy ?? false }
-    /// Separate from `isQueryExecuting` because `Cmd+.` has to dim while a batch commits, which is
-    /// running work nothing can interrupt.
+    // Not isQueryExecuting: Cmd+. has to dim while a batch commits, which nothing can interrupt.
     var isQueryStoppable: Bool { coordinator?.isSelectedTabStoppable ?? false }
 
     var safeModeLevel: SafeModeLevel { coordinator?.toolbarState.safeModeLevel ?? connection.safeModeLevel }
@@ -316,8 +274,7 @@ final class MainContentCommandActions: ObservableObject {
 
     var connectionId: UUID { connection.id }
 
-    /// Whether Close has a tab to act on. With none, it ends the connection instead, and the menu
-    /// has to say so rather than offering to close a tab that is not there.
+    // With no tab, Close ends the connection, and the menu has to say so.
     var hasOpenTab: Bool { coordinator?.tabManager.selectedTab != nil }
 
     var browseDatabaseName: String { coordinator?.browseDatabaseName ?? "" }
@@ -328,8 +285,6 @@ final class MainContentCommandActions: ObservableObject {
         PluginManager.shared.supportsContainerSwitching(for: connection.type)
     }
 
-    /// An engine with no database dimension has nothing to favorite, and neither has a window whose
-    /// browse database is still empty.
     var canFavoriteActiveDatabase: Bool {
         PluginManager.shared.containerSwitchTarget(for: connection.type) == .database
             && !browseDatabaseName.isEmpty
@@ -360,10 +315,7 @@ final class MainContentCommandActions: ObservableObject {
         )
     }
 
-    /// Picks between the two spellings a container command has. Each one is a whole localized
-    /// string rather than a noun dropped into a format, because System Settings binds an App
-    /// Shortcut to a menu item's exact literal title, and because the driver's own entity name
-    /// would make the set open-ended. Both callers live in other files, so this is not private.
+    // Whole localized titles, not a format: System Settings binds an App Shortcut to a menu item's exact title.
     func containerSwitchTitle(schema: String, database: String) -> String {
         switch PluginManager.shared.containerSwitchTarget(for: currentDatabaseType) {
         case .schema: return schema
@@ -382,9 +334,7 @@ final class MainContentCommandActions: ObservableObject {
         PluginManager.shared.supportsDatabaseTree(for: connection.type)
     }
 
-    /// Whether the driver published any session context to switch. Only Snowflake does today, and
-    /// it pays two round trips for the list, so this reads what `loadSessionContexts` already
-    /// fetched rather than asking again.
+    // Reads what loadSessionContexts fetched: Snowflake (the only one today) pays two round trips for the list.
     var hasSessionContexts: Bool {
         !(coordinator?.sessionContexts.isEmpty ?? true)
     }
@@ -393,15 +343,13 @@ final class MainContentCommandActions: ObservableObject {
         PluginManager.shared.supportsSchemaSwitching(for: connection.type)
     }
 
-    /// Filtering the database list only means anything on a connection whose sidebar can show one,
-    /// which is the same rule the tree layout itself is gated on.
+    // Same rule the tree layout is gated on.
     var canFilterDatabases: Bool {
         PluginManager.shared.supportsDatabaseTree(for: connection.type)
             && sidebarLayout == .tree
     }
 
-    /// Asks the same question the sidebar banner does, so Show All Databases is never offered for a
-    /// filter that shows nothing on screen: one naming only system databases while they are hidden.
+    // Same check as the sidebar banner: no Show All Databases for a filter naming only hidden system databases.
     var hasDatabaseFilter: Bool {
         DatabaseTreeVisibility.isFiltering(
             selected: SharedSidebarState.forConnection(connection.id).databaseFilterSelected,
@@ -410,8 +358,7 @@ final class MainContentCommandActions: ObservableObject {
         )
     }
 
-    /// Every layout of an engine that lists tables per schema, because search, Open Quickly and the
-    /// pickers follow the filter even where the sidebar shows one schema.
+    // Not gated on layout: search, Open Quickly and the pickers follow the filter even where the sidebar shows one schema.
     var canFilterSchemas: Bool {
         DatabaseTreeMetadataService.listsTablesPerSchema(PluginManager.shared.databaseGroupingStrategy(for: connection.type))
     }
@@ -445,8 +392,7 @@ final class MainContentCommandActions: ObservableObject {
     }
 
 
-    /// Find and the filter panel act on the result grid, so they need a table tab that is showing
-    /// one. Chart mode is not, and neither is Structure, whose own grid has its own commands.
+    // Chart mode has no result grid, and Structure's grid has its own commands.
     var canUseTableResultCommands: Bool {
         guard coordinator?.toolbarState.isTableTab == true,
               let viewMode = coordinator?.tabManager.selectedTab?.display.resultsViewMode
@@ -456,23 +402,18 @@ final class MainContentCommandActions: ObservableObject {
         return viewMode.showsRowFilters
     }
 
+    // A query result's grid finds as a table's does; only a mounted grid has a bar to show.
     var canUseGridFindCommands: Bool {
-        guard coordinator?.toolbarState.isTableTab == true,
-              let viewMode = coordinator?.tabManager.selectedTab?.display.resultsViewMode
-        else {
-            return false
-        }
-        return viewMode.showsFindBar
+        guard let coordinator, let tab = coordinator.tabManager.selectedTab,
+              tab.tabType == .table || tab.tabType == .query,
+              tab.display.resultsViewMode.showsFindBar else { return false }
+        return coordinator.hasMountedDataGrid
     }
 
     var hasActiveGridFind: Bool {
-        guard canUseGridFindCommands,
-              let findState = coordinator?.tabManager.selectedTab?.findState else { return false }
-        return findState.isVisible && !findState.matches.isEmpty
+        canUseGridFindCommands && coordinator?.findCoordinator.hasActiveFind == true
     }
 
-    /// Jump to Column reads the mounted data grid, so it needs the grid on screen and a result that
-    /// names columns. A query's result counts as much as a table's: a wide result is a wide result.
     var canJumpToColumn: Bool {
         guard dataGridOwnsSelection,
               let coordinator,
@@ -483,9 +424,7 @@ final class MainContentCommandActions: ObservableObject {
         return !coordinator.columnsForVisibilityPicker(for: tab, resultColumns: resultColumns).isEmpty
     }
 
-    /// What `pasteRows()` will actually do, so the Edit menu's Paste item is enabled only when it
-    /// leads somewhere. AppKit gives a disabled item its key equivalent all the same, so an item
-    /// enabled over a handler that returns at its first guard swallows Command+V in silence.
+    // Mirrors pasteRows(): an item enabled over a handler that bails at its first guard swallows Command+V silently.
     var canPasteRows: Bool {
         guard !safeModeLevel.blocksAllWrites, let tab = coordinator?.tabManager.selectedTab else {
             return false
@@ -501,9 +440,7 @@ final class MainContentCommandActions: ObservableObject {
         }
     }
 
-    /// The two facts Save As and Export Results actually turn on. Their menu items used to be
-    /// validated on `isConnected` alone, so both stayed lit in states where the handler returns at
-    /// its first guard and the click does nothing at all.
+    // Save As and Export Results gate on this, not isConnected, which left them lit over a handler that did nothing.
     var isQueryTab: Bool {
         coordinator?.tabManager.selectedTab?.tabType == .query
     }
@@ -514,14 +451,12 @@ final class MainContentCommandActions: ObservableObject {
     }
 
     var hasRowSelection: Bool {
-        selectionOwner != .none && !resolvedRowSelection().isEmpty
+        selectionOwner != .none && coordinator?.activeGridModel?.selection.isEmpty == false
     }
 
-    /// Copy with headers and copy as JSON read the data grid's columns, so they are only meaningful
-    /// when the data grid owns the indices. The structure grid has its own plain copy and nothing
-    /// else; handing it these would read a structure row's position into the result rows.
+    // Structure grid indices are not result rows; copy with headers or as JSON would read the wrong rows.
     var hasDataGridRowSelection: Bool {
-        dataGridOwnsSelection && !resolvedRowSelection().isEmpty
+        !selectedDataRowIDs.isEmpty
     }
 
     var hasTableSelection: Bool {
@@ -536,16 +471,14 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.openJoinBuilder(seededWith: selectedTables.wrappedValue)
     }
 
-    /// A selection can be perfectly valid and still hold nothing truncatable, so the menu bar asks
-    /// this rather than `hasTableSelection`, which is what let it stage a `TRUNCATE` on a view.
+    // Not hasTableSelection, which let the menu bar stage a TRUNCATE on a view.
     var canTruncateSelectedTables: Bool {
         TableOperationEligibility.canTruncate(
             selectedTables.wrappedValue, context: tableOperationEligibility
         )
     }
 
-    /// The same question the sidebar's own Delete item asks, so the two agree. Without it the menu
-    /// bar offered Delete on an engine with no statement for it and the sidebar did not.
+    // Same check as the sidebar's Delete item, which the menu bar used to skip on engines with no statement for it.
     var canDropSelectedTables: Bool {
         TableOperationEligibility.canDrop(selectedTables.wrappedValue, context: tableOperationEligibility)
     }
@@ -560,18 +493,13 @@ final class MainContentCommandActions: ObservableObject {
         )
     }
 
-    /// The one selected object with the database and schema it lives in, or nil when the selection
-    /// is empty or spans several. A command that acts on the object takes this rather than the bare
-    /// `TableInfo`, which names no database, so it reaches the object the user selected even while
-    /// the browser points at another database or schema.
+    // Use over TableInfo, which names no database, so commands reach the selection while the browser points elsewhere.
     var selectedObjectRef: DatabaseTreeTableRef? {
         let selection = selectedTables.wrappedValue
         guard selection.count == 1 else { return nil }
         return selection.first
     }
 
-    /// The one selected object, or nil when the selection is empty or spans several.
-    /// Commands that open a single object need this rather than `hasTableSelection`.
     var selectedObject: TableInfo? {
         selectedObjectRef?.table
     }
@@ -580,30 +508,27 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.tabManager.selectedTab?.hasQueryText ?? false
     }
 
-    /// Whether there are pending data changes that the SQL preview can show.
-    /// Mirrors the toolbar Preview SQL button's enabled condition so the
-    /// menu shortcut (Cmd+Shift+P) doesn't open an empty preview popover.
+    // Mirrors the toolbar Preview SQL button so Cmd+Shift+P never opens an empty preview popover.
     var hasDataPendingChanges: Bool {
         coordinator?.toolbarState.hasDataPendingChanges ?? false
     }
 
-    /// Any pending changes (data edits OR file edits). Mirrors the toolbar
-    /// Save Changes button's enabled condition.
+    // Mirrors the toolbar Save Changes button's enabled condition.
     var hasPendingChanges: Bool {
         coordinator?.toolbarState.hasPendingChanges ?? false
     }
 
+    var hasOpenGridEdit: Bool {
+        coordinator?.isEditingActiveGrid == true
+    }
+
     var hasStructureChanges: Bool {
         coordinator?.toolbarState.hasStructureChanges ?? false
     }
 
     // MARK: - Unsaved Changes Check
 
-    /// Scoped to the whole window, not the selected tab: closing a window closes every tab in it,
-    /// so a tab the user is not looking at must still get its prompt.
-    /// Every connection the window hosts, because closing the window closes all of them. Asking
-    /// only about the one on screen let a background connection's unsaved edits go without a
-    /// prompt, which is silent data loss rather than a missing confirmation.
+    // Every connection in the window: closing it closes them all, and skipping a background one is silent data loss.
     internal var hasUnsavedWorkInWindow: Bool {
         guard let host = window?.contentViewController as? MainSplitViewController else {
             return coordinator?.hasAnyUnsavedWork() ?? false
@@ -613,8 +538,7 @@ final class MainContentCommandActions: ObservableObject {
         }
     }
 
-    /// This connection only. Closing its tabs says nothing about what another connection in the
-    /// same window has pending, so prompting about that would ask the wrong question.
+    // This connection only: closing its tabs leaves another connection's pending work alone.
     internal var hasUnsavedWorkInConnection: Bool {
         coordinator?.hasAnyUnsavedWork() ?? false
     }
@@ -637,7 +561,7 @@ final class MainContentCommandActions: ObservableObject {
         return actions.redoMenuTitle()
     }
 
-    // MARK: - Editor Query Loading (Group A — Called Directly)
+    // MARK: - Editor Query Loading (Group A: Called Directly)
 
     func loadQueryIntoEditor(_ query: String) {
         coordinator?.loadQueryIntoEditor(query)
@@ -651,10 +575,8 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.applyAISuggestion(afterSQL, replacing: beforeSQL, source: source)
     }
 
-    // MARK: - Tab Operations (Group A — Called Directly)
+    // MARK: - Tab Operations (Group A: Called Directly)
 
-    /// A new tab joins the connection's own tab list. It used to open another window whenever
-    /// the list was not empty, which is why two tables meant two windows.
     func newTab(initialQuery: String? = nil) {
         guard let coordinator else { return }
         coordinator.tabManager.addTab(
@@ -664,25 +586,19 @@ final class MainContentCommandActions: ObservableObject {
         )
     }
 
-    /// Closing the last tab leaves the connection open on its empty state, the same state it is
-    /// in right after connecting. The window hosts every open connection now, so closing it here
-    /// would take the other connections' tabs and their unsaved edits with it.
+    // The last tab leaves the connection on its empty state; closing the window would take other connections' tabs too.
     func closeTab(id: UUID) {
         Task { await closeTabAwaiting(id: id) }
     }
 
-    /// A tab holding work only a save can recover asks before it goes, which is what the window
-    /// close and the batch closes already do and what the HIG requires of an app that does not
-    /// autosave: "present a save dialog when people choose to close the document, quit your app,
-    /// log out, or restart".
-    ///
-    /// Save proceeds with the close, per `NSDocument.canCloseDocumentWithDelegate`: "shouldClose
-    /// will be YES if ... the user chose to discard modifications, or chose to save and the saving
-    /// was successful". `saveSelectedTabWork` returns false whenever the work is still unsaved
-    /// after the attempt, and the tab stays open.
+    // Asks before closing unsaved work (HIG); like NSDocument, the tab stays open when the save leaves work unsaved.
     func closeTabAwaiting(id: UUID) async {
         guard let coordinator,
               let tab = coordinator.tabManager.tabs.first(where: { $0.id == id }) else { return }
+        // An open cell editor is unsaved work too, so it lands before the question is asked.
+        if coordinator.tabManager.selectedTabId == id {
+            coordinator.commitActiveGridEdit()
+        }
         guard coordinator.hasUnsavedWork(in: tab) else {
             coordinator.closeTabsByUser(ids: [id])
             return
@@ -708,9 +624,7 @@ final class MainContentCommandActions: ObservableObject {
         }
     }
 
-    /// The selection goes back only while the closing tab still holds it. A save can wait on the
-    /// server with the strip still live, and a tab the user picked in the meantime is a newer choice
-    /// than the one this close set aside.
+    // A save can wait on the server; a tab the user picked meanwhile is a newer choice than the one this close set aside.
     private func closeRevealedTab(_ id: UUID, returningTo previousSelection: UUID?) {
         guard let coordinator else { return }
         let stillShowsClosingTab = coordinator.tabManager.selectedTabId == id
@@ -719,19 +633,13 @@ final class MainContentCommandActions: ObservableObject {
         restoreSelection(previousSelection)
     }
 
-    /// Shown, then asked. The save and discard machinery reads the selected tab, so the tab being
-    /// closed has to be the selected one before the question is put; naming work the user cannot
-    /// see would also ask them to decide about something they have no way to look at first.
+    // Save and discard read the selected tab, and the user should see the work the alert asks about.
     private func revealTab(_ id: UUID) {
         guard let coordinator, coordinator.tabManager.selectedTabId != id else { return }
         coordinator.tabManager.selectedTabId = id
     }
 
-    /// Every answer puts the selection back where the user had it, unless they have since picked
-    /// another tab, because it only moved so the alert had somewhere honest to point. After a close that is the tab they were working in, not
-    /// the neighbour of the one that went: closing a tab in the background leaves the one in front
-    /// alone whether or not it had anything to save. Closing the tab in front lands on its
-    /// neighbour as before, since the tab it would restore is gone.
+    // The selection moved only for the alert; a closed front tab lands on its neighbour since the tab to restore is gone.
     private func restoreSelection(_ id: UUID?) {
         guard let coordinator,
               let id,
@@ -740,9 +648,6 @@ final class MainContentCommandActions: ObservableObject {
         coordinator.tabManager.selectedTabId = id
     }
 
-    /// Cmd+W closes the tab in front. Pressed again with no tabs left it closes the entry, the way
-    /// the connections strip closes it, and the connection once that was its only entry. The window
-    /// itself goes only once that was the last connection open in it.
     func closeTab() {
         guard let coordinator else {
             Task { await closeWindowAwaiting() }
@@ -762,12 +667,11 @@ final class MainContentCommandActions: ObservableObject {
         Task { await ConnectionCloseAction.close(connectionId: connectionId) }
     }
 
-    /// The single close primitive. `asBatchSurvivor` is `nil` for a lone close gesture, which lets
-    /// the window decide for itself whether it can go away; a batch passes `true` for the one
-    /// window it keeps blank and `false` for every window it tears down.
+    // asBatchSurvivor: nil for a lone close (the window decides), true for the window a batch keeps blank, false otherwise.
     @discardableResult
     func closeWindowAwaiting(asBatchSurvivor: Bool? = nil) async -> WindowCloseOutcome {
         let seq = MainContentCoordinator.nextSwitchSeq()
+        coordinator?.commitActiveGridEdit()
         Self.logger.info("[close] closeWindowAwaiting seq=\(seq) hasUnsavedWork=\(self.hasUnsavedWorkInWindow)")
 
         guard hasUnsavedWorkInWindow else {
@@ -796,8 +700,7 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.contentWindow ?? window ?? NSApp.keyWindow
     }
 
-    /// A background tabbed window is occluded by the selected tab, so its confirmation sheet would
-    /// animate onto a surface the user cannot see. Bring it forward first.
+    // A background tabbed window is occluded, so its confirmation sheet would animate where the user cannot see it.
     private func selectInTabGroup() {
         guard let target = coordinator?.contentWindow ?? window,
               let tabGroup = target.tabGroup,
@@ -808,9 +711,7 @@ final class MainContentCommandActions: ObservableObject {
         }
     }
 
-    /// Every close gesture funnels here, so this is the one place that can guarantee a closing
-    /// tab's content outlives the window. It runs before the branch dispatch below because two of
-    /// the three branches tear the window down without another chance to capture anything.
+    // Called before the close dispatch: two of its three branches tear the window down with no later chance to capture.
     private func captureClosingTabsForRecovery() {
         guard let coordinator else { return }
         for tab in coordinator.tabsForRecoveryCapture() {
@@ -844,8 +745,7 @@ final class MainContentCommandActions: ObservableObject {
         Self.logger.info("[close] finish done ms=\(Int(Date().timeIntervalSince(t0) * 1_000))")
     }
 
-    /// Empties the window instead of closing it, which is how the last tab of a group lands on the
-    /// no-tabs state with its connection still live.
+    // Empties instead of closing, so the last tab lands on the no-tabs state with its connection still live.
     private func clearTabsInPlace() {
         guard let coordinator else { return }
         for tab in coordinator.tabManager.tabs {
@@ -856,15 +756,7 @@ final class MainContentCommandActions: ObservableObject {
         coordinator.toolbarState.isTableTab = false
     }
 
-    /// The save half of a close, shared by the tab close, the window close and the batch close so
-    /// the three cannot drift on what Save means. Returns whether the caller may go on to close.
-    ///
-    /// False comes back whenever the work is still staged after the attempt, because the caller
-    /// goes on to close and closing destroys it. User and role changes can only be applied after
-    /// the SQL is reviewed, so Save opens the review sheet and stands the close down; a schema
-    /// change that Safe Mode refused, that the user cancelled at the gate's confirmation, or that
-    /// the server rejected stands it down for the same reason, and so does a file that changed on
-    /// disk, whose conflict sheet is now up, or a Save As the user cancelled.
+    // False while work is still staged after the attempt (review sheet, refused or cancelled DDL, file conflict, Save As cancel).
     func saveSelectedTabWork() async -> Bool {
         guard let coordinator = coordinator else { return true }
 
@@ -873,10 +765,7 @@ final class MainContentCommandActions: ObservableObject {
             return false
         }
 
-        /// Asked of the tab's session rather than of the view on screen. `hasUnsavedWork` reads the
-        /// session too, so the prompt that offered Save can be raised by a tab showing its Data
-        /// view, or by a background tab in a batch close. Keying this on `resultsViewMode` meant
-        /// those answers ran nothing, reported success, and closed over the staged ALTERs.
+        // Keyed on the session, not resultsViewMode, which let a Data-view or background tab close over its staged ALTERs.
         if let tabId = coordinator.tabManager.selectedTabId,
            let session = coordinator.structureSessions[tabId],
            session.changeManager.hasChanges {
@@ -923,11 +812,7 @@ final class MainContentCommandActions: ObservableObject {
         return true
     }
 
-    /// Save on a prompt raised for the whole window or the whole batch has to reach every tab it
-    /// asked about, not just the selected one. `hasUnsavedWorkInWindow` and
-    /// `hasUnsavedWorkInConnection` both walk every tab's session, so a background tab's staged
-    /// ALTERs are exactly what the user has been asked about. The selected tab is skipped here
-    /// because `saveSelectedTabWork` takes it, along with its data-grid edits.
+    // Reaches every tab the window or batch prompt asked about; the selected tab is left to saveSelectedTabWork.
     func applyStagedStructureEdits(in tabs: [QueryTab]) async -> Bool {
         guard let coordinator else { return true }
         let selectedId = coordinator.tabManager.selectedTabId
@@ -958,7 +843,7 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.sidebarViewModel?.batchToggleTruncate()
     }
 
-    // MARK: - Filter Operations (Group A — Called Directly)
+    // MARK: - Filter Operations (Group A: Called Directly)
 
     func toggleFilterPanel() {
         guard canUseTableResultCommands, let coordinator else { return }
@@ -974,26 +859,27 @@ final class MainContentCommandActions: ObservableObject {
         coordinator.presentHighlightRules()
     }
 
-    func showFindBar() {
-        guard canUseGridFindCommands, let coordinator else { return }
-        coordinator.findCoordinator.show()
+    func showFindBar(replace: Bool = false) {
+        guard canUseGridFindCommands else { return }
+        coordinator?.findCoordinator.showFind(replace: replace)
+    }
+
+    func useGridSelectionForFind() {
+        guard canUseGridFindCommands else { return }
+        coordinator?.findCoordinator.useSelectionForFind()
     }
 
     func stepFindForward() {
-        coordinator?.findCoordinator.stepForward()
+        coordinator?.findCoordinator.findNext()
     }
 
     func stepFindBackward() {
-        coordinator?.findCoordinator.stepBackward()
+        coordinator?.findCoordinator.findPrevious()
     }
 
-    // MARK: - Data Operations (Group A — Called Directly)
+    // MARK: - Data Operations (Group A: Called Directly)
 
-    /// Cmd+S on a tab showing its structure. Which sub-tab is on screen makes no difference: DDL,
-    /// Parts and Triggers are read-only views of the same table, and refusing to save from them
-    /// used to make Cmd+S silently inert. The results mode still gates this, because Cmd+S saves
-    /// what you are looking at; the close prompt asks a different question and reaches the session
-    /// whatever the tab is showing.
+    // Any Structure sub-tab saves: DDL, Parts and Triggers are read-only views, and refusing left Cmd+S silently inert.
     private func applyStagedStructureChanges() {
         guard let coordinator,
               let tabId = coordinator.tabManager.selectedTabId,
@@ -1007,6 +893,7 @@ final class MainContentCommandActions: ObservableObject {
     }
 
     func saveChanges() {
+        coordinator?.commitActiveGridEdit()
         if isUsersRolesTab {
             coordinator?.usersRolesActions?.reviewAndApply()
             return
@@ -1024,9 +911,7 @@ final class MainContentCommandActions: ObservableObject {
         } else if coordinator?.changeManager.hasChanges == true
             || !pendingTruncates.wrappedValue.isEmpty
             || !pendingDeletes.wrappedValue.isEmpty {
-            // Handle data grid changes (prioritize over sidebar edits since
-            // data grid edits are synced to sidebar editState, and the data grid
-            // path uses the correct plugin driver for statement generation)
+            // Data grid first: its edits sync to the sidebar editState, and its path uses the plugin driver for statements.
             var truncates = pendingTruncates.wrappedValue
             var deletes = pendingDeletes.wrappedValue
             var options = tableOperationOptions.wrappedValue
@@ -1102,10 +987,6 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.runAIQueryAction(action, target: .selectionOrStatementAtCursor)
     }
 
-    func previewFKReference() {
-        coordinator?.toggleFKPreviewForFocusedCell()
-    }
-
     func showRowAsJSON() {
         coordinator?.showRowAsJSON()
     }
@@ -1138,9 +1019,7 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.activeSheet = .backupDatabase(databases: [])
     }
 
-    /// Asked of the connection, not only its type. libSQL reaches either a local file or a Turso
-    /// URL and only the file can be handed to `sqlite3`, so a remote one offered a Backup Dump that
-    /// wrote a 52-byte file and reported success.
+    // Per connection: a remote libSQL (Turso) URL cannot go to sqlite3, and its Backup Dump wrote a 52-byte file.
     var supportsBackup: Bool {
         NativeDumpRegistry.supports(
             connection,
@@ -1178,8 +1057,6 @@ final class MainContentCommandActions: ObservableObject {
         coordinator?.activeSheet = .restoreDatabase(fileURL: url)
     }
 
-    /// The engine's own archive, not PostgreSQL's. Every engine the registry supports is offered
-    /// Restore Dump, and the panel used to tell all of them to pick a `pg_dump` custom archive.
     private var restoreSourceContentTypes: [UTType] {
         let extensions = NativeDumpRegistry.formats(for: connection.type)
             .map(\.fileExtension)
@@ -1189,8 +1066,7 @@ final class MainContentCommandActions: ObservableObject {
         return types + [.folder, .data]
     }
 
-    /// DuckDB restores either one `.duckdb` file or a folder of Parquet, so the panel has to accept
-    /// a folder as well.
+    // DuckDB restores a .duckdb file or a folder of Parquet.
     private var restoreAcceptsDirectory: Bool {
         NativeDumpRegistry.formats(for: connection.type).contains { $0.producesDirectory }
     }
@@ -1242,12 +1118,6 @@ final class MainContentCommandActions: ObservableObject {
         EditorEventRouter.shared.performFormatSQLForKeyWindow()
     }
 
-    /// Emptying the editor and discarding the results are two commands, not one.
-    ///
-    /// They used to be a single trash button whose tooltip and accessibility label both said
-    /// "Clear Query" while it also cleared the results, the execution record and collapsed the
-    /// results pane. Neither half had a menu-bar command, so neither could be undone, reached by
-    /// keyboard, or announced for what it was.
     func clearQuery() {
         guard let coordinator,
               let (tab, tabIndex) = coordinator.tabManager.selectedTabAndIndex,
@@ -1255,10 +1125,7 @@ final class MainContentCommandActions: ObservableObject {
         coordinator.tabManager.mutate(at: tabIndex) { $0.content.query = "" }
         coordinator.toolbarState.hasQueryText = false
         coordinator.scheduleDraftSave()
-        /// The editor's own text binding recomputes this on every keystroke, and emptying the tab
-        /// from a command does not go through that binding. Without it a scratch tab keeps the
-        /// dirty dot it no longer deserves, and a file-backed tab that this command just emptied
-        /// is not marked modified until some other window event happens to recompute it.
+        // Emptying from a command bypasses the editor binding that recomputes the dirty indicator on each keystroke.
         coordinator.refreshUnsavedIndicator()
     }
 
@@ -1299,18 +1166,12 @@ final class MainContentCommandActions: ObservableObject {
         EditorEventRouter.shared.moveCursorToStatementForKeyWindow(.next)
     }
 
-    /// Runs the statement the caret is in, then puts the caret on the next one.
-    ///
-    /// The caret moves first so the reader can see which statement is queued next while this one runs, and so a held
-    /// key steps through the script rather than running the same statement repeatedly. The editor resolves and runs
-    /// both halves itself, through the same callback the gutter control uses, so the statement can only ever reach the
-    /// connection whose editor it came from. That callback ends at `runStatement`, which refuses while the tab is
-    /// executing, so a held key cannot queue a second run.
+    // Through the gutter's callback, so it only reaches its own connection; the caret moves first so a held key steps through.
     func runStatementAndAdvance() {
         EditorEventRouter.shared.runStatementAtCursorAndAdvanceForKeyWindow()
     }
 
-    // MARK: - UI Operations (Group A — Called Directly)
+    // MARK: - UI Operations (Group A: Called Directly)
 
     func toggleHistoryPanel() {
         guard let connectionId = coordinator?.connectionId else { return }
@@ -1468,12 +1329,9 @@ final class MainContentCommandActions: ObservableObject {
     private func handleDatabaseDidConnect() {
         Task { [weak coordinator] in
             guard let coordinator, !coordinator.isTearingDown else { return }
-            /// A reconnect hands the session a new driver, and the query builder would otherwise keep
-            /// building against the one that was just disconnected.
+            // A reconnect brings a new driver; the query builder would otherwise keep the disconnected one.
             coordinator.setupPluginDriver()
-            /// The first connect is also announced here, while the coordinator's own initial load runs
-            /// for it on the same driver. Refreshing on top sent every catalog query twice, so the
-            /// refresh waits for that load and runs only if it did not leave the catalog loaded.
+            // The first connect lands here during the initial load; refreshing on top sent every catalog query twice.
             if let inFlight = coordinator.schemaLoadTask,
                SchemaLoadPolicy.inFlightLoadCoversConnect(
                    loadDriver: coordinator.schemaLoadDriver,
@@ -1536,12 +1394,16 @@ final class MainContentCommandActions: ObservableObject {
 }
 
 extension MainContentCommandActions {
-    // Copy with the grid not focused: the grid's format when one is mounted, else Copy Rows.
+    // Copy with the grid not focused takes the selected rows in the row copy format; a focused grid answers `copy:` itself.
     func copySelectedRowsInCopyFormat() {
-        guard dataGridOwnsSelection, let grid = coordinator?.dataTabDelegate?.tableViewCoordinator else {
+        guard dataGridOwnsSelection, let model = coordinator?.activeGridModel else {
             copySelectedRows()
             return
         }
-        grid.copyRowsInCopyFormat(at: resolvedRowSelection())
+        let commands = DataGridCommands(model: model)
+        commands.copyRows(
+            DataGridCommandScope(selection: model.selection, focus: nil, isRowHeader: true),
+            as: commands.rowCopyFormat
+        )
     }
 }
diff --git a/apple/TablePro/Views/Main/MainContentCoordinator.swift b/apple/TablePro/Views/Main/MainContentCoordinator.swift
index 8949548fcb..c293e1242e 100644
--- a/apple/TablePro/Views/Main/MainContentCoordinator.swift
+++ b/apple/TablePro/Views/Main/MainContentCoordinator.swift
@@ -14,7 +14,6 @@ import TableProEditorKit
 import TableProPluginKit
 import TableProSQLGrammar
 
-/// Discard action types for unified alert handling
 enum DiscardAction {
     case refresh
     case sort
@@ -46,27 +45,21 @@ struct DisplayFormatsCacheEntry {
     }
 }
 
-/// Represents which sheet is currently active in MainContentView.
-/// Uses a single `.sheet(item:)` modifier instead of multiple `.sheet(isPresented:)`.
+// Drives one `.sheet(item:)` in MainContentView instead of several `.sheet(isPresented:)`.
 enum ActiveSheet: Identifiable {
     case sqlPreview
     case exportDialog
     case importDialog(formatId: String)
     case rowImport(formatId: String)
-    /// Several files, or a folder, each imported as rows into its own table. The files are in `importBatch`.
+    // The files are in `importBatch`, each imported into its own table.
     case rowImportBatch
     case exportQueryResults
-    /// The tables the user right-clicked travel with the request, because the object browser may be
-    /// pointed somewhere else by the time the sheet appears.
+    // Carries the right-clicked tables: the object browser may point elsewhere by the time the sheet appears.
     case transferTables(tables: Set<String>, schema: String?)
-    /// The databases the user right-clicked travel with the request, so the sheet opens on them
-    /// rather than on wherever the object browser happens to point. Empty means the browse database.
+    // Carries the right-clicked databases, not the object browser's current one. Empty means the browse database.
     case backupDatabase(databases: Set<String>)
     case restoreDatabase(fileURL: URL)
-    /// The object's own database and schema travel with the request. A maintenance statement names
-    /// its table and nothing else, so acting on wherever the object browser happens to point
-    /// maintains the same-named table in another database whenever the two have drifted apart.
-    /// This is the rule the sidebar's other destructive commands already keep by carrying their ref.
+    // Carries the object's own scope: the statement names only the table, so the browser's scope could hit a same-named one.
     case maintenance(
         operation: PluginMaintenanceOperation,
         tableName: String,
@@ -74,28 +67,19 @@ enum ActiveSheet: Identifiable {
         schema: String?
     )
     case createDatabase
-    /// The database the new schema goes in travels with the request, for the reason `.maintenance`
-    /// carries its scope: the sheet creates the schema in the database the user right-clicked, not
-    /// in wherever the object browser points by the time Create is pressed.
+    // The right-clicked database, not wherever the object browser points by the time Create is pressed.
     case createSchema(database: String?)
     case editSchema(DatabaseContainerRef)
-    /// The object's own database and schema travel in the target, for the reason `.maintenance`
-    /// carries them: the comment is written to the object the user right-clicked, not to a
-    /// same-named one wherever the browser points by the time Save is pressed.
+    // Carries the object's scope so the comment lands on the right-clicked object, not a same-named one the browser points at.
     case editObjectComment(DatabaseObjectTarget)
     case setSequenceNextValue(DatabaseObjectTarget)
     case editSequence(DatabaseObjectTarget)
-    /// Copying carries the whole launch request, because the source database, the source schema
-    /// and the objects the user right-clicked are all part of what the sheet opens onto, and the
-    /// object browser may be pointed somewhere else by the time the sheet appears.
+    // Carries the source database, schema and objects: the object browser may point elsewhere by the time the sheet appears.
     case copyObjects(ObjectCopyLaunchRequest)
     case rewind
     case tableRebuildReview
-    /// The collection and its database travel with the request, for the reason `.maintenance`
-    /// carries its scope: the document is written where it was read, not wherever the object
-    /// browser points by the time Save is pressed.
+    // Carries the collection and database so the document is saved where it was read, not where the browser points on Save.
     case documentEditor(DocumentEditorRequest)
-    /// The database and schema the Types section was right-clicked in travel with the request.
     case createUserType(database: String?, schema: String?)
     case searchDatabase(DatabaseSearchSession)
     case joinBuilder(JoinBuilderLaunchRequest)
@@ -136,13 +120,12 @@ enum ActiveSheet: Identifiable {
     }
 }
 
-/// Coordinator managing MainContentView business logic
 @MainActor
 final class MainContentCoordinator: ObservableObject {
     nonisolated static let logger = Logger(subsystem: "com.TablePro", category: "MainContentCoordinator")
     nonisolated static let lifecycleLogger = Logger(subsystem: "com.TablePro", category: "NativeTabLifecycle")
 
-    /// Monotonic counter for correlating rapid tab-switch/close log entries.
+    // Correlates rapid tab-switch and tab-close log entries.
     static var switchSeq: Int = 0
     static func nextSwitchSeq() -> Int {
         switchSeq += 1
@@ -156,17 +139,11 @@ final class MainContentCoordinator: ObservableObject {
     var connectionId: UUID { connection.id }
     var sqlDialect: SqlDialect { SqlDialect.from(databaseTypeId: connection.type.rawValue) }
 
-    /// How this connection's scripts are split for execution, with what the driver read from its own session.
     var lexicalGrammar: SQLLexicalGrammar {
         SQLLexicalResolver.executionGrammar(for: connection.type, connectionId: connectionId)
     }
     var statementModel: QueryStatementModel { QueryStatementModel.forDatabaseType(connection.type) }
-    /// Whether `:name` in this connection's queries is a bind parameter, which it is only in SQL.
-    ///
-    /// Every other language already gives the colon a meaning: an object key in a MongoDB script, a field
-    /// query in an Elasticsearch URL (`?q=name:lamp`), a key separator in Redis (`GET user:name`), a record
-    /// id in SurrealQL (`person:tobie`). Read as a parameter, it opens the panel, holds the run until a value
-    /// is typed, and then sends a placeholder the engine's driver never binds.
+    // Only SQL: `:name` means something else in MongoDB, Elasticsearch (`?q=name:lamp`), Redis (`GET user:name`) and SurrealQL.
     var bindsNamedParameters: Bool { services.pluginManager.editorLanguage(for: connection.type) == .sql }
     var browseDatabaseName: String {
         services.databaseManager.browseDatabaseName(for: connection)
@@ -175,8 +152,7 @@ final class MainContentCoordinator: ObservableObject {
         tabManager.openingDatabase(browsing: browseDatabaseName)
     }
     var safeModeLevel: SafeModeLevel { toolbarState.safeModeLevel }
-    /// The level the toolbar shows, and the floor under it with Agent mode's included, which is what
-    /// the Safe Mode list offers from and what the toolbar's tooltip explains.
+    // The floor includes Agent mode's; the Safe Mode list offers levels from it and the toolbar tooltip explains it.
     var safeModeStatus: SafeModeStatus {
         SafeModeStatus(level: safeModeLevel, floor: AgentModeSafeModeFloor.effectiveFloor(for: connection))
     }
@@ -184,7 +160,6 @@ final class MainContentCoordinator: ObservableObject {
         services.databaseManager.chooseSafeModeLevel(level, for: connectionId)
         toolbarState.safeModeLevel = services.databaseManager.session(for: connectionId)?.safeModeLevel ?? level
     }
-    let selectionState = GridSelectionState()
     let selectionSummary = SelectionSummaryState()
     let tabManager: QueryTabManager
     let changeManager: DataChangeManager
@@ -209,107 +184,72 @@ final class MainContentCoordinator: ObservableObject {
     private(set) var rowEditingCoordinator: RowEditingCoordinator!
     private(set) lazy var browseCursorCoordinator = BrowseCursorCoordinator(parent: self)
 
-    /// Stable identifier for this coordinator's window (set by MainContentView on appear)
+    // Set by MainContentView on appear.
     @Published var windowId: UUID?
 
-    /// Setting this presents the favorite-edit dialog sheet from `MainEditorContentView`.
     @Published var favoriteDialogQuery: FavoriteDialogQuery?
 
-    /// Direct reference to sidebar viewmodel, eliminates global notification broadcasts
     weak var sidebarViewModel: SidebarViewModel?
 
-    /// Direct reference to structure view actions — eliminates notification broadcasts
     weak var structureActions: StructureViewActionHandler?
 
-    /// Direct reference to create-table view actions so the Save Changes menu
-    /// (Cmd+S) routes to table creation. Set by `CreateTableView` on appear.
+    // Lets Save Changes (Cmd+S) route to table creation. Set by `CreateTableView` on appear.
     weak var createTableActions: CreateTableActionHandler?
 
     weak var usersRolesActions: UsersRolesActionHandler?
 
-    /// Staged structure edits and table drafts, per tab. They belong here rather than in the view
-    /// for two reasons: the view is destroyed on every tab switch and on every switch between Data
-    /// and Structure, and the close gate has to be able to see the staged work of a tab the user is
-    /// not currently looking at.
+    // Not in the view: it dies on every tab and Data/Structure switch, and the close gate must see unseen tabs' staged work.
     @Published var structureSessions: [UUID: StructureEditingSession] = [:]
     @Published var createTableDrafts: [UUID: CreateTableDraft] = [:]
-    /// A type tab's queued changes, kept here for the same two reasons.
+    // Kept here for the same reasons as `structureSessions`.
     @Published var userTypeEditors: [UUID: UserTypeEditorModel] = [:]
     // Held here for the same reason: the diagram stages schema edits that Save and the close gate reach.
     @Published var erDiagramModels: [UUID: ERDiagramViewModel] = [:]
 
-    /// Tabs holding staged principal changes. `usersRolesActions` is nilled the moment the tab is
-    /// deselected, but the view model behind it is cached per tab id and keeps the staged work, so
-    /// without this record a background Users & Roles tab reports itself clean and closes silently.
+    // The cached view model keeps staged work after `usersRolesActions` is nilled; without this a background tab closes silently.
     internal var tabsWithStagedPrincipals: Set<UUID> = []
 
-    /// Tabs whose close confirmation is already on screen. `saveCompletionContinuation` is a single
-    /// slot, so a second gesture arriving before the first sheet resolves would overwrite the
-    /// continuation the first one is suspended on and leave that task waiting forever.
+    // `saveCompletionContinuation` is one slot: a second close gesture would overwrite it and strand the first task forever.
     internal var tabClosesInFlight: Set<UUID> = []
 
-    /// The grid that owns the current selection when it is not the data grid, so the
-    /// inspector reads the selected row from it instead of the data tab's rows.
-    /// Set by `TableStructureView` and `CreateTableView` on appear.
+    // The non-data grid that owns the selection, read by the inspector. Set by `TableStructureView` and `CreateTableView`.
     weak var inspectorRowSource: (any InspectorRowSource)?
 
-    /// Bumped whenever a published schema row changes, so the inspector re-reads it.
+    // Bumped when a published schema row changes, so the inspector re-reads it.
     @Published var inspectorRowSourceRevision: Int = 0
 
-    /// Direct reference to AI chat viewmodel — eliminates notification broadcasts
-    /// The assistant's view model, and only if something has already brought one into existence.
-    /// Reading this never builds one: an editor command that wants to talk to the assistant reveals
-    /// it first, and revealing is what activates it.
+    // Never builds the view model: a command reveals the assistant first, and revealing is what activates it.
     var aiViewModel: AIChatViewModel? { trailingPaneState?.assistant.viewModelIfActivated }
 
     weak var trailingPaneState: TrailingPaneState?
 
-    /// Direct reference to the data tab grid delegate — enables row mutation operations to
-    /// Observable mirror of the grid's display revision, so views outside the grid re-render when
-    /// the value filter or the displayed order changes. The grid's own state lives on a plain
-    /// AppKit object reached through observation-ignored hops, so it cannot invalidate a view.
+    // Moves when a value filter or a display format changes, so views outside the grid re-read the order.
     @Published var gridDisplayRevision: Int = 0
 
-    /// Sent when an inspector edit rewrites the selected row's values, so the inspector's JSON
-    /// rendering re-reads the row. Apart from `gridDisplayRevision`, which drives a full rebuild of
-    /// the field list and takes first responder out of whatever is being typed into.
-    ///
-    /// An event rather than a published counter. The counter it replaces was not published, so the
-    /// `onChange` that read it never fired and the JSON rendering went stale. Publishing it would
-    /// have redrawn every view that observes this coordinator on each keystroke a detached value
-    /// window commits, and only one of them wants to know.
+    // Refreshes the inspector JSON without `gridDisplayRevision`'s full rebuild; a subject so observers don't redraw per keystroke.
     let inspectorRowContentChanged = PassthroughSubject<Void, Never>()
 
-    /// dispatch insertRows/removeRows directly to the NSTableView via DataGridViewDelegate.
-    weak var dataTabDelegate: DataTabGridDelegate?
+    // One grid model per data tab, outliving every mount of its grid.
+    var dataGridEntries: [UUID: DataTabGridEntry] = [:]
+    // Set while a tab switch still has the outgoing tab's edits in the change manager.
+    var tabSwitchOutgoingTabId: UUID?
+    private(set) lazy var gridChangeState = AnyChangeManager(changeManager)
+    let gridCellsEdited = PassthroughSubject<Void, Never>()
 
-    var activeGridDisplayIDs: [RowID]? {
-        guard let tabId = tabManager.selectedTab?.id else { return nil }
-        return displayIDs(forTab: tabId)
-    }
-
-    /// One-shot intent set when the user explicitly opens a table (Return/double-click),
-    /// consumed by the grid as it appears to move focus into it. Never set on mere selection.
+    // One-shot: set on an explicit open (Return, double-click), consumed by the grid to take focus. Never set on selection.
     var pendingGridFocusOnOpen = false
 
-    /// Proxy for toggling the inspector NSSplitViewItem from coordinator code
     weak var trailingPaneProxy: TrailingPaneProxy?
 
-    /// Direct reference to split view controller for sidebar toggle
     weak var splitViewController: MainSplitViewController?
 
-    /// Direct reference to this coordinator's content window, used for presenting alerts.
-    /// Avoids NSApp.keyWindow which may return a sheet window, causing stuck dialogs.
+    // For alerts instead of NSApp.keyWindow, which may return a sheet window and leave dialogs stuck.
     weak var contentWindow: NSWindow?
 
-    /// Back-reference to this coordinator's command actions, enabling window → coordinator → actions
-    /// lookup. The app runs the AppKit lifecycle with no SwiftUI `Scene`, so a focused value has
-    /// nothing to resolve against; this reference reaches every caller, AppKit and SwiftUI alike.
+    // No SwiftUI `Scene` in the AppKit lifecycle, so a focused value can't resolve; this reaches AppKit and SwiftUI callers.
     weak var commandActions: MainContentCommandActions?
 
-    /// Presents the quick switcher as a floating panel anchored over this coordinator's window.
-    /// The window owns it, because the panel anchors on the window and every connection the window
-    /// hosts would otherwise bring one of its own to the same point.
+    // Owned by the window: the panel anchors on it, and each connection the window hosts would otherwise bring its own.
     var quickSwitcherPanel: QuickSwitcherPanelController? {
         splitViewController?.quickSwitcherPanel
     }
@@ -320,10 +260,7 @@ final class MainContentCoordinator: ObservableObject {
     @Published var activeSheet: ActiveSheet? {
         didSet { releaseImportFileUnlessImporting() }
     }
-    /// Owns the connection and database switcher surfaces. The commands present through this
-    /// rather than flipping a flag a toolbar-hosted view has to observe, because that view is
-    /// absent whenever its item is clipped into the overflow menu or removed by the user. It
-    /// belongs to the window for the same reason the panel it drives does.
+    // Commands present through this, not a flag: the toolbar view is gone when its item is in overflow or removed.
     var switcherPresenter: ToolbarSwitcherPresenter? {
         splitViewController?.switcherPresenter
     }
@@ -339,14 +276,9 @@ final class MainContentCoordinator: ObservableObject {
     var deferredRestoreLoadTabId: UUID?
 
     var displayFormatsCache: [UUID: DisplayFormatsCacheEntry] = [:]
-    var displayOrderCache: [UUID: DisplayOrderCacheEntry] = [:]
-    var displayStateCache: [UUID: DisplayStateCacheEntry] = [:]
-    /// Published because the inspector draws from it: a load that lands, a comment refetch and a
-    /// rename each reach the panel because the view rebuilds its snapshot when this changes.
+    // Published because the inspector rebuilds its snapshot from it (load, comment refetch, rename).
     @Published var tableMetadataCache: [UUID: TableMetadataCacheEntry] = [:]
-    /// Moves on every Table Info invalidation, so a read in flight across one cannot mark the cache
-    /// current: its numbers may predate the change. One counter for the window rather than one per
-    /// tab, because an invalidation can arrive before a tab's first read has made an entry to mark.
+    // Bumped per Table Info invalidation so an in-flight read can't mark the cache current; per window, as it can precede a tab entry.
     var tableMetadataGeneration = 0
     var displayStateClock = 0
 
@@ -365,68 +297,47 @@ final class MainContentCoordinator: ObservableObject {
 
     var importFormatLookup = ImportFormatLookup.live
 
-    /// Routing failures report through here so a test can observe the message instead of raising a
-    /// real alert. `AlertHelper.present` runs application-modal when no window qualifies, and a
-    /// unit test host has no window, so calling it directly parks the main thread in a modal loop
-    /// that nothing can dismiss and no test time limit can interrupt.
+    // Injectable: `AlertHelper.present` goes app-modal with no window, and a unit test host has none, hanging the main thread.
     var presentError: (String, String, NSWindow?) -> Void = { title, message, window in
         AlertHelper.showErrorSheet(title: title, message: message, window: window)
     }
 
     // MARK: - Internal State
 
-    /// Per-tab execution ownership. Replaces a per-window generation counter, a stored per-tab
-    /// `isExecuting` bool and two task handles that a tab retarget participated in none of.
-    ///
-    /// Deliberately observed rather than ``: busy state is derived from
-    /// membership here, so the views that used to read the stored flag have to be able to see it
-    /// change. It is a value type, so every claim, settle and invalidate is a write to this
-    /// property and invalidates its readers.
+    // Published on purpose: busy state is derived from membership here, and every claim, settle and invalidate is a write.
     @Published internal var tabExecution = TabExecutionRegistry()
 
-    /// One in-flight query task per tab, beside the claim registry that owns each tab's result.
-    /// Cancellation is keyed by tab for the same reason ownership is: the window hosts several tabs
-    /// on one connection, and a handle shared between them made every start path a Stop for whoever
-    /// held it.
+    // Keyed by tab: the window hosts several tabs on one connection, and a shared handle made every start a Stop for its holder.
     internal var queryTasks = TabQueryTasks()
     internal var rowCountTasks: [UUID: (token: UUID, task: Task<Void, Never>)] = [:]
 
-    /// Which user-requested exact count currently owns each tab's counting indicator.
+    // Tab id to the user-requested exact count that owns its counting indicator.
     internal var exactCountOwners: [UUID: UUID] = [:]
     internal var tableLoadTasks: [UUID: (token: UUID, task: Task<Void, Never>)] = [:]
 
-    /// Each tab's browse history, keyed by tab id the way the other per-tab caches here are.
-    ///
-    /// Not a field on `QueryTab`: that struct is the persisted shape of a tab, and an entry
-    /// describes rows that may be gone by the next launch. Keeping it out of the struct also keeps
-    /// it out of the hand-written `Equatable`, so a push never re-publishes the tab list.
+    // Not on `QueryTab`: that is the persisted shape, and staying out of its `Equatable` keeps a push from re-publishing tabs.
     internal var navigationHistories: [UUID: TabNavigationHistory] = [:]
     internal var redisDatabaseSwitchTask: Task<Void, Never>?
     private var periodicSaveTask: Task<Void, Never>?
     private var draftSaveTask: Task<Void, Never>?
     private var terminationObserver: NSObjectProtocol?
     internal var postConnectCancellable: AnyCancellable?
-    /// Owned here rather than by the view that asks for it: a view's `task` is cancelled whenever a
-    /// connection switch takes its pane out of the window, and a cancelled first load left the
-    /// object list without anything to load it again.
+    // Owned here, not by the view: a connection switch cancels the view's `task`, and a cancelled first load never reran.
     internal var schemaLoadTask: Task<Void, Never>?
-    /// The driver `schemaLoadTask` reads through. A reconnect installs a new one, and a load still
-    /// running on the old driver says nothing about the catalog the new one sees.
+    // A reconnect installs a new driver, and a load on the old one says nothing about the new catalog.
     internal weak var schemaLoadDriver: (any DatabaseDriver)?
-    /// The coordinator's, not the view's: a session that drops and comes back swaps the content
-    /// view out and in again, and restoring the saved tabs a second time over the live ones replaced
-    /// whatever changed since the last save.
+    // On the coordinator: a dropped session swaps the view, and restoring twice overwrote the live tabs' changes.
     internal var hasRestoredTabs = false
-    /// Set once this coordinator's restore has run, or was not due. A moved tab waits for it,
-    /// so it is checked against, merged into and saved with the saved set.
+    // Set once restore ran or was not due. A moved tab waits for it so it merges into and saves with the saved set.
     internal var hasSettledTabRestore = false
     internal var movesAwaitingRestore: [PendingTabMove] = []
-    /// How many times this connection's content has appeared, a connection switch back included.
+    // Counts every appearance, a switch back to this connection included.
     internal private(set) var activationCount = 0
     private var externalFileModCancellable: AnyCancellable?
     internal lazy var sourceFileDiskChangeMonitor = SourceFileDiskChangeMonitor(tabManager: tabManager)
     private var schemaSwitchCancellable: AnyCancellable?
     private var clearedEditsCancellable: AnyCancellable?
+    private var gridRepaintCancellable: AnyCancellable?
     private var browseContainerCancellable: AnyCancellable?
 
     @Published var fileConflictRequest: FileConflictRequest?
@@ -440,75 +351,59 @@ final class MainContentCoordinator: ObservableObject {
     }
     internal private(set) var fileWatcher: DatabaseFileWatcher?
 
-    /// Set during handleTabChange to suppress redundant column-change reconfiguration
+    // Set during handleTabChange to suppress redundant column-change reconfiguration.
     internal var isHandlingTabSwitch = false
     var isUpdatingColumnLayout = false
 
-    /// Guards against re-entrant confirm dialogs (e.g. nested run loop during runModal)
+    // Guards re-entrant confirm dialogs (nested run loop during runModal).
     internal var isShowingConfirmAlert = false
 
-    /// Guards against duplicate safe mode confirmation prompts
     internal var isShowingSafeModePrompt = false
 
-    /// What restoring the last save would do, once it has been planned against the live rows.
     @Published internal var rewindPlan: RewindPlan?
 
-    /// The rebuild a column drag asked for, held while the user reads it.
+    // The rebuild a column drag asked for, held while the user reviews it.
     @Published internal var tableRebuildRequest: TableRebuildReviewRequest?
 
-    /// Continuation for callers that need to await the result of a fire-and-forget save
-    /// (e.g. save-then-close). Set before calling `saveChanges`, resumed by `executeCommitStatements`.
+    // For save-then-close callers. Set before `saveChanges`, resumed by `executeCommitStatements`.
     internal var saveCompletionContinuation: CheckedContinuation<Bool, Never>?
 
     // MARK: - Window Lifecycle (driven by TabWindowController NSWindowDelegate)
 
-    /// Whether this coordinator's window is the key (focused) window.
-    /// Updated by TabWindowController delegate methods; consumed by
-    /// event handlers (e.g. sidebar table-selection navigation filter).
+    // Updated by TabWindowController; read by event handlers such as the sidebar table-selection filter.
     var isKeyWindow = false
 
-    /// Eviction task scheduled in `handleWindowDidResignKey` (fires 5s later).
+    // Scheduled in `handleWindowDidResignKey`, fires 5s later.
     var evictionTask: Task<Void, Never>?
 
     var refreshCoalesceTask: Task<Void, Never>?
     var refreshPendingTrailing = false
 
-    /// True once the coordinator's view has appeared (onAppear fired).
-    /// Coordinators that SwiftUI creates during body re-evaluation but never
-    /// adopts into @State are silently discarded — no teardown warning needed.
+    // SwiftUI creates and discards coordinators during body re-evaluation; those never activate and need no teardown warning.
     private let _didActivate = OSAllocatedUnfairLock(initialState: false)
 
-    /// Tracks whether teardown() was called; used by deinit to log missed teardowns
+    // Read by deinit to log missed teardowns.
     private let _didTeardown = OSAllocatedUnfairLock(initialState: false)
 
-    /// Tracks whether teardown has been scheduled (but not yet executed)
-    /// so deinit doesn't warn if SwiftUI deallocates before the delayed Task fires
+    // So deinit doesn't warn if SwiftUI deallocates before the delayed teardown Task fires.
     private let _teardownScheduled = OSAllocatedUnfairLock(initialState: false)
 
-    /// Whether teardown is scheduled or already completed — used by views to skip
-    /// persistence during window close teardown
+    // Views skip persistence during window close teardown.
     var isTearingDown: Bool { _teardownScheduled.withLock { $0 } || _didTeardown.withLock { $0 } }
 
-    /// Set when NSApplication is terminating — suppresses deinit warning since
-    /// SwiftUI does not call onDisappear during app termination
+    // Suppresses the deinit warning: SwiftUI does not call onDisappear during app termination.
     nonisolated private static let _isAppTerminating = OSAllocatedUnfairLock(initialState: false)
     nonisolated static var isAppTerminating: Bool {
         get { _isAppTerminating.withLock { $0 } }
         set { _isAppTerminating.withLock { $0 = newValue } }
     }
 
-    /// Stable instance identity. Used to key the registry so a recycled
-    /// `ObjectIdentifier` from a freshly-allocated coordinator can never
-    /// remove a different instance's entry from a delayed cleanup Task.
+    // Registry key: a recycled `ObjectIdentifier` could let a delayed cleanup Task remove another instance's entry.
     let instanceId = UUID()
 
-    /// Registry of active coordinators for aggregated quit-time persistence.
-    /// Keyed by `instanceId` (UUID) — never by `ObjectIdentifier`, which can
-    /// be recycled across allocations.
+    // For quit-time persistence. Keyed by `instanceId`, never `ObjectIdentifier`, which can be recycled.
     static var activeCoordinators: [UUID: MainContentCoordinator] = [:]
 
-    /// Register this coordinator so quit-time persistence can aggregate tabs.
-    /// Idempotent — repeated registration is a no-op.
     func registerEagerly() {
         Self.activeCoordinators[instanceId] = self
     }
@@ -525,14 +420,7 @@ final class MainContentCoordinator: ObservableObject {
         _didActivate.withLock { $0 }
     }
 
-    /// Every tab the connection has open, across every window hosting it. Tearing a tab off into
-    /// its own window splits one connection's tabs over two coordinators, and the saved set is the
-    /// union: saving from one of them alone writes a partial list over the full one, which is how
-    /// tabs that were never closed get erased.
-    ///
-    /// Deduped by tab id, because `activeCoordinators` also holds the throwaway coordinators
-    /// SwiftUI builds and discards while re-evaluating a body, and those report the same tabs as
-    /// the real one until they deallocate.
+    // Union across windows: saving one window's tabs erased torn-off ones. Deduped, since SwiftUI's throwaway coordinators repeat tabs.
     static func aggregatedTabs(for connectionId: UUID) -> [QueryTab] {
         var seen = Set<UUID>()
         return activeCoordinators.values
@@ -543,8 +431,6 @@ final class MainContentCoordinator: ObservableObject {
             .filter { seen.insert($0.id).inserted }
     }
 
-    /// Resolve transient view state that only the live coordinator knows about
-    /// (sort column names, editor cursor offset) onto the tab before it is serialized.
     func enrichedForPersistence(_ tab: QueryTab) -> QueryTab {
         var enriched = tab
         if enriched.sortState.isSorting {
@@ -558,19 +444,15 @@ final class MainContentCoordinator: ObservableObject {
                 return named
             }
         }
-        // Only when there is a live caret to write. `cursorPositions` starts empty and is fed by
-        // the editor's own change events, so a tab whose editor never became first responder has
-        // none, and writing that absence over the tab's saved caret discards it.
+        // Only with a live caret: a tab whose editor never took focus has no `cursorPositions`, and writing that erased its saved caret.
         if tab.tabType == .query, tab.id == tabManager.selectedTabId,
            let range = cursorPositions.first?.range {
             enriched.restoredCursorOffset = range.location
             enriched.restoredCursorLength = range.length
         }
-        // The grid's own teardown keeps the selection on the tab, but a tab moved to another window
-        // is snapshotted while its grid is still mounted, so that capture has not run yet.
-        if tab.id == tabManager.selectedTabId, let live = mountedGridSelection() {
-            enriched.selectedRowIndices = live.rows
-            enriched.cellSelection = live.cells
+        // The model keeps the selection; a tab moved to another window carries it in the tab.
+        if let store = dataGridEntries[tab.id]?.store {
+            enriched.selectionSnapshot = store.selectionSnapshot
         }
         return enriched
     }
@@ -580,8 +462,6 @@ final class MainContentCoordinator: ObservableObject {
         return buffer.columns.isEmpty ? effectiveResultColumns(for: tab) : buffer.columns
     }
 
-    /// Map persisted sort columns (keyed by name) back to indices into the live column set.
-    /// Columns that no longer exist are dropped, so a renamed or removed column degrades gracefully.
     static func resolveRestoredSortColumns(
         _ persisted: [PersistedSortColumn],
         in columns: [String]
@@ -592,11 +472,7 @@ final class MainContentCoordinator: ObservableObject {
         }
     }
 
-    /// The selection a query tab was left with, as a range to hand straight to the editor.
-    ///
-    /// The editor applies this once through its own controller rather than through the cursor
-    /// binding, so this is a plain read. The value stays on the tab until the editor reports it
-    /// consumed, because `body` runs many times before the text view exists.
+    // A plain read: the value stays on the tab until the editor reports it consumed, since `body` runs before the text view exists.
     func restoredCursorRange(for tabId: UUID) -> NSRange? {
         guard let index = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               tabManager.tabs[index].tabType == .query,
@@ -607,10 +483,7 @@ final class MainContentCoordinator: ObservableObject {
         return NSRange(location: clamped, length: max(0, selectionLength))
     }
 
-    /// The regions collapsed in a query tab.
-    ///
-    /// Folds live on the tab rather than on the window, so switching tabs cannot carry one tab's collapsed regions
-    /// onto another and nothing has to be cleared when a tab appears.
+    // Folds live on the tab, not the window, so a tab switch can't carry one tab's folds onto another.
     func foldRanges(for tabId: UUID) -> [Range<Int>]? {
         guard let index = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               tabManager.tabs[index].tabType == .query else { return nil }
@@ -626,18 +499,13 @@ final class MainContentCoordinator: ObservableObject {
         }
     }
 
-    /// The statement a selected result asked the editor to go to, if one is waiting.
     func pendingStatementJump(for tabId: UUID) -> StatementAnchor? {
         guard let index = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               tabManager.tabs[index].tabType == .query else { return nil }
         return tabManager.tabs[index].pendingStatementJump
     }
 
-    /// Asks the tab's editor to take the reader to `anchor`.
-    ///
-    /// The anchor is stored rather than applied, because the editor owns the text this has to be resolved against and
-    /// may not be mounted yet. It is cleared as soon as an editor consumes it, so selecting the same result again
-    /// asks again rather than being swallowed as an unchanged value.
+    // Stored, not applied: the editor may not be mounted yet. Cleared on consume, so selecting the same result asks again.
     func requestStatementJump(_ anchor: StatementAnchor, in tabId: UUID) {
         guard let index = tabManager.tabs.firstIndex(where: { $0.id == tabId }),
               tabManager.tabs[index].tabType == .query else { return }
@@ -663,9 +531,7 @@ final class MainContentCoordinator: ObservableObject {
     private static let periodicSaveInterval: Duration = .seconds(30)
     private static let draftSaveDebounce: Duration = .seconds(1)
 
-    /// Persist shortly after the user stops typing. Editing query text changes no tab
-    /// identity, so it drives none of the structural saves, and without this a scratch
-    /// query lives only in memory until the 30 second timer or the quit-time flush.
+    // Typing changes no tab identity, so without this a scratch query lives only in memory until the 30s timer or quit flush.
     func scheduleDraftSave() {
         guard !Self.isAppTerminating, !isTearingDown else { return }
         draftSaveTask?.cancel()
@@ -689,14 +555,12 @@ final class MainContentCoordinator: ObservableObject {
         }
     }
 
-    /// Get selected tab ID from any coordinator for a given connectionId.
     static func aggregatedSelectedTabId(for connectionId: UUID) -> UUID? {
         activeCoordinators.values
             .first { $0.connectionId == connectionId && $0.tabManager.selectedTabId != nil }?
             .tabManager.selectedTabId
     }
 
-    /// Check if this coordinator is the first registered for its connection.
     private func isFirstCoordinatorForConnection() -> Bool {
         Self.activeCoordinators.values
             .first { $0.connectionId == self.connectionId } === self
@@ -712,11 +576,7 @@ final class MainContentCoordinator: ObservableObject {
         }
     }()
 
-    /// Frees the row data of every background tab that can fetch it again, called when this
-    /// coordinator's window stops being key. The selected tab keeps its rows so returning to the
-    /// window costs no refresh, and `canEvictReloadableTableRows` decides the rest: a query tab, a
-    /// tab holding a pinned result, a failed tab and a tab with work in flight all stay resident,
-    /// because none of them would come back on their own.
+    // Called on resign key. The selected tab keeps its rows; `canEvictReloadableTableRows` keeps tabs that can't reload themselves.
     func evictInactiveRowData() {
         for tab in tabManager.tabs {
             evictReloadableTableRows(for: tab.id)
@@ -767,15 +627,13 @@ final class MainContentCoordinator: ObservableObject {
                 self?.browseCursorCoordinator.browseContainerDidChange()
             }
         tabManager.onTabRetargeted = { [weak self] tabId in
-            self?.dataTabDelegate?.tableViewCoordinator?.flushPendingColumnLayoutPersistence()
+            self?.existingGridModel(forTab: tabId)?.discardEditing()
+            self?.flushColumnLayoutPersistence()
             self?.supersedeExecution(for: tabId)
             self?.releaseRetargetedTabState(for: tabId)
         }
 
-        // Synchronous save at quit time. NotificationCenter with queue: .main
-        // delivers the closure on the main thread, satisfying assumeIsolated's
-        // precondition. The write completes before the process exits — unlike
-        // Task-based saves that need a run loop.
+        // Synchronous: queue .main satisfies assumeIsolated, and the write finishes before exit, unlike Task-based saves.
         terminationObserver = NotificationCenter.default.addObserver(
             forName: NSApplication.willTerminateNotification,
             object: nil,
@@ -783,12 +641,8 @@ final class MainContentCoordinator: ObservableObject {
         ) { [weak self] _ in
             MainActor.assumeIsolated {
                 guard let self else { return }
-                self.dataTabDelegate?.tableViewCoordinator?.flushPendingColumnLayoutPersistence()
-                // Only the first coordinator for this connection saves,
-                // aggregating tabs from all windows to fix last-write-wins bug.
-                // Skip isTearingDown check: during Cmd+Q, onDisappear fires
-                // markTeardownScheduled() before willTerminate, and we still
-                // need to save here.
+                self.flushColumnLayoutPersistence()
+                // First coordinator saves every window's tabs (last-write-wins bug). No isTearingDown check: Cmd+Q marks it before willTerminate.
                 let allTabs = Self.aggregatedTabs(for: self.connectionId)
                 let selectedId = Self.aggregatedSelectedTabId(for: self.connectionId)
                 self.persistence.saveNowSync(tabs: allTabs, selectedTabId: selectedId)
@@ -822,6 +676,7 @@ final class MainContentCoordinator: ObservableObject {
         self.paginationCoordinator = PaginationCoordinator(parent: self)
         self.rowEditingCoordinator = RowEditingCoordinator(parent: self)
         clearedEditsCancellable = resumeWhenEditsClear()
+        gridRepaintCancellable = observeChangeManagerForGridRepaint()
 
         Self.lifecycleLogger.info(
             "[open] MainContentCoordinator.init done connId=\(connection.id, privacy: .public) elapsedMs=\(Int(Date().timeIntervalSince(initStart) * 1_000))"
@@ -840,15 +695,12 @@ final class MainContentCoordinator: ObservableObject {
             current = true
             return prior
         }
-        /// This runs on every appearance, and a connection switch is one: it takes this
-        /// connection's panes out of the window and puts them back. Only the first one starts what
-        /// lives as long as the coordinator.
+        // Runs on every appearance, a connection switch included; only the first starts coordinator-lifetime work.
         if !wasAlreadyActive {
             services.schemaProviderRegistry.setLiveScopeProvider(CoordinatorLiveScopeProvider.shared)
             services.schemaProviderRegistry.retain(for: connection.id)
             registerForPersistence()
-            /// Recovery records which connections have a live coordinator, which only changes here
-            /// and in `teardown()`, so a switch has nothing new to write.
+            // Live coordinators change only here and in `teardown()`, so a switch has nothing new to write.
             SessionRecoveryTracker.sync()
             startPeriodicSave()
             startFileWatcherIfNeeded()
@@ -860,7 +712,6 @@ final class MainContentCoordinator: ObservableObject {
         )
     }
 
-    /// Start watching the database file for external changes (SQLite, DuckDB).
     private func startFileWatcherIfNeeded() {
         guard fileWatcher == nil,
               services.pluginManager.connectionMode(for: connection.type) == .fileBased else { return }
@@ -877,19 +728,14 @@ final class MainContentCoordinator: ObservableObject {
         fileWatcher = watcher
     }
 
-    /// Reveals the assistant, building its view model if this is the first time anything asked for
-    /// one. Activation happens here rather than at window open, which is what keeps a window that
-    /// never opens the assistant from reading the whole conversation history off disk.
+    // Activates lazily so a window that never opens the assistant never reads the conversation history off disk.
     func showAssistant() {
-        /// The gate comes first. Activating builds the view model, whose init reads the stored
-        /// conversations, and the pane would then refuse to open it anyway.
+        // Gate first: activating reads the stored conversations, and the pane would refuse to open anyway.
         guard AppSettingsManager.shared.ai.enabled else { return }
         trailingPaneState?.assistant.activate(connection: connection)
         trailingPaneProxy?.showAssistant()
     }
 
-    /// Reveals the inspector on its JSON rendering. The view mode is part of the inspector's own
-    /// state, so "show the row as JSON" is two facts: which surface, and which rendering.
     func showRowAsJSON() {
         trailingPaneState?.inspector.viewMode = .json
         trailingPaneProxy?.showInspector()
@@ -916,8 +762,7 @@ final class MainContentCoordinator: ObservableObject {
         _teardownScheduled.withLock { $0 = false }
     }
 
-    /// Requests the connection-scoped refresh, which every window of this connection
-    /// shares, then applies the window-local follow-up.
+    // The refresh is connection-scoped and shared by every window; the follow-up is window-local.
     func refreshTables(currentDatabaseOnly: Bool = false) async {
         schemaColumns.removeAll()
         await services.schemaRefreshService.refresh(
@@ -954,9 +799,7 @@ final class MainContentCoordinator: ObservableObject {
         }
     }
 
-    /// Opens the viewer rather than fetching here. Inspecting an object should not put its source
-    /// into an editable query buffer, where the next Cmd+Return runs it, and the viewer refetches
-    /// on its own so a restored tab shows the current definition instead of a stale one.
+    // Opens the viewer, not a query buffer: Cmd+Return would run the source, and the viewer refetches the current definition.
     func showObjectSource(_ objectRef: DatabaseObjectRef) {
         let resolved = objectRef.resolvingDatabase(browseDatabaseName)
         let payload = EditorTabPayload(
@@ -984,12 +827,7 @@ final class MainContentCoordinator: ObservableObject {
         WindowManager.shared.openTab(payload: payload)
     }
 
-    /// Drop sidebar state for tables that no longer exist. The selection lives in this
-    /// window's sidebar, so it is pruned per window.
-    /// Explicit cleanup, called when the connection or the window that hosts it goes away, never
-    /// from a view's `onDisappear`: a workspace switch unparents a connection's panes, which is a
-    /// disappearance the connection is expected to come back from. Releases the schema provider
-    /// synchronously on MainActor so we don't depend on deinit + Task scheduling.
+    // Never from `onDisappear`: a workspace switch unparents panes the connection comes back to. Releases synchronously, not via deinit.
     func teardown() {
         let start = Date()
         Self.lifecycleLogger.info(
@@ -1014,10 +852,7 @@ final class MainContentCoordinator: ObservableObject {
         fileWatcher?.stopWatching(connectionId: connectionId)
         fileWatcher = nil
         cancelAllQueryTasks()
-        /// A cancelled task is not a finished one. `Task.cancel()` is cooperative, so the driver
-        /// call may still be running and will throw on the way out; without this the resulting
-        /// error reaches the ordinary failure path and reports a query that "failed" when what
-        /// actually happened is that the window closed.
+        // `Task.cancel()` is cooperative: the driver call may still throw and report a failure when the window just closed.
         reportEndedExecutions(tabExecution.invalidateAll(reason: .sessionEnded))
         refreshCoalesceTask?.cancel()
         refreshCoalesceTask = nil
@@ -1033,20 +868,16 @@ final class MainContentCoordinator: ObservableObject {
         databaseSearchSession?.stop()
         databaseSearchSession = nil
 
-        dataTabDelegate?.tableViewCoordinator?.releaseData()
+        releaseAllGridModels()
 
         tabSessionRegistry.removeAll()
-        /// The delegate a session owns holds closures the mounted view installed, and those capture
-        /// the view, which holds this coordinator. Dropping the dictionary is not enough to break
-        /// that, so the wiring is released explicitly here as well as at every per-tab drop site.
+        // The session delegate holds view closures that capture this coordinator, so the wiring is released explicitly.
         for session in structureSessions.values { session.releaseViewWiring() }
         structureSessions.removeAll()
         createTableDrafts.removeAll()
         userTypeEditors.removeAll()
         erDiagramModels.removeAll()
         displayFormatsCache.removeAll()
-        displayOrderCache.removeAll()
-        displayStateCache.removeAll()
         tableMetadataCache.removeAll()
         schemaColumns.removeAll()
         columnScopeRequeryTask?.cancel()
@@ -1055,8 +886,7 @@ final class MainContentCoordinator: ObservableObject {
         tabManager.tabs.removeAll()
         tabManager.selectedTabId = nil
 
-        // Release change manager state — pluginDriver holds a strong reference
-        // to the entire database driver which prevents deallocation
+        // pluginDriver strongly holds the whole database driver, which blocks deallocation.
         changeManager.clearChanges()
         changeManager.pluginDriver = nil
 
@@ -1074,10 +904,7 @@ final class MainContentCoordinator: ObservableObject {
         let connectionId = connection.id
         let alreadyHandled = _didTeardown.withLock { $0 } || _teardownScheduled.withLock { $0 }
 
-        // Never-activated coordinators are throwaway instances created by SwiftUI
-        // during body re-evaluation — @State only keeps the first, rest are discarded.
-        // Retain is paired with `markActivated`, so a never-activated coordinator
-        // never retained the schema provider and must not release it here.
+        // Never-activated coordinators are SwiftUI throwaways that never retained the schema provider, so must not release it.
         guard _didActivate.withLock({ $0 }) else {
             let id = instanceId
             Task { @MainActor in
@@ -1103,7 +930,7 @@ final class MainContentCoordinator: ObservableObject {
 
     // MARK: - Initialization Actions
 
-    /// Synchronous toolbar setup — no I/O, safe to call inline
+    // No I/O, safe to call inline.
     func initializeToolbar() {
         toolbarState.update(from: connection)
 
@@ -1112,15 +939,13 @@ final class MainContentCoordinator: ObservableObject {
         }
     }
 
-    /// Load schema if not already loaded by another window for this connection.
-    /// A second window on a connection, or this view mounting again, finds the schema loaded and
-    /// leaves it alone instead of reloading the autocomplete every window shares.
+    // A second window or a remount finds the schema loaded and leaves the shared autocomplete alone.
     func loadSchemaIfNeeded() async {
         loadSchemaOnActivation()
         await schemaLoadTask?.value
     }
 
-    /// Initialize view with connection info and load schema (legacy — used by first window)
+    // Legacy, used by the first window.
     func initializeView() async {
         initializeToolbar()
         await loadSchemaIfNeeded()
@@ -1137,16 +962,14 @@ final class MainContentCoordinator: ObservableObject {
             traceExecutionBlocked(tabId: tab.id, site: "runQuery")
             return
         }
+        commitActiveGridEdit()
 
         if tab.tabType == .table {
             executeTableTabQueryDirectly(trigger: trigger, viewport: viewport)
             return
         }
 
-        /// The offset says where the SQL sits in the tab's query, so each result can point back at the statement that
-        /// produced it. The selection and the statement at the caret both hand over untrimmed text with an exact
-        /// offset and let the scanner do the trimming, which keeps the two from having to agree about how much
-        /// whitespace was dropped.
+        // The offset lets each result point back at its statement. Both paths pass untrimmed text and let the scanner trim.
         let target = selectionOrStatementAtCursor(in: tab.content.query)
         executeResolvedSQL(
             target.sql, tabIndex: index, bypassRowLimit: bypassRowLimit,
@@ -1154,13 +977,7 @@ final class MainContentCoordinator: ObservableObject {
         )
     }
 
-    /// Runs one statement, named by its own text rather than by where the caret happens to be.
-    ///
-    /// The gutter's run control draws itself from the same scan this executes through, so the control runs the
-    /// statement it sits beside even when the caret is somewhere else entirely. It hands over the SQL rather than a
-    /// range on purpose: the editor's text and the tab's binding are two strings that can differ for a moment, and a
-    /// range resolved against the wrong one truncates silently. Past that it is the ordinary path, so parameters, safe
-    /// mode and the execution gate all apply exactly as they do to any other run.
+    // Takes SQL, not a range: the editor text and the tab binding can briefly differ, and a range on the wrong one truncates silently.
     @discardableResult
     func runStatement(_ sql: String, sourceOffset: Int? = nil) -> Bool {
         guard let (tab, index) = tabManager.selectedTabAndIndex, tab.tabType == .query else { return false }
@@ -1168,18 +985,12 @@ final class MainContentCoordinator: ObservableObject {
             traceExecutionBlocked(tabId: tab.id, site: "runStatement")
             return false
         }
+        commitActiveGridEdit()
 
         return executeResolvedSQL(sql, tabIndex: index, bypassRowLimit: false, sourceOffset: sourceOffset)
     }
 
-    /// Everything both run paths do once the SQL to run has been decided.
-    ///
-    /// Shared so that a statement run from the gutter and a statement run from the caret cannot drift apart on
-    /// parameter handling, which is the half of this that is easy to forget.
-    ///
-    /// Returns whether the SQL was actually dispatched. It is not when the statement carries parameters whose panel
-    /// has yet to be filled in: that opens the panel and runs nothing, and a caller that advances the caret on the
-    /// strength of a run would then be pointing at the wrong statement when the reader presses again.
+    // Returns false when a parameter panel opens instead, so callers don't advance the caret on a run that didn't happen.
     @discardableResult
     private func executeResolvedSQL(
         _ sql: String,
@@ -1225,11 +1036,7 @@ final class MainContentCoordinator: ObservableObject {
         return true
     }
 
-    /// Execute table tab query directly.
-    /// Table tab queries are always app-generated SELECTs, so they skip dangerous-query
-    /// checks but still respect safe mode levels that apply to all queries.
-    /// Returns the confirmation task when Safe Mode asks before the load runs.
-    /// A table tab changes source only through `replaceTabContent`, so every run here re-reads its own.
+    // App-built SELECTs skip dangerous-query checks but keep safe mode. Returns the confirmation task when Safe Mode asks first.
     @discardableResult
     func executeTableTabQueryDirectly(
         trigger: TableLoadTrigger = .userInitiated,
@@ -1268,10 +1075,7 @@ final class MainContentCoordinator: ObservableObject {
                     )
                 )
                 isShowingSafeModePrompt = false
-                /// The sheet holds this window, not a link or an agent selecting another table under
-                /// it, and the answer is about the statement it showed. Run on whatever tab was
-                /// selected by then, it put this table's rows under another table's name. The text
-                /// alone does not name the statement: a Redis database switch keeps the same SCAN.
+                // Only on the tab and table the sheet showed: elsewhere it put these rows under another name; SQL alone misses a Redis db switch.
                 let asked = tabManager.tabs.first(where: { $0.id == tabId })
                 guard tabManager.selectedTabId == tabId,
                       let asked,
@@ -1388,7 +1192,7 @@ final class MainContentCoordinator: ObservableObject {
 
         let needsDefinition = tabSessionRegistry.needsDefinition(tabId)
         let needsMetadataFetch = tableName.map { isEditable && !isMetadataCached(tabId: tabId, tableName: $0) } ?? false
-        /// Captured now, while the result this decision was made against is still the active one.
+        // Captured now, while the result this decision was made against is still the active one.
         let cachedMetadata: ParsedSchemaMetadata? = needsMetadataFetch ? nil : ParsedSchemaMetadata.cached(
             rows: tabSessionRegistry.tableRows(for: tabId),
             primaryKeyColumns: tabManager.tabs[index].tableContext.primaryKeyColumns
@@ -1452,20 +1256,14 @@ final class MainContentCoordinator: ObservableObject {
                 let inlineMeta = needsMetadataFetch
                     ? QueryExecutor.inlineMetadata(from: fetchResult.resultColumnMeta, columns: fetchResult.columns)
                     : nil
-                /// After a definition change the rows and the definition commit together, so the grid
-                /// never holds the new columns under the old keys, defaults or generated columns.
+                // Rows and definition commit together after a definition change, so new columns never sit under old keys or defaults.
                 let definition = needsDefinition ? try? await schemaTask?.value : nil
 
                 let applied = await MainActor.run { [weak self] () -> Bool in
                     guard let self else { return false }
                     traceFetchCompleted(traceToken, began: fetchBeganAt, ended: fetchEndedAt, result: fetchResult)
 
-                    // Every write below belongs to whoever owns the tab now. A superseded result
-                    // that cleared the spinner or nilled the task handle would be reporting on a
-                    // query that is still running, so the gate comes before all of them. Settling
-                    // is that gate: it answers and releases in one step, and it comes before the
-                    // cancellation check rather than sharing a guard with it, because a short
-                    // circuit there would leave the tab claimed forever and refusing later runs.
+                    // Settle first: it gates every write below, and sharing a guard with the cancel check would leave the tab claimed forever.
                     guard tabExecution.settle(claim) else {
                         traceStaleResultDropped(traceToken)
                         return false
@@ -1519,21 +1317,14 @@ final class MainContentCoordinator: ObservableObject {
                     )
                     return true
                 }
-                /// Phase 2 writes keys, defaults and a row count onto whatever the tab holds when it
-                /// lands. A result that lost the tab to a retarget would describe its own table on
-                /// the next one, so only the execution that applied its rows may start it.
+                // Phase 2 writes onto whatever the tab holds, so only the execution that applied its rows may start it.
                 guard applied else {
                     schemaTask?.cancel()
                     return
                 }
 
                 if isEditable, let tableName {
-                    /// Committing to phase 2 is what makes the total pending, so it is recorded here
-                    /// rather than inside `resolveRowCount`. On a first open the metadata arm reaches
-                    /// that function only after a Task hop and the schema round trip, and phase 1 has
-                    /// already cleared `isLoading` synchronously, so the tab spends the whole fetch
-                    /// looking settled with no total: the readout states a row count it is about to
-                    /// replace, and `Count Exactly` is offered against a total nobody has yet.
+                    // Marked pending here: phase 1 clears `isLoading` first, so without it the tab looks settled and offers Count Exactly early.
                     tabManager.mutate(tabId: tabId) { $0.pagination.isCountPending = true }
                     launchPhase2(
                         tableName: tableName,
@@ -1571,9 +1362,7 @@ final class MainContentCoordinator: ObservableObject {
         let editorLanguage = services.pluginManager.editorLanguage(for: connection.type)
         let pluginBuildsBrowse = (services.databaseManager.driver(for: connectionId) as? PluginDriverAdapter)?
             .queryBuildingPluginDriver != nil
-        /// An engine whose plugin writes its own browse, or whose language is not SQL, gets no table from a query's
-        /// text, and the name a query tab carries came from an earlier result or an older build, so it can name
-        /// another collection. A pipeline's `_id` can also be a group key that names an unrelated document.
+        // Plugin-built browse or non-SQL: no table from query text; a tab's stored name or a pipeline `_id` can name another collection.
         let usesNoSQLBrowsing = editorLanguage != .sql || pluginBuildsBrowse
         if tab.tabType != .table, usesNoSQLBrowsing {
             return (nil, false)
diff --git a/apple/TablePro/Views/Main/MainContentView.swift b/apple/TablePro/Views/Main/MainContentView.swift
index 25b61e6911..fdc7b3f76a 100644
--- a/apple/TablePro/Views/Main/MainContentView.swift
+++ b/apple/TablePro/Views/Main/MainContentView.swift
@@ -2,30 +2,19 @@
 //  MainContentView.swift
 //  TablePro
 //
-//  Main content view combining query editor and results table.
-//  Refactored to use coordinator pattern for business logic separation.
-//
-//  Extensions:
-//  - MainContentView+Bindings.swift — computed bindings and trigger types
-//  - MainContentView+EventHandlers.swift — tab/table selection, sidebar edit handling
-//  - MainContentView+Setup.swift — initialization, command actions, database switching
-//  - MainContentView+Helpers.swift — helper methods, inspector context
-//  - MainContentView+Modifiers.swift — toolbar tint, focused command actions, preview
-//
 
 import Combine
 import os
 import SwiftUI
 import TableProPluginKit
 
-/// Main content view - thin presentation layer
 struct MainContentView: View {
     nonisolated static let lifecycleLogger = Logger(subsystem: "com.TablePro", category: "NativeTabLifecycle")
 
     // MARK: - Properties
 
     let connection: DatabaseConnection
-    /// Payload identifying what this window-tab should display (nil = default query tab)
+    // nil means the default query tab.
     let payload: EditorTabPayload?
 
     // Shared state from parent
@@ -56,9 +45,7 @@ struct MainContentView: View {
     @State var queryResultsSummaryCache: (tabId: UUID, version: Int, summary: String?)?
     @State var inspectorUpdateTask: Task<Void, Never>?
     @State var inspectorContextRefreshTask: Task<Void, Never>?
-    /// Stable identifier for this window in WindowLifecycleMonitor
     @State var windowId = UUID()
-    /// Reference to this view's NSWindow for filtering notifications
     @State var viewWindow: NSWindow?
 
     // MARK: - Environment
@@ -138,8 +125,7 @@ struct MainContentView: View {
 
     // MARK: - Sheet Content
 
-    /// Connection with the active database from the current session,
-    /// so export/import dialogs see the database the user actually switched to.
+    // Export and import dialogs need the database the user switched to, not the saved one.
     var connectionWithCurrentDatabase: DatabaseConnection {
         var conn = connection
         if let currentDB = DatabaseManager.shared.session(for: connection.id)?.browseDatabase {
@@ -148,9 +134,7 @@ struct MainContentView: View {
         return conn
     }
 
-    /// Exporting a container names the database that container lives in, which is not always the
-    /// one being browsed. The dialog scopes every list and the export itself to this connection's
-    /// database, so naming it here is what makes exporting another database show that database.
+    // Exporting another database's container has to name that database; the dialog scopes everything to this one.
     var exportConnection: DatabaseConnection {
         var conn = connectionWithCurrentDatabase
         if let scoped = coordinator.exportPreselection?.scopedDatabase, !scoped.isEmpty {
@@ -159,11 +143,7 @@ struct MainContentView: View {
         return conn
     }
 
-    /// Returns the appropriate sheet view for the given `ActiveSheet` case.
-    /// Uses a dismissal binding that sets `coordinator.activeSheet = nil` when the
-    /// child view sets `isPresented = false`.
-    /// The transfer sheet is built here rather than inline, because `sheetContent(for:)` is one
-    /// switch over every sheet the window can present and is already at the function length limit.
+    // Its own function: sheetContent(for:) switches over every sheet and is already at the function length limit.
     @ViewBuilder
     func transferSheet(tables: Set<String>, schema: String?, dismiss: Binding<Bool>) -> some View {
         TableTransferSheet(
@@ -183,11 +163,7 @@ struct MainContentView: View {
                     coordinator.activeSheet = nil
                     coordinator.exportPreselection = nil
                     coordinator.exportFormatId = nil
-                    /// Cleared on every dismissal, Cancel included. The request holds the closure
-                    /// that runs the rebuild, and that closure holds the structure view, which
-                    /// holds this coordinator; leaving it set after a cancel keeps the cycle alive
-                    /// for the window's life and offers a stale plan to whatever opens the sheet
-                    /// next.
+                    // Cleared on every dismissal: the request's closure holds this coordinator, so a kept one leaks and offers a stale plan.
                     coordinator.tableRebuildRequest = nil
                 }
             }
@@ -330,9 +306,6 @@ struct MainContentView: View {
         }
     }
 
-    /// Trigger for toolbar pending-changes badge — combines all four sources that
-    /// contribute to `hasPendingChanges`. Replaces four separate handlers that each
-    /// called `updateToolbarPendingState()`.
     private var pendingChangeTrigger: PendingChangeTrigger {
         PendingChangeTrigger(
             hasDataChanges: changeManager.hasChanges,
@@ -348,7 +321,7 @@ struct MainContentView: View {
         )
     }
 
-    /// Split into two halves to help the Swift type checker with the long modifier chain.
+    // Split in two to help the Swift type checker with the long modifier chain.
     private var bodyContent: some View {
         bodyContentCore
             .background {
@@ -365,40 +338,41 @@ struct MainContentView: View {
             })
             .modifier(InspectorValueLoadModifier(
                 inspector: trailingPaneState.inspector,
-                selection: coordinator.selectionState,
+                model: gridSelectionOwner == .dataGrid ? coordinator.activeGridModel : nil,
                 tabId: currentTab?.id,
-                selectsDataRows: gridSelectionOwner == .dataGrid,
                 contentVersion: currentTab?.schemaVersion ?? 0
-            ) { [coordinator] tabId, displayRow in
-                await coordinator.loadInspectorRowValues(tabId: tabId, displayRow: displayRow)
+            ) { [coordinator] tabId, rowID in
+                await coordinator.loadInspectorRowValues(tabId: tabId, rowID: rowID)
             })
-            /// Keyed on the connection alone. The only driver that answers `fetchSessionContexts`
-            /// is Snowflake, which pays two round trips for it, so this must not reload per query.
-            /// It lives with the connection's content rather than with the toolbar control it used
-            /// to feed, because the Database menu is what offers these now and a menu has no view
-            /// to hang a `task` on.
+            .background {
+                if let model = coordinator.activeGridModel {
+                    GridSelectionWatcher(
+                        model: model,
+                        onAttach: { scheduleInspectorUpdate() },
+                        onChange: { rowsChanged in handleGridSelectionChange(rowsChanged: rowsChanged) }
+                    )
+                    .id(ObjectIdentifier(model))
+                }
+            }
+            .onReceive(coordinator.gridCellsEdited) { _ in
+                scheduleInspectorUpdate()
+            }
+            // Keyed on the connection alone: Snowflake, the only driver that answers, pays two round trips for it.
             .task(id: coordinator.toolbarState.connectionState) {
                 await coordinator.loadSessionContexts()
             }
             .onChange(of: inspectorTrigger) { _ in
                 scheduleInspectorUpdate()
             }
-            /// The numbers land after the rows that moved the trigger above, and a comment refetch
-            /// moves nothing else, so the snapshot follows the cache on its own. Only the snapshot:
-            /// the edit state does not depend on them, and rebuilding it would end a typed undo run.
+            // Only the snapshot: rebuilding the edit state would end a typed undo run.
             .onChange(of: tableMetadataForCurrentTab) { _ in
                 updateInspectorContext()
             }
-            /// The JSON rendering draws the snapshot the context carries, and an edit made in the
-            /// fields rendering changes the row under it without moving anything `InspectorTrigger`
-            /// watches. Rebuilding on the switch is enough: the two renderings are never on screen
-            /// together, so the stale snapshot is only ever reached by switching to it.
+            // An edit in the fields rendering moves nothing InspectorTrigger watches; the two renderings are never on screen together.
             .onValueChange(of: \.viewMode, in: trailingPaneState.inspector) { _, _ in
                 updateInspectorContext()
             }
-            /// A value window detached from a field goes on writing while the JSON rendering is the
-            /// one on screen, and it moves nothing the trigger above watches. Debounced, because it
-            /// commits per keystroke and rebuilding the JSON tree cancels the reader's fetches.
+            // Debounced: a detached value window commits per keystroke, and rebuilding the JSON tree cancels the reader's fetches.
             .onReceive(coordinator.inspectorRowContentChanged) { _ in
                 scheduleInspectorContextRefresh()
             }
@@ -478,16 +452,23 @@ struct MainContentView: View {
                 }
                 handleTableSelectionChange(from: oldTables, to: newTables)
             }
-            /// A background reload of the same container must not take a selection out from under
-            /// the user. Every other input re-asserts unconditionally: a container switch above all,
-            /// because a selection made in the container being left is not one in the container
-            /// arriving.
+            // A background reload of the same container must not take the selection out from under the user.
             .onChange(of: tables) { _ in
                 guard coordinator.windowSidebarState.acceptsObjectMarkRefresh else { return }
                 coordinator.syncSidebarObjectSelection()
             }
     }
 
+    // Any grid's selection counts, a query result's as much as a table's: the setting is "on row select", not on cursor moves.
+    private func handleGridSelectionChange(rowsChanged: Bool) {
+        if rowsChanged,
+           coordinator.activeGridModel?.selection.isEmpty == false,
+           AppSettingsManager.shared.dataGrid.autoShowInspector {
+            coordinator.trailingPaneProxy?.revealInspectorForSelection()
+        }
+        scheduleInspectorUpdate()
+    }
+
     // MARK: - Main Content
 
     private var mainContentView: some View {
@@ -520,31 +501,6 @@ struct MainContentView: View {
             connection: connection,
             windowId: windowId,
             connectionId: connection.id,
-            selectionState: coordinator.selectionState,
-            onCellEdit: { rowIndex, colIndex, value in
-                coordinator.updateCellInTab(
-                    rowIndex: rowIndex, columnIndex: colIndex, value: value)
-                scheduleInspectorUpdate()
-            },
-            onSortStateChanged: { newState in
-                coordinator.handleSortStateChanged(newState)
-            },
-            onAddRow: {
-                coordinator.addNewRow()
-            },
-            onSelectionChange: { newIndices in
-                /// Any grid selection counts, not just a table tab's. The setting is called
-                /// "Auto-show inspector on row select" and both docs pages describe it that way,
-                /// but it was gated on `tabType == .table`, so picking a row in a query result did
-                /// nothing and the setting read as intermittently broken rather than scoped.
-                if !newIndices.isEmpty, AppSettingsManager.shared.dataGrid.autoShowInspector {
-                    coordinator.trailingPaneProxy?.revealInspectorForSelection()
-                }
-                scheduleInspectorUpdate()
-            },
-            onFilterColumn: { columnName in
-                coordinator.addFilterForColumn(columnName)
-            },
             onFirstPage: {
                 coordinator.goToFirstPage()
             },
diff --git a/apple/TablePro/Views/QueryPlan/QueryPlanDiagramView.swift b/apple/TablePro/Views/QueryPlan/QueryPlanDiagramView.swift
index 1b9e5e5ffa..bf48e11048 100644
--- a/apple/TablePro/Views/QueryPlan/QueryPlanDiagramView.swift
+++ b/apple/TablePro/Views/QueryPlan/QueryPlanDiagramView.swift
@@ -1,11 +1,3 @@
-//
-//  QueryPlanDiagramView.swift
-//  TablePro
-//
-//  EXPLAIN plan diagram: boxes and arrows on an AppKit-magnified canvas, so pan and zoom
-//  behave the way every other document surface on macOS does.
-//
-
 import SwiftUI
 import TableProTheme
 
@@ -13,11 +5,10 @@ struct QueryPlanDiagramView: View {
     @Binding var selectedNodeId: UUID?
     @Environment(\.colorScheme) private var colorScheme
 
-    /// Owned by the plan's `QueryPlanViewState`, because this view goes away on every mode switch.
+    // Owned by the plan's `QueryPlanViewState`: this view goes away on every mode switch.
     let viewport: DiagramViewportController
 
-    /// Derived from the plan on every update, so a second EXPLAIN in the same tab redraws
-    /// instead of keeping the layout the first one produced.
+    // Derived on every update, so a second EXPLAIN in the same tab redraws.
     private let layout: QueryPlanDiagramLayout
 
     init(plan: QueryPlan, selectedNodeId: Binding<UUID?>, viewport: DiagramViewportController) {
@@ -76,9 +67,7 @@ struct QueryPlanDiagramView: View {
     }
 }
 
-/// A non-interactive copy at natural scale, so an export never captures the current zoom, scroll
-/// offset or selection. `ImageRenderer` draws in the light scheme whatever the window shows, so the
-/// canvas's own scheme is passed in.
+// `ImageRenderer` draws in the light scheme whatever the window shows, so the canvas's scheme is passed in.
 struct QueryPlanDiagramExportCanvas: View {
     let layout: QueryPlanDiagramLayout
     let colorScheme: ColorScheme
@@ -110,8 +99,7 @@ struct QueryPlanDiagramExportCanvas: View {
 
 // MARK: - Drawing
 
-/// What the canvas view hosts: every step and arrow, drawn at the layout's own coordinates. It takes
-/// no input and publishes nothing to accessibility, both of which `QueryPlanDiagramCanvasView` owns.
+// Input and accessibility belong to `QueryPlanDiagramCanvasView`.
 struct QueryPlanDiagramDrawing: View {
     let layout: QueryPlanDiagramLayout
     let selectedNodeId: UUID?
@@ -135,10 +123,7 @@ struct QueryPlanDiagramDrawing: View {
 
 // MARK: - Arrow Layer
 
-/// Shapes rather than a `Canvas`. A `Canvas` inside a magnifying `NSScrollView` stops painting past
-/// `contentSize * magnification + 128` document points once magnification reaches 0.5, so a plan
-/// zoomed out lost its arrows while its nodes, being ordinary views, stayed (#2692). The export
-/// canvas is never magnified and draws the same arrows from the same geometry.
+// Shapes, not a `Canvas`: a `Canvas` in a magnified `NSScrollView` stops painting at 0.5 magnification (#2692).
 struct QueryPlanArrowsView: View {
     let arrows: [QueryPlanDiagramLayout.Arrow]
     let size: CGSize
@@ -161,9 +146,7 @@ struct QueryPlanArrowsView: View {
         return path
     }
 
-    /// One shape for every curve and one for every head, rather than one view per arrow. A shape
-    /// view is sized to its own path, so a per-arrow view would be laid out at its bounding box and
-    /// centred, which moves the arrow off the node it points at.
+    // A per-arrow shape view is laid out at its bounding box and centred, off the node it points at.
     private struct Combined: Shape {
         let paths: [Path]
 
@@ -188,8 +171,6 @@ struct QueryPlanArrowsView: View {
 
 struct QueryPlanDiagramNodeView: View {
     @Environment(\.accessibilityDifferentiateWithoutColor) private var differentiateWithoutColor
-    @Environment(\.colorSchemeContrast) private var contrast
-    @ObservedObject private var themeEngine = ThemeEngine.shared
 
     let node: QueryPlanNode
     let isSelected: Bool
@@ -264,9 +245,7 @@ struct QueryPlanDiagramNodeView: View {
         node.severity?.tint(differentiateWithoutColor: differentiateWithoutColor) ?? .secondary
     }
 
-    /// The grid outlines its own selection with the focus border, so a selected step does too.
-    private var stroke: AnyShapeStyle {
-        guard isSelected else { return AnyShapeStyle(tint) }
-        return ThemeShapeStyle.style(.gridFocusBorder, native: Color.accentColor, engine: themeEngine, contrast: contrast)
+    private var stroke: Color {
+        isSelected ? .accentColor : tint
     }
 }
diff --git a/apple/TablePro/Views/Results/CellInteractionResolver.swift b/apple/TablePro/Views/Results/CellInteractionResolver.swift
index dcba244658..aa64b5e819 100644
--- a/apple/TablePro/Views/Results/CellInteractionResolver.swift
+++ b/apple/TablePro/Views/Results/CellInteractionResolver.swift
@@ -14,10 +14,7 @@ internal struct CellContext: Equatable {
     let isBinaryValue: Bool
     let isForeignKey: Bool
     let displayFormatOverride: ValueDisplayFormat?
-
-    /// What the value itself turned out to be, resolved once by the caller that holds the typed
-    /// cell. It reaches the resolver rather than being sniffed here so the row inspector, which
-    /// resolves through `CellValueContentDetector` too, cannot reach a different answer.
+    // Resolved by the caller that holds the typed cell, so the row inspector and the grid reach one answer.
     let detectedContent: CellValueContent
 
     init(
@@ -44,7 +41,7 @@ internal struct CellContext: Equatable {
 }
 
 internal enum CellInteractionMode: Equatable {
-    case viewInline(value: String)
+    case viewText(value: String)
     case viewJson
     case viewBlob
     case viewPhpSerialized
@@ -54,7 +51,7 @@ internal enum CellInteractionMode: Equatable {
     case viewVector
 
     case editInline(value: String)
-    case editOverlay(value: String)
+    case editText(value: String)
     case editForeignKey
     case editJson
     case editBlob
@@ -65,6 +62,12 @@ internal enum CellInteractionMode: Equatable {
 }
 
 internal struct CellInteractionResolver {
+    static let inlineLengthLimit = 256
+
+    static func editsInPopover(_ text: String) -> Bool {
+        (text as NSString).length > inlineLengthLimit || text.containsLineBreak
+    }
+
     func resolve(_ context: CellContext) -> CellInteractionMode {
         guard !context.isRowDeleted else { return .blocked }
 
@@ -101,17 +104,14 @@ internal struct CellInteractionResolver {
         }
     }
 
-    /// A writable foreign key column picks from the rows it points at rather than taking a typed
-    /// key on trust. Resolved here rather than ahead of the blob and structured-format branches, so
-    /// a foreign key that is also a blob, JSON or PHP-serialized value keeps the editor its content
-    /// needs, and a read-only cell keeps every viewer it has.
+    // Last, so a foreign key holding a blob or JSON keeps the editor its content needs.
     private func plainText(for context: CellContext, isReadOnly: Bool) -> CellInteractionMode {
         if isReadOnly {
-            return .viewInline(value: context.value ?? "NULL")
+            return .viewText(value: context.value ?? "NULL")
         }
         if context.isForeignKey { return .editForeignKey }
         let value = context.value ?? ""
-        if value.containsLineBreak { return .editOverlay(value: value) }
+        if Self.editsInPopover(value) { return .editText(value: value) }
         return .editInline(value: value)
     }
 
diff --git a/apple/TablePro/Views/Results/CellOverlayBase.swift b/apple/TablePro/Views/Results/CellOverlayBase.swift
deleted file mode 100644
index 4eadc03e16..0000000000
--- a/apple/TablePro/Views/Results/CellOverlayBase.swift
+++ /dev/null
@@ -1,342 +0,0 @@
-//
-//  CellOverlayBase.swift
-//  TablePro
-//
-
-import AppKit
-import Combine
-import TableProTheme
-
-enum CellOverlayDismissReason {
-    case userAction
-    case scroll
-    case columnGeometry
-    case appResign
-    case windowResignKey
-    case outsideClick
-}
-
-@MainActor
-class CellOverlayBase: NSObject {
-    private var container: CellOverlayContainerView?
-    private weak var hostTableView: NSTableView?
-    private var scrollObserver: NSObjectProtocol?
-    private var columnGeometryObservers: [any NSObjectProtocol] = []
-    private var appResignObserver: NSObjectProtocol?
-    private var windowResignKeyObserver: NSObjectProtocol?
-    private var outsideClickMonitor: Any?
-    private var isFollowingGrid = false
-    /// Held for the life of the open overlay: its subscription is what repaints the text on a theme
-    /// change.
-    private var textStyle: ThemeTextViewStyle?
-    private var invisibleCharacters: InvisibleCharacterTextDisplay?
-    var onRemove: (() -> Void)?
-
-    private(set) var row: Int = -1
-    private(set) var column: Int = -1
-    private(set) var columnIndex: Int = -1
-
-    var isActive: Bool { container != nil }
-    var containerView: NSView? { container }
-    var tableView: NSTableView? { hostTableView }
-
-    func install(
-        in tableView: NSTableView,
-        row: Int,
-        column: Int,
-        columnIndex: Int,
-        container: CellOverlayContainerView
-    ) {
-        guard let scrollView = tableView.enclosingScrollView else { return }
-        self.hostTableView = tableView
-        self.row = row
-        self.column = column
-        self.columnIndex = columnIndex
-        Self.mount(container, over: tableView, in: scrollView, column: column)
-        self.container = container
-        setOverlayCell(CellPosition(row: row, column: columnIndex), in: tableView)
-        selectionOverlay(in: tableView)?.needsDisplay = true
-        installDismissObservers()
-    }
-
-    private static func mount(
-        _ container: CellOverlayContainerView,
-        over tableView: NSTableView,
-        in scrollView: NSScrollView,
-        column: Int
-    ) {
-        container.frame = scrollView.convert(container.frame, from: tableView)
-        scrollView.addSubview(container, positioned: .above, relativeTo: layer(for: column, of: tableView, in: scrollView))
-    }
-
-    // Above AppKit's floating container only for a frozen cell, which the band would otherwise cover.
-    private static func layer(for column: Int, of tableView: NSTableView, in scrollView: NSScrollView) -> NSView {
-        guard let coordinator = (tableView as? KeyHandlingTableView)?.coordinator,
-              coordinator.freezingBand()?.pins(column) == true,
-              let container = coordinator.rowGutter?.superview,
-              container.superview === scrollView else { return scrollView.contentView }
-        return container
-    }
-
-    // Where the cell is on screen, which for a frozen column is the pinned band, not its home.
-    static func displayedCellFrame(in tableView: NSTableView, column: Int, row: Int) -> NSRect {
-        let frame = tableView.frameOfCell(atColumn: column, row: row)
-        return (tableView as? KeyHandlingTableView)?.coordinator?.freezingBand()?.displayed(frame, ofColumn: column) ?? frame
-    }
-
-    /// The cell under the overlay draws no text of its own behind it. A drawn cell has no view to
-    /// carry that, so the coordinator holds it and repaints the cell either side of the change.
-    private func setOverlayCell(_ position: CellPosition?, in tableView: NSTableView) {
-        (tableView as? KeyHandlingTableView)?.coordinator?.overlayCell = position
-    }
-
-    private func selectionOverlay(in tableView: NSTableView) -> GridSelectionOverlay? {
-        (tableView as? KeyHandlingTableView)?.selectionOverlay
-    }
-
-    func handleDismiss(reason: CellOverlayDismissReason) {
-        removeOverlay()
-    }
-
-    func removeOverlay() {
-        guard let activeContainer = container else { return }
-        removeDismissObservers()
-        if let hostTableView {
-            setOverlayCell(nil, in: hostTableView)
-            selectionOverlay(in: hostTableView)?.needsDisplay = true
-        }
-        activeContainer.removeFromSuperview()
-        container = nil
-        textStyle = nil
-        invisibleCharacters = nil
-        if let hostTableView {
-            hostTableView.window?.makeFirstResponder(hostTableView)
-        }
-        onRemove?()
-    }
-
-    // A zoom resizes the value and moves its cell, so the overlay follows instead of ending the edit as a
-    // column resize or a scroll would.
-    func followGrid(through change: () -> Void) {
-        isFollowingGrid = true
-        defer { isFollowingGrid = false }
-        change()
-        guard let container, let hostTableView, let scrollView = hostTableView.enclosingScrollView,
-              let textView = (container.subviews.first as? NSScrollView)?.documentView as? NSTextView else { return }
-        hostTableView.scrollRowToVisible(row)
-        textView.font = ThemeEngine.shared.valueFont
-        let cellFrame = Self.displayedCellFrame(in: hostTableView, column: column, row: row)
-        container.frame = scrollView.convert(Self.overlayFrame(for: cellFrame, value: textView.string), from: hostTableView)
-    }
-
-    static func overlayFrame(for cellFrame: NSRect, value: String) -> NSRect {
-        let lineHeight = ThemeEngine.shared.dataGridFonts.regular.boundingRectForFont.height + 4
-        // A CR on its own breaks the line in the text view as LF does; CRLF is one break.
-        var newlineCount = 0
-        var previous: Unicode.Scalar?
-        for scalar in value.unicodeScalars {
-            if scalar == "\r" || (scalar == "\n" && previous != "\r") {
-                newlineCount += 1
-            }
-            previous = scalar
-        }
-        let lineCount = CGFloat(newlineCount + 1)
-        let contentHeight = max(lineCount * lineHeight + 8, cellFrame.height)
-        let height = min(max(contentHeight, cellFrame.height), 120)
-        return NSRect(x: cellFrame.origin.x, y: cellFrame.origin.y, width: cellFrame.width, height: height)
-    }
-
-    /// The grid's own scope, so an overlay over the theme editor's preview wears the draft.
-    static func themeScope(of tableView: NSTableView) -> ThemeScope {
-        (tableView as? KeyHandlingTableView)?.themeScope ?? .live
-    }
-
-    static func makeContainer(frame: NSRect, scope: ThemeScope) -> CellOverlayContainerView {
-        let container = CellOverlayContainerView(frame: frame)
-        container.wantsLayer = true
-        container.layer?.borderWidth = 2
-        container.layer?.cornerRadius = 2
-        container.layer?.masksToBounds = true
-        container.scope = scope
-        container.applyLayerColors()
-        return container
-    }
-
-    /// A value is content, so the box takes the editor's colors, caret and selection included, the
-    /// way the inspector and the pop-out editor show the same value.
-    func applyTheme(to textView: NSTextView, scope: ThemeScope) {
-        textStyle = ThemeTextViewStyle(textView: textView, scope: scope)
-    }
-
-    // Before the text is set, so the value is laid out once.
-    func markInvisibleCharacters(in textView: NSTextView) {
-        invisibleCharacters = InvisibleCharacterTextDisplay.install(
-            on: textView,
-            isEnabled: AppSettingsManager.shared.dataGrid.showInvisibleCharacters
-        )
-    }
-
-    /// Lays a text view out the way an inline cell overlay needs.
-    ///
-    /// A cell holds one value, so the overlay behaves like a field editor and scrolls a long line
-    /// rather than wrapping it. Wrapping made TextKit 2 lay the whole value out before the overlay
-    /// could appear: measured at 206ms for a 256KB value and 816ms for 1MB, against 7ms unwrapped,
-    /// and the wrapped result was thousands of visual lines in a box 120pt tall (#2381).
-    ///
-    /// `maxSize` is raised with the container because a text view grows only as far as `maxSize`,
-    /// which `init(frame:)` leaves at the frame: without it the long line is clipped at the cell's
-    /// width instead of scrolled, measured as a 140pt document against 344,166pt with it raised.
-    static func applyCellTextLayout(to textView: NSTextView) {
-        let unbounded = NSSize(
-            width: CGFloat.greatestFiniteMagnitude,
-            height: CGFloat.greatestFiniteMagnitude
-        )
-        textView.isVerticallyResizable = true
-        textView.isHorizontallyResizable = true
-        textView.maxSize = unbounded
-        textView.textContainer?.widthTracksTextView = false
-        textView.textContainer?.containerSize = unbounded
-    }
-
-    static func makeScrollView(in container: NSView, scope: ThemeScope) -> NSScrollView {
-        let scrollView = NSScrollView(frame: container.bounds)
-        scrollView.autoresizingMask = [.width, .height]
-        scrollView.hasVerticalScroller = true
-        scrollView.hasHorizontalScroller = false
-        scrollView.autohidesScrollers = true
-        scrollView.borderType = .noBorder
-        scrollView.drawsBackground = true
-        scrollView.backgroundColor = scope.palette.color(.editorBackground, otherwise: .textBackgroundColor)
-        return scrollView
-    }
-
-    private func installDismissObservers() {
-        guard let hostTableView else { return }
-
-        if let clipView = hostTableView.enclosingScrollView?.contentView {
-            scrollObserver = NotificationCenter.default.addObserver(
-                forName: NSView.boundsDidChangeNotification,
-                object: clipView,
-                queue: .main
-            ) { [weak self] _ in
-                MainActor.assumeIsolated {
-                    guard self?.isFollowingGrid == false else { return }
-                    self?.handleDismiss(reason: .scroll)
-                }
-            }
-        }
-
-        columnGeometryObservers = [
-            NSTableView.columnDidResizeNotification,
-            NSTableView.columnDidMoveNotification,
-        ].map { name in
-            NotificationCenter.default.addObserver(forName: name, object: hostTableView, queue: .main) { [weak self] _ in
-                MainActor.assumeIsolated {
-                    guard self?.isFollowingGrid == false else { return }
-                    self?.handleDismiss(reason: .columnGeometry)
-                }
-            }
-        }
-
-        appResignObserver = NotificationCenter.default.addObserver(
-            forName: NSApplication.didResignActiveNotification,
-            object: nil,
-            queue: .main
-        ) { [weak self] _ in
-            MainActor.assumeIsolated {
-                self?.handleDismiss(reason: .appResign)
-            }
-        }
-
-        if let overlayWindow = hostTableView.window {
-            windowResignKeyObserver = NotificationCenter.default.addObserver(
-                forName: NSWindow.didResignKeyNotification,
-                object: overlayWindow,
-                queue: .main
-            ) { [weak self] _ in
-                MainActor.assumeIsolated {
-                    self?.handleDismiss(reason: .windowResignKey)
-                }
-            }
-        }
-
-        outsideClickMonitor = NSEvent.addLocalMonitorForEvents(matching: [.leftMouseDown, .rightMouseDown]) { [weak self] event in
-            MainActor.assumeIsolated {
-                self?.handleOutsideClick(event: event)
-            }
-            return event
-        }
-    }
-
-    private func removeDismissObservers() {
-        if let observer = scrollObserver {
-            NotificationCenter.default.removeObserver(observer)
-            scrollObserver = nil
-        }
-        columnGeometryObservers.forEach(NotificationCenter.default.removeObserver)
-        columnGeometryObservers = []
-        if let observer = appResignObserver {
-            NotificationCenter.default.removeObserver(observer)
-            appResignObserver = nil
-        }
-        if let observer = windowResignKeyObserver {
-            NotificationCenter.default.removeObserver(observer)
-            windowResignKeyObserver = nil
-        }
-        if let monitor = outsideClickMonitor {
-            NSEvent.removeMonitor(monitor)
-            outsideClickMonitor = nil
-        }
-    }
-
-    private func handleOutsideClick(event: NSEvent) {
-        guard let containerView = container,
-              let containerWindow = containerView.window,
-              event.window === containerWindow else { return }
-        let frameInWindow = containerView.convert(containerView.bounds, to: nil)
-        if !frameInWindow.contains(event.locationInWindow) {
-            handleDismiss(reason: .outsideClick)
-        }
-    }
-}
-
-final class CellOverlayContainerView: NSView {
-    override var isFlipped: Bool { true }
-
-    var scope: ThemeScope = .live {
-        didSet {
-            guard scope !== oldValue else { return }
-            themeCancellable = nil
-            subscribeIfInWindow()
-            applyLayerColors()
-        }
-    }
-
-    private var themeCancellable: AnyCancellable?
-
-    override func viewDidMoveToWindow() {
-        super.viewDidMoveToWindow()
-        subscribeIfInWindow()
-    }
-
-    private func subscribeIfInWindow() {
-        guard window != nil, themeCancellable == nil else { return }
-        themeCancellable = scope.changes
-            .receive(on: RunLoop.main)
-            .sink { [weak self] _ in self?.applyLayerColors() }
-    }
-
-    override func viewDidChangeEffectiveAppearance() {
-        super.viewDidChangeEffectiveAppearance()
-        applyLayerColors()
-    }
-
-    /// A `CGColor` is a resolved colour and a layer never resolves it again, so the two layer
-    /// colours are reapplied whenever the appearance or the theme changes under an open overlay.
-    func applyLayerColors() {
-        let appearance = effectiveAppearance
-        let resolved = scope.resolved
-        layer?.borderColor = resolved.cgColor(.gridFocusBorder, in: appearance)
-        layer?.backgroundColor = resolved.cgColor(.editorBackground, otherwise: .textBackgroundColor, in: appearance)
-    }
-}
diff --git a/apple/TablePro/Views/Results/CellOverlayEditor.swift b/apple/TablePro/Views/Results/CellOverlayEditor.swift
deleted file mode 100644
index 12725bdd1c..0000000000
--- a/apple/TablePro/Views/Results/CellOverlayEditor.swift
+++ /dev/null
@@ -1,161 +0,0 @@
-//
-//  CellOverlayEditor.swift
-//  TablePro
-//
-
-import AppKit
-
-@MainActor
-final class CellOverlayEditor: CellOverlayBase, NSTextViewDelegate {
-    private var editorTextView: OverlayTextView?
-    private var initialValue: String = ""
-
-    var onCommit: ((_ row: Int, _ columnIndex: Int, _ newValue: String) -> Void)?
-    var onMovement: ((_ row: Int, _ column: Int, _ movement: CellEditorMovement) -> Void)?
-
-    func show(
-        in tableView: NSTableView,
-        row: Int,
-        column: Int,
-        columnIndex: Int,
-        value: String
-    ) {
-        dismiss(commit: true)
-
-        let cellFrame = Self.displayedCellFrame(in: tableView, column: column, row: row)
-        guard !cellFrame.isEmpty else { return }
-        guard let window = tableView.window else { return }
-
-        let frame = Self.overlayFrame(for: cellFrame, value: value)
-        let scope = Self.themeScope(of: tableView)
-        let containerView = Self.makeContainer(frame: frame, scope: scope)
-        let scrollView = Self.makeScrollView(in: containerView, scope: scope)
-
-        let textView = OverlayTextView(frame: scrollView.bounds)
-        textView.overlayEditor = self
-        textView.isEditable = true
-        textView.isRichText = false
-        textView.allowsUndo = true
-        textView.font = ThemeEngine.shared.valueFont
-        textView.textColor = .labelColor
-        textView.backgroundColor = .textBackgroundColor
-        applyTheme(to: textView, scope: scope)
-        textView.focusRingType = .none
-        Self.applyCellTextLayout(to: textView)
-        markInvisibleCharacters(in: textView)
-        textView.delegate = self
-        textView.string = value
-        textView.selectAll(nil)
-
-        scrollView.documentView = textView
-        containerView.addSubview(scrollView)
-
-        initialValue = value
-        editorTextView = textView
-
-        install(in: tableView, row: row, column: column, columnIndex: columnIndex, container: containerView)
-        window.makeFirstResponder(textView)
-    }
-
-    override func handleDismiss(reason: CellOverlayDismissReason) {
-        dismiss(commit: reason != .columnGeometry)
-    }
-
-    func dismiss(commit: Bool) {
-        guard let activeTextView = editorTextView else { return }
-        let newValue = activeTextView.string
-        let originalValue = initialValue
-        let dismissRow = row
-        let dismissColumnIndex = columnIndex
-
-        editorTextView = nil
-        initialValue = ""
-        removeOverlay()
-
-        if commit, newValue != originalValue {
-            onCommit?(dismissRow, dismissColumnIndex, newValue)
-        }
-    }
-
-    func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
-        if commandSelector == #selector(NSResponder.insertNewline(_:)) {
-            if NSApp.currentEvent?.modifierFlags.contains(.option) == true {
-                textView.insertNewlineIgnoringFieldEditor(nil)
-                return true
-            }
-            dismiss(commit: true)
-            return true
-        }
-
-        if commandSelector == #selector(NSResponder.cancelOperation(_:)) {
-            dismiss(commit: false)
-            return true
-        }
-
-        if commandSelector == #selector(NSResponder.insertTab(_:)) {
-            return leave(with: .tab, from: textView)
-        }
-
-        if commandSelector == #selector(NSResponder.insertBacktab(_:)) {
-            return leave(with: .backtab, from: textView)
-        }
-
-        if commandSelector == #selector(NSResponder.moveUp(_:)) {
-            return leaveVertically(.up, from: textView)
-        }
-
-        if commandSelector == #selector(NSResponder.moveDown(_:)) {
-            return leaveVertically(.down, from: textView)
-        }
-
-        return false
-    }
-
-    /// Only the plain arrows are read. Shift, Option and Command each map to a selector of their
-    /// own, so extending a selection or jumping to the end of the value keeps its native meaning.
-    ///
-    /// An unhandled arrow moves the caret inside marked text, which is what it is for, so a
-    /// composition takes it back rather than having it swallowed.
-    private func leaveVertically(_ movement: CellEditorMovement, from textView: NSTextView) -> Bool {
-        guard !textView.hasMarkedText() else { return false }
-        let exit = CellEditorArrowExit(
-            text: textView.string as NSString,
-            selection: textView.selectedRange()
-        )
-        let leaves = movement == .up ? exit.canExitUp : exit.canExitDown
-        guard leaves else { return false }
-        return leave(with: movement, from: textView)
-    }
-
-    /// A composition in progress owns the keystroke. Until the input method commits it the text
-    /// view holds provisional text, and leaving the cell would save that half-composed value and
-    /// carry the editor off it. The key is swallowed rather than passed back, because a literal
-    /// tab in a cell is not what Tab was pressed for.
-    private func leave(with movement: CellEditorMovement, from textView: NSTextView) -> Bool {
-        guard !textView.hasMarkedText() else { return true }
-        let dismissRow = row, dismissColumn = column
-        dismiss(commit: true)
-        onMovement?(dismissRow, dismissColumn, movement)
-        return true
-    }
-}
-
-private final class OverlayTextView: NSTextView {
-    private let storedUndoManager = UndoManager()
-
-    weak var overlayEditor: CellOverlayEditor?
-
-    private static let menuKeyEquivalents: Set<String> = ["s"]
-
-    override var undoManager: UndoManager? { storedUndoManager }
-
-    override func performKeyEquivalent(with event: NSEvent) -> Bool {
-        if event.modifierFlags.contains(.command),
-           let chars = event.charactersIgnoringModifiers,
-           Self.menuKeyEquivalents.contains(chars) {
-            overlayEditor?.dismiss(commit: true)
-            return false
-        }
-        return super.performKeyEquivalent(with: event)
-    }
-}
diff --git a/apple/TablePro/Views/Results/CellOverlayViewer.swift b/apple/TablePro/Views/Results/CellOverlayViewer.swift
deleted file mode 100644
index 6559c43d52..0000000000
--- a/apple/TablePro/Views/Results/CellOverlayViewer.swift
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-//  CellOverlayViewer.swift
-//  TablePro
-//
-
-import AppKit
-
-@MainActor
-final class CellOverlayViewer: CellOverlayBase, NSTextViewDelegate {
-    func show(
-        in tableView: NSTableView,
-        row: Int,
-        column: Int,
-        columnIndex: Int,
-        value: String
-    ) {
-        removeOverlay()
-
-        let cellFrame = Self.displayedCellFrame(in: tableView, column: column, row: row)
-        guard !cellFrame.isEmpty else { return }
-        guard let window = tableView.window else { return }
-
-        let frame = Self.overlayFrame(for: cellFrame, value: value)
-        let scope = Self.themeScope(of: tableView)
-        let containerView = Self.makeContainer(frame: frame, scope: scope)
-        let scrollView = Self.makeScrollView(in: containerView, scope: scope)
-
-        let textView = NSTextView(frame: scrollView.bounds)
-        textView.isEditable = false
-        textView.isSelectable = true
-        textView.isRichText = false
-        textView.font = ThemeEngine.shared.valueFont
-        textView.textColor = .labelColor
-        textView.backgroundColor = .textBackgroundColor
-        applyTheme(to: textView, scope: scope)
-        Self.applyCellTextLayout(to: textView)
-        markInvisibleCharacters(in: textView)
-        textView.delegate = self
-        textView.string = value
-        textView.selectAll(nil)
-
-        scrollView.documentView = textView
-        containerView.addSubview(scrollView)
-
-        install(in: tableView, row: row, column: column, columnIndex: columnIndex, container: containerView)
-        window.makeFirstResponder(textView)
-    }
-
-    func dismiss() {
-        removeOverlay()
-    }
-
-    func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
-        switch commandSelector {
-        case #selector(NSResponder.insertNewline(_:)),
-             #selector(NSResponder.cancelOperation(_:)),
-             #selector(NSResponder.insertTab(_:)),
-             #selector(NSResponder.insertBacktab(_:)):
-            removeOverlay()
-            return true
-        default:
-            return false
-        }
-    }
-}
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellAccessibilityView.swift b/apple/TablePro/Views/Results/Cells/DataGridCellAccessibilityView.swift
deleted file mode 100644
index f2c2b1634c..0000000000
--- a/apple/TablePro/Views/Results/Cells/DataGridCellAccessibilityView.swift
+++ /dev/null
@@ -1,146 +0,0 @@
-//
-//  DataGridCellAccessibilityView.swift
-//  TablePro
-//
-
-import AppKit
-
-/// Whether anything is reading the data grid through accessibility.
-///
-/// Accessibility is pull-based, and the first question anyone asks the grid is the app's only signal
-/// that a client is attached: `NSWorkspace.isVoiceOverEnabled` covers VoiceOver alone, and nothing
-/// at all reports Switch Control, Voice Control, an inspector or XCUITest. So the grid starts in its
-/// fast shape and changes shape the first time it is asked.
-///
-/// One-way and process-wide: a client that attaches once may detach, but nothing reports that
-/// either, and dropping back would be a second reload for no gain.
-@MainActor
-internal enum DataGridAccessibility {
-    internal static let didActivateNotification = Notification.Name("com.TablePro.DataGridAccessibilityDidActivate")
-
-    /// Written through `markActive()` in the app. Settable so a test can drive both shapes.
-    internal static var isActive = false
-
-    internal static func markActive() {
-        guard !isActive else { return }
-        isActive = true
-        NotificationCenter.default.post(name: didActivateNotification, object: nil)
-    }
-}
-
-/// A data cell's stand-in for an assistive client, mounted only while one is attached.
-///
-/// `NSTableView` builds its `AXCell` tree from cell views and from nothing else. An
-/// `NSAccessibilityElement` published by the row never reaches that tree, whichever attribute
-/// carries the text, whether the attribute is set or overridden, and however the element is
-/// parented: the tree shows AppKit's own placeholder in its place, which is why drawn cells read as
-/// a full grid of correctly placed, permanently blank values. One view per cell is the cost `#2381`
-/// removed, so it is charged only to the sessions that need it.
-///
-/// The view draws nothing and takes no clicks. Its row still paints every cell and still handles
-/// every click, so this carries the text and no pixels.
-@MainActor
-internal final class DataGridCellAccessibilityView: NSView {
-    internal static let reuseIdentifier = NSUserInterfaceItemIdentifier("DataGridCellAccessibilityView")
-
-    private weak var coordinator: TableViewCoordinator?
-    private var seededRow = 0
-    private var dataColumn = 0
-
-    /// The row this cell is showing now, asked of the table rather than remembered, for the reason
-    /// `DataGridRowView.rowIndex` is: an incremental insert or remove moves a mounted cell view to
-    /// its new slot without asking for it again, so a stored index outlives the row it named and the
-    /// cell then speaks a different row's value under the old row's number.
-    private var row: Int {
-        guard let tableView = coordinator?.tableView else { return seededRow }
-        let resolved = tableView.row(for: self)
-        return resolved >= 0 ? resolved : seededRow
-    }
-
-    internal func configure(coordinator: TableViewCoordinator, row: Int, dataColumn: Int) {
-        self.coordinator = coordinator
-        seededRow = row
-        self.dataColumn = dataColumn
-        setAccessibilityColumnIndexRange(NSRange(location: dataColumn, length: 1))
-    }
-
-    /// Answered live for the same reason, rather than stamped in `configure`, so a client reading the
-    /// tree after a row moved is told where the cell is rather than where it was built.
-    override internal func accessibilityRowIndexRange() -> NSRange {
-        NSRange(location: row, length: 1)
-    }
-
-    override internal func hitTest(_ point: NSPoint) -> NSView? { nil }
-
-    // A frozen column's cell is read where the pinned band shows it, not at its home off screen.
-    override internal func accessibilityFrame() -> NSRect {
-        guard let tableView = coordinator?.tableView,
-              let window = tableView.window,
-              let band = coordinator?.freezingBand() else { return super.accessibilityFrame() }
-        let column = tableView.column(for: self)
-        guard band.pins(column) else { return super.accessibilityFrame() }
-        let displayed = band.displayed(tableView.convert(bounds, from: self), ofColumn: column)
-        return window.convertToScreen(tableView.convert(displayed, to: nil))
-    }
-
-    override internal func isAccessibilityElement() -> Bool { true }
-
-    /// Static text inside the `AXCell` that `NSTableView` wraps every cell view in, which is the
-    /// shape the row-number column already publishes and the one VoiceOver expects of a table.
-    ///
-    /// A cell that carries a chevron is a combo box, because it takes typed text and offers a list
-    /// beside it, and that is what `NSComboBoxCell` publishes (measured: AXComboBox, with AXShowMenu
-    /// and AXConfirm). Reporting it as static text would leave the menu unreachable to a client that
-    /// looks for one, which is every client but a sighted pointer.
-    override internal func accessibilityRole() -> NSAccessibility.Role? {
-        if coordinator?.checkboxMark(row: row, columnIndex: dataColumn) != nil { return .checkBox }
-        return coordinator?.presentsComboBoxCell(columnIndex: dataColumn) == true ? .comboBox : .staticText
-    }
-
-    override internal func accessibilityValue() -> Any? {
-        if let mark = coordinator?.checkboxMark(row: row, columnIndex: dataColumn) {
-            return NSNumber(value: mark == .checked)
-        }
-        return text
-    }
-
-    override internal func accessibilityPerformPress() -> Bool {
-        guard coordinator?.toggleCheckbox(row: row, columnIndex: dataColumn) == true else { return false }
-        NSAccessibility.post(element: self, notification: .valueChanged)
-        return true
-    }
-
-    /// Every combination is its own format string rather than pieces joined at run time, so a
-    /// translator sees a whole sentence and can order its parts. The pending change comes before the
-    /// highlight rule, because it is the one the reader is about to save.
-    override internal func accessibilityLabel() -> String? {
-        let pendingChange = coordinator?.pendingChangeDescription(row: row, columnIndex: dataColumn)
-        let highlight = coordinator?.highlightDescription(row: row, columnIndex: dataColumn)
-
-        if let pendingChange, let highlight {
-            return String(
-                format: String(localized: "Row %d, column %d: %@, %@, highlighted where %@"),
-                row + 1, dataColumn + 1, text, pendingChange, highlight
-            )
-        }
-        if let pendingChange {
-            return String(
-                format: String(localized: "Row %d, column %d: %@, %@"),
-                row + 1, dataColumn + 1, text, pendingChange
-            )
-        }
-        if let highlight {
-            return String(
-                format: String(localized: "Row %d, column %d: %@, highlighted where %@"),
-                row + 1, dataColumn + 1, text, highlight
-            )
-        }
-        return String(format: String(localized: "Row %d, column %d: %@"), row + 1, dataColumn + 1, text)
-    }
-
-    /// Read through rather than stored, so an edit, an undo or a display-format change is spoken
-    /// without anything having to remember to stand this view down.
-    private var text: String {
-        coordinator?.accessibilityText(row: row, columnIndex: dataColumn) ?? ""
-    }
-}
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellAccessoryDelegate.swift b/apple/TablePro/Views/Results/Cells/DataGridCellAccessoryDelegate.swift
deleted file mode 100644
index 7507ab145f..0000000000
--- a/apple/TablePro/Views/Results/Cells/DataGridCellAccessoryDelegate.swift
+++ /dev/null
@@ -1,13 +0,0 @@
-//
-//  DataGridCellAccessoryDelegate.swift
-//  TablePro
-//
-
-import Foundation
-
-@MainActor
-protocol DataGridCellAccessoryDelegate: AnyObject {
-    func dataGridCellDidClickFKArrow(row: Int, columnIndex: Int, intent: ReferenceOpenIntent)
-    func dataGridCellDidClickChevron(row: Int, columnIndex: Int)
-    func dataGridCellDidDoubleClick(row: Int, columnIndex: Int)
-}
diff --git a/apple/TablePro/Views/Results/Cells/DataGridCellRegistry.swift b/apple/TablePro/Views/Results/Cells/DataGridCellRegistry.swift
deleted file mode 100644
index 03950b6e61..0000000000
--- a/apple/TablePro/Views/Results/Cells/DataGridCellRegistry.swift
+++ /dev/null
@@ -1,141 +0,0 @@
-//
-//  DataGridCellRegistry.swift
-//  TablePro
-//
-
-import AppKit
-import Combine
-import Foundation
-
-@MainActor
-final class DataGridCellRegistry {
-    weak var accessoryDelegate: DataGridCellAccessoryDelegate?
-
-    private(set) var nullDisplayString: String
-    private(set) var showsInvisibleCharacters: Bool
-    private(set) var palette: DataGridCellPalette
-    private(set) var scope: ThemeScope
-    private var paletteKey: PaletteKey
-    private var settingsCancellable: AnyCancellable?
-
-    private let rowNumberCellIdentifier = NSUserInterfaceItemIdentifier("RowNumberCellView")
-
-    private struct PaletteKey: Equatable {
-        let revision: Int
-        let generation: Int
-        let appearance: NSAppearance.Name
-    }
-
-    init(scope: ThemeScope = .live) {
-        self.scope = scope
-        nullDisplayString = AppSettingsManager.shared.dataGrid.nullDisplay
-        showsInvisibleCharacters = AppSettingsManager.shared.dataGrid.showInvisibleCharacters
-        let appearance = NSApp?.effectiveAppearance ?? NSAppearance.currentDrawing()
-        paletteKey = Self.paletteKey(for: appearance)
-        palette = scope.dataGridCellPalette(in: appearance)
-        settingsCancellable = AppEvents.shared.dataGridSettingsChanged
-            .receive(on: RunLoop.main)
-            .sink { [weak self] _ in
-                self?.nullDisplayString = AppSettingsManager.shared.dataGrid.nullDisplay
-                self?.showsInvisibleCharacters = AppSettingsManager.shared.dataGrid.showInvisibleCharacters
-            }
-    }
-
-    /// Asked by every row as it draws: the tints resolve in the appearance the row draws in, which
-    /// only the draw knows, and the key makes the call a comparison until the theme or it moves.
-    func preparePalette(in appearance: NSAppearance) {
-        let key = Self.paletteKey(for: appearance)
-        guard key != paletteKey else { return }
-        paletteKey = key
-        palette = scope.dataGridCellPalette(in: appearance)
-    }
-
-    /// A fixed scope never moves the key, so a new one rebuilds the palette here.
-    func adopt(_ scope: ThemeScope, in appearance: NSAppearance) {
-        self.scope = scope
-        paletteKey = Self.paletteKey(for: appearance)
-        palette = scope.dataGridCellPalette(in: appearance)
-    }
-
-    /// The engine's counters for every scope: a system color change reaches every scope through it.
-    private static func paletteKey(for appearance: NSAppearance) -> PaletteKey {
-        let change = ThemeEngine.shared.change
-        return PaletteKey(revision: change.revision, generation: change.generation, appearance: appearance.name)
-    }
-
-    func makeRowNumberCell(
-        in tableView: NSTableView,
-        row: Int,
-        pageOffset: Int,
-        cachedRowCount: Int,
-        visualState: RowVisualState
-    ) -> NSView {
-        let cellView: NSTableCellView
-        let cell: NSTextField
-
-        if let reused = tableView.makeView(withIdentifier: rowNumberCellIdentifier, owner: nil) as? NSTableCellView,
-           let textField = reused.textField {
-            cellView = reused
-            cell = textField
-            cell.font = ThemeEngine.shared.dataGridFonts.rowNumber
-        } else {
-            cellView = DataGridRowNumberCellView()
-            cellView.identifier = rowNumberCellIdentifier
-
-            cell = NSTextField(labelWithString: "")
-            cell.alignment = .right
-            cell.font = ThemeEngine.shared.dataGridFonts.rowNumber
-            cell.tag = DataGridFontVariant.rowNumber
-            cell.translatesAutoresizingMaskIntoConstraints = false
-
-            cellView.textField = cell
-            cellView.addSubview(cell)
-            cell.alphaValue = 0
-
-            NSLayoutConstraint.activate([
-                cell.leadingAnchor.constraint(
-                    equalTo: cellView.leadingAnchor,
-                    constant: DataGridMetrics.cellHorizontalInset
-                ),
-                cell.trailingAnchor.constraint(
-                    equalTo: cellView.trailingAnchor,
-                    constant: -DataGridMetrics.cellHorizontalInset
-                ),
-                cell.centerYAnchor.constraint(equalTo: cellView.centerYAnchor),
-            ])
-        }
-
-        cell.textColor = rowNumberColor(for: visualState)
-        guard row >= 0 && row < cachedRowCount else {
-            cell.stringValue = ""
-            return cellView
-        }
-
-        let displayNumber = row + pageOffset + 1
-        cell.stringValue = "\(displayNumber)"
-        cellView.setAccessibilityLabel(String(format: String(localized: "Row %d"), displayNumber))
-        cellView.setAccessibilityRowIndexRange(NSRange(location: row, length: 1))
-
-        return cellView
-    }
-
-    func rowNumberColor(for visualState: RowVisualState) -> NSColor {
-        palette.rowNumberColor(for: visualState, onEmphasizedSelection: false)
-    }
-}
-
-/// The row-number cell, mounted under the pinned row gutter, which paints every visible number.
-///
-/// Its number would show beside the gutter while a sideways bounce slides the column out from under
-/// it, so the field draws at zero alpha. Zero alpha keeps the field in the accessibility tree, where
-/// `isHidden` would drop it. It is also the only view a row drag can build its image from, so the
-/// drag image is taken with the field shown.
-final class DataGridRowNumberCellView: NSTableCellView {
-    override var draggingImageComponents: [NSDraggingImageComponent] {
-        guard let textField else { return super.draggingImageComponents }
-        let alpha = textField.alphaValue
-        textField.alphaValue = 1
-        defer { textField.alphaValue = alpha }
-        return super.draggingImageComponents
-    }
-}
diff --git a/apple/TablePro/Views/Results/Comparison/ResultComparisonGrid.swift b/apple/TablePro/Views/Results/Comparison/ResultComparisonGrid.swift
index 4ebfeee44d..8804aabd50 100644
--- a/apple/TablePro/Views/Results/Comparison/ResultComparisonGrid.swift
+++ b/apple/TablePro/Views/Results/Comparison/ResultComparisonGrid.swift
@@ -3,6 +3,7 @@
 //  TablePro
 //
 
+import Combine
 import SwiftUI
 import TableProPluginKit
 
@@ -12,7 +13,7 @@ internal struct ResultComparisonGridLine: Equatable {
 }
 
 @MainActor
-internal final class ResultComparisonGridModel: DataGridViewDelegate {
+internal final class ResultComparisonGridModel: ObservableObject {
     internal static let leadingColumnCount = 2
 
     internal struct LoadKey: Hashable {
@@ -20,14 +21,24 @@ internal final class ResultComparisonGridModel: DataGridViewDelegate {
         let filter: ResultComparisonFilter
     }
 
+    internal let grid = HeldRowsGridAdapter(configuration: ResultComparisonGridModel.configuration)
     private(set) var lines: [ResultComparisonGridLine] = []
-    private(set) var tableRows = TableRows()
-    private var states: [RowVisualState] = []
     private var loadedKey: LoadKey?
 
-    // A grid row is a display position; the grid's own value filter can reorder it.
-    private weak var coordinator: TableViewCoordinator?
+    internal var model: DataGridModel { grid.model }
+    internal var tableRows: TableRows { grid.heldRows }
 
+    private static var configuration: DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.showRowNumbers = false
+        configuration.supportsValueFilter = false
+        configuration.supportsColumnSort = false
+        configuration.appliesRowCopyFormat = true
+        configuration.commands = [.freezeColumns, .displayAs]
+        return configuration
+    }
+
+    @discardableResult
     internal func ensureLoaded(
         key: LoadKey,
         comparison: ResultComparison,
@@ -36,10 +47,23 @@ internal final class ResultComparisonGridModel: DataGridViewDelegate {
         pairing: ResultColumnPairing
     ) -> TableRows {
         guard loadedKey != key else { return tableRows }
+        // A row is a line of this load, so a selection made against another load names nothing here.
+        if loadedKey != nil {
+            grid.model.clearSelection()
+        }
         loadedKey = key
         lines = Self.lines(for: comparison.entries.filter { key.filter.matches($0.kind) })
-        states = lines.map(Self.visualState(for:))
-        tableRows = Self.tableRows(for: lines, left: left, right: right, pairing: pairing)
+        let rows = Self.tableRows(for: lines, left: left, right: right, pairing: pairing)
+        var states: [RowID: RowVisualState] = [:]
+        for (row, line) in zip(rows.rows, lines) {
+            states[row.id] = Self.visualState(for: line)
+        }
+        grid.visualStates = states
+        // Display formats are kept by data index, so another pairing's columns start with raw values.
+        if rows.columns != tableRows.columns || rows.columnTypes != tableRows.columnTypes {
+            grid.model.store.displayFormats = []
+        }
+        grid.setRows(rows)
         return tableRows
     }
 
@@ -137,26 +161,6 @@ internal final class ResultComparisonGridModel: DataGridViewDelegate {
     ) -> ColumnType {
         CompareRowGridModel.displayType(source: left.columnType(at: pair.left), target: right.columnType(at: pair.right))
     }
-
-    private func lineIndex(forDisplayRow row: Int) -> Int? {
-        let index = coordinator?.tableRowsIndex(forDisplayRow: row) ?? row
-        return lines.indices.contains(index) ? index : nil
-    }
-
-    // MARK: - DataGridViewDelegate
-
-    internal func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        coordinator = tableViewCoordinator
-    }
-
-    internal func dataGridVisualState(forRow row: Int) -> RowVisualState? {
-        guard let index = lineIndex(forDisplayRow: row), states.indices.contains(index) else { return nil }
-        return states[index]
-    }
-
-    internal func dataGridCopyRows(_ indices: Set<Int>) {
-        coordinator?.copyRowsAsTSV(at: indices, includeHeaders: false)
-    }
 }
 
 internal struct ResultComparisonGrid: View {
@@ -166,38 +170,19 @@ internal struct ResultComparisonGrid: View {
     internal let pairing: ResultColumnPairing
     internal let filter: ResultComparisonFilter
 
-    @State private var model = ResultComparisonGridModel()
-    @State private var changeManager = AnyChangeManager(DataChangeManager())
-    @State private var selectedRows: Set<Int> = []
-    @State private var columnLayout = ColumnLayoutState()
+    @StateObject private var model = ResultComparisonGridModel()
 
+    private var key: ResultComparisonGridModel.LoadKey {
+        ResultComparisonGridModel.LoadKey(comparisonId: comparison.id, filter: filter)
+    }
+
+    // task(id:) runs with this body's values; onChange(of:) would run with the previous body's (measured).
     internal var body: some View {
-        let key = ResultComparisonGridModel.LoadKey(comparisonId: comparison.id, filter: filter)
-        let model = model
-        let comparison = comparison
-        let left = left
-        let right = right
-        let pairing = pairing
-        var configuration = DataGridConfiguration()
-        configuration.showRowNumbers = false
-        configuration.supportsColumnCommands = false
-        configuration.supportsValueFilter = false
-        configuration.supportsColumnSort = false
-        return DataGridView(
-            tableRowsProvider: {
-                model.ensureLoaded(key: key, comparison: comparison, left: left, right: right, pairing: pairing)
-            },
-            changeManager: changeManager,
-            isEditable: false,
-            configuration: configuration,
-            delegate: model,
-            selectedRowIndices: $selectedRows,
-            sortState: .constant(SortState()),
-            columnLayout: $columnLayout,
-            contentRevision: key.hashValue
-        )
-        .onChange(of: key) { _ in
-            selectedRows = []
-        }
+        DataGridView(model: model.model)
+            .task(id: key) { load() }
+    }
+
+    private func load() {
+        model.ensureLoaded(key: key, comparison: comparison, left: left, right: right, pairing: pairing)
     }
 }
diff --git a/apple/TablePro/Views/Results/DataGridBodyChrome.swift b/apple/TablePro/Views/Results/DataGridBodyChrome.swift
deleted file mode 100644
index d8545cc094..0000000000
--- a/apple/TablePro/Views/Results/DataGridBodyChrome.swift
+++ /dev/null
@@ -1,225 +0,0 @@
-//
-//  DataGridBodyChrome.swift
-//  TablePro
-//
-
-import AppKit
-import TableProTheme
-
-/// The single owner of the data grid body's column separators and of the table's background, as
-/// `SortableHeaderChrome` is for the header.
-///
-/// `NSTableView` draws vertical grid lines by keeping one separator view per column as its own
-/// subview, and it re-sorts that whole subview list on every layout pass. That is O(columns) views
-/// and O(columns squared) work per pass: measured at 518ms for a single pass on a 500-column result,
-/// against 0.03ms with the mask cleared. Adding or removing any subview of the table view, which is
-/// exactly what opening the inline cell editor does, forces such a pass. So the grid clears
-/// `gridStyleMask` and draws the separators itself (#2381).
-///
-/// Where they are drawn follows AppKit's own split rather than inventing one. A row view covers
-/// whatever the table view draws underneath it, which is why AppKit puts its horizontal separator
-/// inside `NSTableRowView.drawSeparator(in:)` and can only put a vertical one in a view above the
-/// rows. So a row draws the separators crossing it, and the table view draws only the area below the
-/// last row, where nothing covers it.
-@MainActor
-enum DataGridBodyChrome {
-    static let separatorThickness: CGFloat = 1
-
-    /// Where the separators fall: one standing at the leading edge of every presented column the
-    /// rect reaches.
-    ///
-    /// The leading edge, not the trailing one, is where AppKit put it, and taking the boundary from
-    /// the column rather than from a fixed step keeps the row-number column's edge and leaves the
-    /// pool's spacers without one.
-    ///
-    /// Pure, and separate from the drawing, so a test can measure the geometry against
-    /// `rect(ofColumn:)` without a graphics context.
-    ///
-    /// - Parameters:
-    ///   - rect: the area being drawn, in the coordinate space of `view`.
-    ///   - view: the view drawing, which supplies the space the column rects are converted into.
-    static func separatorRects(
-        in rect: NSRect,
-        of view: NSView,
-        tableView: NSTableView,
-        presentsColumn: (Int) -> Bool
-    ) -> [NSRect] {
-        guard rect.width > 0, rect.height > 0 else { return [] }
-        let inTableView = view.convert(rect, to: tableView)
-        return tableView.columnIndexes(in: inTableView).compactMap { tableColumnIndex in
-            guard presentsColumn(tableColumnIndex) else { return nil }
-            let columnRect = view.convert(tableView.rect(ofColumn: tableColumnIndex), from: tableView)
-            guard columnRect.width > 0 else { return nil }
-            let separator = NSRect(
-                x: columnRect.minX - separatorThickness,
-                y: rect.minY,
-                width: separatorThickness,
-                height: rect.height
-            )
-            return separator.intersects(rect) ? separator : nil
-        }
-    }
-
-    static func drawColumnSeparators(
-        in rect: NSRect,
-        of view: NSView,
-        tableView: NSTableView,
-        presentsColumn: (Int) -> Bool
-    ) {
-        let separators = separatorRects(in: rect, of: view, tableView: tableView, presentsColumn: presentsColumn)
-        guard !separators.isEmpty else { return }
-        tableView.gridColor.setFill()
-        separators.forEach { $0.fill() }
-    }
-
-    // MARK: - Row backgrounds
-
-    /// One row's band in the space of the view asking: a row of the table, or one of the bands past
-    /// the last row that the alternation continues through.
-    struct RowBand: Equatable {
-        let row: Int
-        let rect: NSRect
-        let isTableRow: Bool
-    }
-
-    /// Every band the rect reaches: the table's rows, then bands one row apart past the last row,
-    /// numbered on from it, which is where `NSTableView` continues the alternation.
-    ///
-    /// - Parameters:
-    ///   - rect: the area being drawn, in the coordinate space of `view`.
-    ///   - view: the view drawing, which supplies the space the bands are converted into.
-    static func rowBands(in rect: NSRect, of view: NSView, tableView: NSTableView) -> [RowBand] {
-        guard rect.width > 0, rect.height > 0 else { return [] }
-        let inTableView = view.convert(rect, to: tableView)
-        let rows = tableView.rows(in: inTableView)
-        var bands = (rows.location..<(rows.location + rows.length)).map { row in
-            RowBand(row: row, rect: view.convert(tableView.rect(ofRow: row), from: tableView), isTableRow: true)
-        }
-
-        let pitch = tableView.rowHeight + tableView.intercellSpacing.height
-        let rowCount = tableView.numberOfRows
-        let lastRowBottom = rowCount > 0 ? tableView.rect(ofRow: rowCount - 1).maxY : tableView.bounds.minY
-        guard pitch > 0, inTableView.maxY > lastRowBottom else { return bands }
-
-        var index = max(0, Int(((inTableView.minY - lastRowBottom) / pitch).rounded(.down)))
-        while lastRowBottom + CGFloat(index) * pitch < inTableView.maxY {
-            let band = NSRect(
-                x: inTableView.minX,
-                y: lastRowBottom + CGFloat(index) * pitch,
-                width: inTableView.width,
-                height: pitch
-            )
-            bands.append(RowBand(row: rowCount + index, rect: view.convert(band, from: tableView), isTableRow: false))
-            index += 1
-        }
-        return bands
-    }
-
-    /// Set on the table rather than read at each draw: AppKit reads the table's own
-    /// `backgroundColor` for the area an elastic scroll uncovers, and the separators draw in its
-    /// `gridColor`. A theme that declares neither leaves both at the table's own defaults,
-    /// `controlBackgroundColor` and `separatorColor`.
-    static func applyThemeColors(to tableView: NSTableView, scope: ThemeScope) {
-        let resolved = scope.resolved
-        let gridColor = resolved[.gridLine]
-        if tableView.gridColor != gridColor {
-            tableView.gridColor = gridColor
-        }
-        let background = resolved[.gridBackground]
-        if tableView.backgroundColor != background {
-            tableView.backgroundColor = background
-        }
-    }
-
-    /// The alternate stripe a row carries, or nil when the table does not alternate, where a row
-    /// shows the table's own background.
-    ///
-    /// The theme's pair when it declares one, otherwise `NSColor.alternatingContentBackgroundColors`,
-    /// which is the pair `NSTableView` itself hands its row views.
-    static func stripeColor(forRow row: Int, of tableView: NSTableView, scope: ThemeScope) -> NSColor? {
-        guard tableView.usesAlternatingRowBackgroundColors else { return nil }
-        let resolved = scope.resolved
-        return row.isMultiple(of: 2) ? resolved[.gridBackground] : resolved[.gridAlternateRow]
-    }
-
-    // MARK: - Selection
-
-    static func selectionSlot(emphasized: Bool) -> ThemeSlot {
-        emphasized ? .gridSelection : .gridInactiveSelection
-    }
-
-    /// What a selected row shows, for the surfaces that paint it themselves: the pinned row gutter
-    /// and a selected column's heading. Without a theme override it is the color `NSTableRowView`
-    /// fills with, so they match the rows AppKit draws.
-    static func selectionColor(emphasized: Bool, scope: ThemeScope) -> NSColor {
-        themedSelectionColor(emphasized: emphasized, scope: scope)
-            ?? scope.resolved[selectionSlot(emphasized: emphasized)]
-    }
-
-    static func isSelectionThemed(emphasized: Bool, scope: ThemeScope) -> Bool {
-        scope.resolved.isOverridden(selectionSlot(emphasized: emphasized))
-    }
-
-    /// Nil unless the theme declares its own selection; a row then leaves the selection to
-    /// `NSTableRowView`, which follows Accent and focus.
-    /// Opaque: the row, the gutter and a heading sit on three different bases, so a translucent
-    /// selection is laid over the grid background once and all three paint that.
-    static func themedSelectionColor(emphasized: Bool, scope: ThemeScope) -> NSColor? {
-        let resolved = scope.resolved
-        let slot = selectionSlot(emphasized: emphasized)
-        guard resolved.isOverridden(slot) else { return nil }
-        guard let selection = resolved.definition.value(for: slot).themedColor, !selection.isOpaque else {
-            return resolved[slot]
-        }
-        if let background = resolved.definition.value(for: .gridBackground).themedColor {
-            return selection.composited(over: background).nsColor
-        }
-        let nativeBackground = resolved[.gridBackground]
-        return NSColor(name: nil) { appearance in
-            var base = ThemeColor.white
-            appearance.performAsCurrentDrawingAppearance {
-                base = ThemeColor(nativeBackground)
-            }
-            return selection.composited(over: base.opaque).nsColor
-        }
-    }
-
-    /// What a row view lays down before its tint and selection: its stripe, or the table's own
-    /// background when the table does not alternate.
-    ///
-    /// Painted by `DataGridRowView` itself rather than by `NSTableRowView`, which paints the system
-    /// stripes whatever the theme declares.
-    static func rowBackgroundColor(forRow row: Int, of tableView: NSTableView, scope: ThemeScope) -> NSColor {
-        stripeColor(forRow: row, of: tableView, scope: scope) ?? tableView.backgroundColor
-    }
-
-    /// Lays `background` down and blends `layers` over it bottom to top, which is the colour a row
-    /// view's fills end up showing over the table beneath them. Opaque whatever the layers are,
-    /// because the background replaces the pixels rather than blending over them.
-    static func fill(_ rect: NSRect, with layers: [NSColor], over background: NSColor) {
-        background.setFill()
-        rect.fill()
-        for layer in layers {
-            layer.setFill()
-            rect.fill(using: .sourceOver)
-        }
-    }
-
-    /// The table's background: its own colour, and past the last row the alternate stripes blended
-    /// over it once.
-    ///
-    /// Drawn here rather than by `NSTableView.drawBackground(inClipRect:)`, which blends the stripe in
-    /// twice past the last row. Measured on macOS 27 in dark mode, its empty rows read 52 against the
-    /// rows' 40, so the empty area striped brighter than the rows above it, and nothing that paints
-    /// the stripe once could match it, the pinned row gutter included. Under the rows only the
-    /// table's colour goes down, because a row view blends its own stripe over exactly that.
-    static func drawTableBackground(in rect: NSRect, of tableView: NSTableView, scope: ThemeScope) {
-        tableView.backgroundColor.setFill()
-        rect.fill()
-        for band in rowBands(in: rect, of: tableView, tableView: tableView) where !band.isTableRow {
-            guard let stripe = stripeColor(forRow: band.row, of: tableView, scope: scope) else { continue }
-            stripe.setFill()
-            band.rect.intersection(rect).fill(using: .sourceOver)
-        }
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridCellFactory.swift b/apple/TablePro/Views/Results/DataGridCellFactory.swift
deleted file mode 100644
index 0e2be0be4b..0000000000
--- a/apple/TablePro/Views/Results/DataGridCellFactory.swift
+++ /dev/null
@@ -1,262 +0,0 @@
-//
-//  DataGridCellFactory.swift
-//  TablePro
-//
-
-import AppKit
-import Foundation
-import TableProPluginKit
-import TableProTextEngine
-
-@MainActor
-final class DataGridCellFactory {
-    private static let minColumnWidth: CGFloat = 60
-    private static let maxColumnWidth: CGFloat = 800
-    private static let minFitToContentWidth: CGFloat = 300
-    private static let fitToContentViewportFraction: CGFloat = 0.5
-    private static let sampleRowCount = 30
-    private static let wideResultSampleRowCount = 10
-    private static let wideResultColumnCount = 50
-    private static let fitToContentValueBudget = 200_000
-    private static let maxMeasureChars = 50
-    private static let headerPadding: CGFloat = 48
-    private static let headerCharWidthRatio: CGFloat = 0.75
-
-    private struct ColumnWidthBudget {
-        let cap: CGFloat
-        let measuredCharLimit: Int
-        let sampledRows: Int
-    }
-
-    static func fitToContentCap(availableWidth: CGFloat) -> CGFloat {
-        let proportional = availableWidth * fitToContentViewportFraction
-        return min(max(proportional, minFitToContentWidth), maxColumnWidth)
-    }
-
-    func calculateOptimalColumnWidth(
-        for columnName: String,
-        columnIndex: Int,
-        tableRows: TableRows,
-        accessory: DataGridCellAccessory = .none,
-        displayFormat: ValueDisplayFormat? = nil,
-        databaseType: DatabaseType? = nil,
-        isLargeDataset: Bool = false,
-        nullDisplayString: String? = nil,
-        revealsInvisibleCharacters: Bool = false
-    ) -> CGFloat {
-        measureColumnWidth(
-            for: columnName,
-            columnIndex: columnIndex,
-            tableRows: tableRows,
-            accessory: accessory,
-            displayFormat: displayFormat,
-            databaseType: databaseType,
-            isLargeDataset: isLargeDataset,
-            nullDisplayString: nullDisplayString,
-            revealsInvisibleCharacters: revealsInvisibleCharacters,
-            budget: ColumnWidthBudget(
-                cap: Self.maxColumnWidth,
-                measuredCharLimit: Self.maxMeasureChars,
-                sampledRows: Self.automaticSampleRowCount(columnCount: tableRows.columns.count)
-            )
-        )
-    }
-
-    func calculateFitToContentWidth(
-        for columnName: String,
-        columnIndex: Int,
-        tableRows: TableRows,
-        availableWidth: CGFloat,
-        accessory: DataGridCellAccessory = .none,
-        displayFormat: ValueDisplayFormat? = nil,
-        databaseType: DatabaseType? = nil,
-        isLargeDataset: Bool = false,
-        nullDisplayString: String? = nil,
-        revealsInvisibleCharacters: Bool = false,
-        fittedColumnCount: Int = 1
-    ) -> CGFloat {
-        let cap = Self.fitToContentCap(availableWidth: availableWidth)
-        let charWidth = ThemeEngine.shared.dataGridFonts.monoCharWidth
-        let measuredCharLimit = charWidth > 0 ? Int((cap / charWidth).rounded(.up)) : Self.maxMeasureChars
-
-        return measureColumnWidth(
-            for: columnName,
-            columnIndex: columnIndex,
-            tableRows: tableRows,
-            accessory: accessory,
-            displayFormat: displayFormat,
-            databaseType: databaseType,
-            isLargeDataset: isLargeDataset,
-            nullDisplayString: nullDisplayString,
-            revealsInvisibleCharacters: revealsInvisibleCharacters,
-            budget: ColumnWidthBudget(
-                cap: cap,
-                measuredCharLimit: measuredCharLimit,
-                sampledRows: Self.fitSampleRowCount(fittedColumnCount: fittedColumnCount)
-            )
-        )
-    }
-
-    /// The first paint samples, because it measures every column of the result before the grid can
-    /// draw a single row.
-    private static func automaticSampleRowCount(columnCount: Int) -> Int {
-        columnCount > wideResultColumnCount ? wideResultSampleRowCount : sampleRowCount
-    }
-
-    /// An explicit fit reads the page rather than a sample, because a sample that stepped over the
-    /// longest value is the reason the user asked twice. The budget is on the whole gesture, not on
-    /// one column, so fitting a single column covers any page a user can configure while fitting
-    /// every column of a wide result stays a bounded amount of formatting on the main thread.
-    private static func fitSampleRowCount(fittedColumnCount: Int) -> Int {
-        max(sampleRowCount, fitToContentValueBudget / max(1, fittedColumnCount))
-    }
-
-    private func measureColumnWidth(
-        for columnName: String,
-        columnIndex: Int,
-        tableRows: TableRows,
-        accessory: DataGridCellAccessory,
-        displayFormat: ValueDisplayFormat?,
-        databaseType: DatabaseType?,
-        isLargeDataset: Bool,
-        nullDisplayString: String?,
-        revealsInvisibleCharacters: Bool,
-        budget: ColumnWidthBudget
-    ) -> CGFloat {
-        let charWidth = ThemeEngine.shared.dataGridFonts.monoCharWidth
-        let headerCharCount = (columnName as NSString).length
-        var maxWidth = CGFloat(headerCharCount) * charWidth * Self.headerCharWidthRatio + Self.headerPadding
-
-        let totalRows = tableRows.count
-        let step = max(1, totalRows / max(1, budget.sampledRows))
-
-        let columnType = columnIndex < tableRows.columnTypes.count
-            ? tableRows.columnTypes[columnIndex]
-            : nil
-        let resolvedNullDisplayString = nullDisplayString
-            ?? AppSettingsManager.shared.dataGrid.nullDisplay
-
-        for i in stride(from: 0, to: totalRows, by: step) {
-            let rawValue = tableRows.value(at: i, column: columnIndex)
-            let formattedValue = CellDisplayFormatter.format(
-                rawValue,
-                columnType: columnType,
-                displayFormat: displayFormat,
-                databaseType: databaseType
-            ) ?? ""
-            let placeholder = DataGridCellContent.placeholder(
-                for: rawValue,
-                isAbsent: tableRows.isAbsent(row: i, column: columnIndex),
-                unloadedByteCount: tableRows.unloadedByteCount(row: i, column: columnIndex)
-            )
-            let value = DataGridCellContent.resolvedDisplayText(
-                formattedValue,
-                placeholder: placeholder,
-                isLargeDataset: isLargeDataset,
-                nullDisplayString: resolvedNullDisplayString
-            )
-
-            let charCount = min((value as NSString).length, budget.measuredCharLimit)
-            let markedWidth = revealsInvisibleCharacters && placeholder == nil
-                ? Self.markedWidth(of: value, length: charCount)
-                : nil
-            let textWidth = markedWidth ?? CGFloat(charCount) * charWidth
-            maxWidth = max(maxWidth, textWidth + accessory.measurementPadding)
-
-            if maxWidth >= budget.cap {
-                return budget.cap
-            }
-        }
-
-        return min(max(maxWidth, Self.minColumnWidth), budget.cap)
-    }
-
-    // A mark is wider than the character it stands for, so a value holding one is laid out.
-    private static func markedWidth(of value: String, length: Int) -> CGFloat? {
-        let text = value as NSString
-        var index = 0
-        while index < length {
-            let unit = text.character(at: index)
-            if unit == 0x0D || SpecialCharacter.mayBeSpecial(unit) { break }
-            index += 1
-        }
-        guard index < length else { return nil }
-        let font = ThemeEngine.shared.dataGridFonts.regular
-        let marked = SpecialCharacterLine(
-            NSAttributedString(string: text.substring(to: length), attributes: [.font: font]),
-            style: SpecialCharacterStyle(marksLineBreaks: true)
-        )
-        return CGFloat(CTLineGetTypographicBounds(marked.line, nil, nil, nil))
-    }
-}
-
-extension NSFont {
-    func withTraits(_ traits: NSFontDescriptor.SymbolicTraits) -> NSFont {
-        let descriptor = fontDescriptor.withSymbolicTraits(traits)
-        return NSFont(descriptor: descriptor, size: pointSize) ?? self
-    }
-}
-
-internal extension String {
-    var containsLineBreak: Bool {
-        let nsString = self as NSString
-        let length = nsString.length
-        guard length > 0 else { return false }
-        for i in 0..<length {
-            let ch = nsString.character(at: i)
-            if ch == 0x0A || ch == 0x0D || ch == 0x0B || ch == 0x0C ||
-               ch == 0x85 || ch == 0x2028 || ch == 0x2029 {
-                return true
-            }
-        }
-        return false
-    }
-
-    var sanitizedForCellDisplay: String {
-        flattenedOntoOneLine(keepingLoneCarriageReturns: false)
-    }
-
-    // A CR with no LF after it ends no line on any current system. It is usually what is left of a
-    // CRLF split on LF, so a cell keeps it for the renderer to mark.
-    var flattenedForCell: String {
-        flattenedOntoOneLine(keepingLoneCarriageReturns: true)
-    }
-
-    // What a cell shows while marks are off: the lone CR reads as the space it always did.
-    var shownWithoutMarks: String {
-        guard utf16.contains(0x0D) else { return self }
-        return replacingOccurrences(of: "\r", with: " ", options: .literal)
-    }
-
-    private func flattenedOntoOneLine(keepingLoneCarriageReturns: Bool) -> String {
-        let nsString = self as NSString
-        let length = nsString.length
-        guard length > 0 else { return self }
-
-        var mutable: NSMutableString?
-        var copiedUpTo = 0
-        for i in 0..<length {
-            let ch = nsString.character(at: i)
-            guard ch == 0x0A || ch == 0x0D || ch == 0x0B || ch == 0x0C ||
-                  ch == 0x85 || ch == 0x2028 || ch == 0x2029 else { continue }
-            if ch == 0x0D, keepingLoneCarriageReturns, i + 1 >= length || nsString.character(at: i + 1) != 0x0A {
-                continue
-            }
-
-            if mutable == nil {
-                mutable = NSMutableString(capacity: length)
-            }
-            if i > copiedUpTo {
-                mutable?.append(nsString.substring(with: NSRange(location: copiedUpTo, length: i - copiedUpTo)))
-            }
-            mutable?.append(" ")
-            copiedUpTo = i + 1
-        }
-
-        guard let result = mutable else { return self }
-        if copiedUpTo < length {
-            result.append(nsString.substring(with: NSRange(location: copiedUpTo, length: length - copiedUpTo)))
-        }
-        return result as String
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridColumnPool.swift b/apple/TablePro/Views/Results/DataGridColumnPool.swift
deleted file mode 100644
index 1167853cf8..0000000000
--- a/apple/TablePro/Views/Results/DataGridColumnPool.swift
+++ /dev/null
@@ -1,352 +0,0 @@
-//
-//  DataGridColumnPool.swift
-//  TablePro
-//
-
-import AppKit
-
-@MainActor
-final class DataGridColumnPool {
-    private var pooledColumns: [NSTableColumn] = []
-    private weak var attachedTableView: NSTableView?
-
-    /// Columns the user hid, kept apart from the ones the window unmounts so a window slide can
-    /// never bring a hidden column back.
-    private var userHiddenIdentifiers: Set<NSUserInterfaceItemIdentifier> = []
-    /// Slots the current result actually uses. The pool only grows, so the surplus slots past the
-    /// result's column count stay attached and hidden, and windowing must never mount one.
-    private var activeIdentifiers: Set<NSUserInterfaceItemIdentifier> = []
-
-    var totalSlots: Int { pooledColumns.count }
-
-    func attach(to tableView: NSTableView) {
-        attachedTableView = tableView
-    }
-
-    /// Whether the result presents this column at all, which is a different question from whether
-    /// the window currently has it mounted.
-    ///
-    /// `isHidden` answers both at once, and everything that asks "which columns is the user
-    /// looking at" (copy, find, cell navigation, size-all) means this one. Reading `isHidden`
-    /// there silently narrows those to the columns near the viewport.
-    func presentsColumn(_ column: NSTableColumn) -> Bool {
-        activeIdentifiers.contains(column.identifier) && !userHiddenIdentifiers.contains(column.identifier)
-    }
-
-    var hasUserHiddenColumns: Bool { !userHiddenIdentifiers.isEmpty }
-
-    /// Whether this position in `tableColumns` holds one of the columns the result presents.
-    ///
-    /// The row-number column is an attached column too, and the pool keeps the surplus slots of a
-    /// previously wider result attached and hidden, so no fixed position answers this.
-    func presentsColumn(atTableColumnIndex index: Int, in tableView: NSTableView) -> Bool {
-        guard index >= 0, index < tableView.tableColumns.count else { return false }
-        return presentsColumn(tableView.tableColumns[index])
-    }
-
-    func firstPresentedColumnIndex(in tableView: NSTableView) -> Int? {
-        tableView.tableColumns.firstIndex { presentsColumn($0) }
-    }
-
-    func lastPresentedColumnIndex(in tableView: NSTableView) -> Int? {
-        tableView.tableColumns.lastIndex { presentsColumn($0) }
-    }
-
-    func nextPresentedColumnIndex(after index: Int, in tableView: NSTableView) -> Int? {
-        let start = max(0, index + 1)
-        guard start < tableView.tableColumns.count else { return nil }
-        return tableView.tableColumns[start...].firstIndex { presentsColumn($0) }
-    }
-
-    func previousPresentedColumnIndex(before index: Int, in tableView: NSTableView) -> Int? {
-        let end = min(max(0, index), tableView.tableColumns.count)
-        guard end > 0 else { return nil }
-        return tableView.tableColumns[..<end].lastIndex { presentsColumn($0) }
-    }
-
-    func detachFromTableView() {
-        guard let tableView = attachedTableView else { return }
-        let attached = Set(tableView.tableColumns.map(\.identifier))
-        for column in pooledColumns where attached.contains(column.identifier) {
-            tableView.removeTableColumn(column)
-        }
-        attachedTableView = nil
-    }
-
-    /// - Returns: whether a column's visibility changed. `NSTableColumn.isHidden` moves every column
-    ///   after it and is the one geometry change `NSTableView` announces through no notification, so
-    ///   the caller has to repaint the drawn body itself. See
-    ///   `TableViewCoordinator.columnGeometryDidChange()`.
-    @discardableResult
-    func reconcile(
-        tableView: NSTableView,
-        schema: ColumnIdentitySchema,
-        columnTypes: [ColumnType],
-        columnComments: [String: String] = [:],
-        savedLayout: ColumnLayoutState?,
-        isEditable: Bool,
-        hiddenColumnNames: Set<String>,
-        firstClickSortDirection: SortDirection,
-        supportsColumnSort: Bool = true,
-        supportsValueFilter: Bool = true,
-        minimumWidths: [String: CGFloat] = [:],
-        widthCalculator: (String, Int) -> CGFloat
-    ) -> Bool {
-        attach(to: tableView)
-        let visibleCount = schema.columnNames.count
-        activeIdentifiers = Set(schema.identifiers)
-
-        growBackingPoolIfNeeded(to: visibleCount)
-
-        let willRestoreWidths = !(savedLayout?.columnWidths.isEmpty ?? true)
-        let hiddenFromLayout = savedLayout?.hiddenColumns ?? []
-        var comments: [NSUserInterfaceItemIdentifier: String] = [:]
-        var showsComments = false
-        var visibilityChanged = false
-
-        for slot in 0..<pooledColumns.count {
-            let column = pooledColumns[slot]
-            if slot < visibleCount {
-                let columnName = schema.columnNames[slot]
-                let resolvedWidth = willRestoreWidths
-                    ? (savedLayout?.columnWidths[columnName] ?? widthCalculator(columnName, slot))
-                    : widthCalculator(columnName, slot)
-                let comment = displayableComment(columnComments[columnName])
-                configureColumn(
-                    column,
-                    name: columnName,
-                    columnType: slot < columnTypes.count ? columnTypes[slot] : nil,
-                    comment: comment,
-                    width: resolvedWidth,
-                    minWidth: minimumWidths[columnName] ?? DataGridMetrics.dataColumnMinWidth,
-                    isEditable: isEditable,
-                    firstClickSortDirection: firstClickSortDirection,
-                    supportsColumnSort: supportsColumnSort,
-                    supportsValueFilter: supportsValueFilter
-                )
-                let hidden = hiddenFromLayout.contains(columnName) || hiddenColumnNames.contains(columnName)
-                if hidden {
-                    userHiddenIdentifiers.insert(column.identifier)
-                } else {
-                    userHiddenIdentifiers.remove(column.identifier)
-                }
-                visibilityChanged = setHidden(hidden, on: column) || visibilityChanged
-                if let comment {
-                    comments[column.identifier] = comment
-                    if !hidden {
-                        showsComments = true
-                    }
-                }
-            } else {
-                visibilityChanged = setHidden(true, on: column) || visibilityChanged
-            }
-        }
-        applyComments(comments, showsComments: showsComments, in: tableView)
-
-        let targetOrder = computeTargetOrder(
-            visibleCount: visibleCount,
-            savedOrder: savedLayout?.columnOrder,
-            schema: schema
-        )
-
-        attachAndOrderColumns(
-            in: tableView,
-            visibleCount: visibleCount,
-            targetOrder: targetOrder
-        )
-        return visibilityChanged
-    }
-
-    private func setHidden(_ hidden: Bool, on column: NSTableColumn) -> Bool {
-        guard column.isHidden != hidden else { return false }
-        column.isHidden = hidden
-        return true
-    }
-
-    private func growBackingPoolIfNeeded(to count: Int) {
-        while pooledColumns.count < count {
-            let slot = pooledColumns.count
-            let column = NSTableColumn(identifier: ColumnIdentitySchema.slotIdentifier(slot))
-            column.minWidth = DataGridMetrics.dataColumnMinWidth
-            column.maxWidth = DataGridMetrics.dataColumnMaxWidth
-            column.resizingMask = .userResizingMask
-            column.isEditable = true
-            column.isHidden = true
-            pooledColumns.append(column)
-        }
-    }
-
-    private func computeTargetOrder(
-        visibleCount: Int,
-        savedOrder: [String]?,
-        schema: ColumnIdentitySchema
-    ) -> [Int] {
-        var slots: [Int] = []
-        var seen = Set<Int>()
-
-        if let savedOrder {
-            for name in savedOrder {
-                guard let slot = schema.dataIndex(forColumnName: name),
-                      slot < visibleCount,
-                      !seen.contains(slot) else { continue }
-                slots.append(slot)
-                seen.insert(slot)
-            }
-        }
-
-        for slot in 0..<visibleCount where !seen.contains(slot) {
-            slots.append(slot)
-        }
-        return slots
-    }
-
-    private func attachAndOrderColumns(
-        in tableView: NSTableView,
-        visibleCount: Int,
-        targetOrder: [Int]
-    ) {
-        var attached = Set(tableView.tableColumns.map(\.identifier))
-        let baseOffset = tableView.tableColumns.first?.identifier == ColumnIdentitySchema.rowNumberIdentifier ? 1 : 0
-
-        for slot in targetOrder where !attached.contains(pooledColumns[slot].identifier) {
-            tableView.addTableColumn(pooledColumns[slot])
-            attached.insert(pooledColumns[slot].identifier)
-        }
-
-        for slot in 0..<pooledColumns.count
-        where slot >= visibleCount && !attached.contains(pooledColumns[slot].identifier) {
-            tableView.addTableColumn(pooledColumns[slot])
-            attached.insert(pooledColumns[slot].identifier)
-        }
-
-        NSAnimationContext.beginGrouping()
-        NSAnimationContext.current.duration = 0
-        NSAnimationContext.current.allowsImplicitAnimation = false
-        defer { NSAnimationContext.endGrouping() }
-
-        var indexByIdentifier: [NSUserInterfaceItemIdentifier: Int] = [:]
-        indexByIdentifier.reserveCapacity(tableView.tableColumns.count)
-        for (index, column) in tableView.tableColumns.enumerated() {
-            indexByIdentifier[column.identifier] = index
-        }
-
-        for (targetPosition, slot) in targetOrder.enumerated() {
-            let identifier = ColumnIdentitySchema.slotIdentifier(slot)
-            guard let currentIndex = indexByIdentifier[identifier] else { continue }
-            let desiredIndex = baseOffset + targetPosition
-            guard desiredIndex < tableView.tableColumns.count else { continue }
-            if currentIndex == desiredIndex { continue }
-
-            tableView.moveColumn(currentIndex, toColumn: desiredIndex)
-            updateIndexMap(&indexByIdentifier, movedFrom: currentIndex, to: desiredIndex)
-        }
-    }
-
-    private func updateIndexMap(
-        _ map: inout [NSUserInterfaceItemIdentifier: Int],
-        movedFrom source: Int,
-        to destination: Int
-    ) {
-        guard source != destination else { return }
-        let lower = min(source, destination)
-        let upper = max(source, destination)
-        let delta = source < destination ? -1 : 1
-        for (key, value) in map where value >= lower && value <= upper {
-            if value == source {
-                map[key] = destination
-            } else {
-                map[key] = value + delta
-            }
-        }
-    }
-
-    private func configureColumn(
-        _ column: NSTableColumn,
-        name: String,
-        columnType: ColumnType?,
-        comment: String?,
-        width: CGFloat,
-        minWidth: CGFloat,
-        isEditable: Bool,
-        firstClickSortDirection: SortDirection,
-        supportsColumnSort: Bool = true,
-        supportsValueFilter: Bool = true
-    ) {
-        if !(column.headerCell is SortableHeaderCell) || column.headerCell.stringValue != name {
-            let cell = SortableHeaderCell(textCell: name)
-            cell.font = column.headerCell.font
-            cell.alignment = column.headerCell.alignment
-            column.headerCell = cell
-        }
-        (column.headerCell as? SortableHeaderCell)?.supportsValueFilter = supportsValueFilter
-
-        var tooltip: String
-        if let typeName = columnType?.rawType ?? columnType?.displayName {
-            tooltip = "\(name) (\(typeName))"
-        } else {
-            tooltip = name
-        }
-        if let comment {
-            tooltip += "\n\(comment)"
-        }
-        if column.headerToolTip != tooltip {
-            column.headerToolTip = tooltip
-        }
-
-        let label = accessibilityLabel(name: name, comment: comment)
-        if column.headerCell.accessibilityLabel() != label {
-            column.headerCell.setAccessibilityLabel(label)
-        }
-
-        applyWidth(max(width, minWidth), minWidth: minWidth, to: column)
-        if column.isEditable != isEditable {
-            column.isEditable = isEditable
-        }
-        guard supportsColumnSort else {
-            if column.sortDescriptorPrototype != nil {
-                column.sortDescriptorPrototype = nil
-            }
-            return
-        }
-        let prototypeAscending = firstClickSortDirection == .ascending
-        if column.sortDescriptorPrototype?.key != name
-            || column.sortDescriptorPrototype?.ascending != prototypeAscending {
-            column.sortDescriptorPrototype = NSSortDescriptor(key: name, ascending: prototypeAscending)
-        }
-    }
-
-    /// Raising `minWidth` past `width` moves the width without updating the table's column geometry, so the width goes in first.
-    private func applyWidth(_ width: CGFloat, minWidth: CGFloat, to column: NSTableColumn) {
-        if column.minWidth > minWidth {
-            column.minWidth = minWidth
-        }
-        if column.width != width {
-            column.width = width
-        }
-        if column.minWidth != minWidth {
-            column.minWidth = minWidth
-        }
-    }
-
-    private func accessibilityLabel(name: String, comment: String?) -> String {
-        let label = String(format: String(localized: "Column: %@"), name)
-        guard let comment else { return label }
-        return "\(label), \(comment)"
-    }
-
-    private func displayableComment(_ comment: String?) -> String? {
-        guard let comment else { return nil }
-        let trimmed = comment.trimmingCharacters(in: .whitespacesAndNewlines)
-        return trimmed.isEmpty ? nil : trimmed
-    }
-
-    private func applyComments(
-        _ comments: [NSUserInterfaceItemIdentifier: String],
-        showsComments: Bool,
-        in tableView: NSTableView
-    ) {
-        guard let headerView = tableView.headerView as? SortableHeaderView else { return }
-        headerView.showsComments = showsComments
-        headerView.updateComments(comments)
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridCoordinator+Delta.swift b/apple/TablePro/Views/Results/DataGridCoordinator+Delta.swift
deleted file mode 100644
index b29ab09f6d..0000000000
--- a/apple/TablePro/Views/Results/DataGridCoordinator+Delta.swift
+++ /dev/null
@@ -1,174 +0,0 @@
-//
-//  DataGridCoordinator+Delta.swift
-//  TablePro
-//
-
-import AppKit
-
-internal extension TableViewCoordinator {
-    func applyDelta(_ delta: Delta) {
-        switch delta {
-        case .cellChanged(let row, let column):
-            selectionSummaryTracker.dataDidChange()
-            guard let tableView,
-                  let tableColumn = tableColumnIndex(for: column)
-            else { return }
-            guard row >= 0, row < tableView.numberOfRows else { return }
-            invalidateDisplayCache(forDisplayRow: row, column: column)
-            updateVisualIndex(forDisplayRow: row)
-            redrawCells(rows: IndexSet(integer: row), tableColumnIndexes: IndexSet(integer: tableColumn))
-            invalidateRowDecoration(displayRow: row)
-        case .cellsChanged(let positions):
-            guard !positions.isEmpty else { return }
-            selectionSummaryTracker.dataDidChange()
-            guard let tableView else { return }
-            var rowSet = IndexSet()
-            var colSet = IndexSet()
-            for position in positions {
-                if position.row >= 0, position.row < tableView.numberOfRows {
-                    rowSet.insert(position.row)
-                }
-                if let tableColumn = tableColumnIndex(for: position.column) {
-                    colSet.insert(tableColumn)
-                }
-                invalidateDisplayCache(forDisplayRow: position.row, column: position.column)
-            }
-            guard !rowSet.isEmpty, !colSet.isEmpty else { return }
-            for row in rowSet {
-                updateVisualIndex(forDisplayRow: row)
-            }
-            redrawCells(rows: rowSet, tableColumnIndexes: colSet)
-            for row in rowSet {
-                invalidateRowDecoration(displayRow: row)
-            }
-        case .rowsInserted(let indices):
-            guard !indices.isEmpty else { return }
-            overlayEditor?.dismiss(commit: false)
-            overlayViewer?.dismiss()
-            dismissPopoversBoundToDisplayPositions()
-            applyInsertedRows(indices)
-        case .rowsRemoved(let indices):
-            guard !indices.isEmpty else { return }
-            overlayEditor?.dismiss(commit: false)
-            overlayViewer?.dismiss()
-            dismissPopoversBoundToDisplayPositions()
-            applyRemovedRows(indices)
-        case .columnsReplaced, .fullReplace:
-            applyFullReplace()
-        }
-    }
-
-    /// A value filter decides afresh which rows are shown, so the cell selection cannot follow its
-    /// rows there and is dropped instead of shifted.
-    func applyInsertedRows(_ indices: IndexSet) {
-        selectionSummaryTracker.dataDidChange()
-        guard let tableView else { return }
-        if valueFilterState.isActive {
-            selectionController.clear()
-            reloadAfterRowMutationWithValueFilter()
-            return
-        }
-        visualIndex.rebuild(from: changeManager)
-        updateCache()
-        let keyTableView = tableView as? KeyHandlingTableView
-        let focusedRow = keyTableView?.focusedRow ?? -1
-        tableView.insertRows(at: indices, withAnimation: Self.rowAnimation(.slideDown))
-        selectionController.applyInsertedRows(indices, newRowCount: cachedRowCount)
-        /// AppKit shifts the selected rows without posting a selection change, so nothing else moves
-        /// the cursor with them.
-        keyTableView?.focusedRow = GridSelection.row(focusedRow, afterInserting: indices)
-        repaintVisibleRowDecorations()
-    }
-
-    /// Accessibility > Display > Reduce Motion asks for no sliding rows, and the app
-    /// already honours it elsewhere.
-    static func rowAnimation(_ preferred: NSTableView.AnimationOptions) -> NSTableView.AnimationOptions {
-        NSWorkspace.shared.accessibilityDisplayShouldReduceMotion ? [] : preferred
-    }
-
-    func applyRemovedRows(_ indices: IndexSet) {
-        selectionSummaryTracker.dataDidChange()
-        guard let tableView else { return }
-        if valueFilterState.isActive {
-            selectionController.clear()
-            reloadAfterRowMutationWithValueFilter()
-            return
-        }
-        visualIndex.rebuild(from: changeManager)
-        updateCache()
-        let keyTableView = tableView as? KeyHandlingTableView
-        let focusedRow = keyTableView?.focusedRow ?? -1
-        tableView.removeRows(at: indices, withAnimation: Self.rowAnimation(.slideUp))
-        selectionController.applyRemovedRows(indices, newRowCount: cachedRowCount)
-        keyTableView?.focusedRow = GridSelection.row(focusedRow, afterRemoving: indices) ?? -1
-        repaintVisibleRowDecorations()
-    }
-
-    func applyFullReplace() {
-        selectionSummaryTracker.dataDidChange()
-        overlayEditor?.dismiss(commit: false)
-        overlayViewer?.dismiss()
-        dismissPopoversBoundToDisplayPositions()
-        pruneStaleValueFilters()
-        guard let tableView else { return }
-        invalidateAllDisplayCaches()
-        recomputeValueFilteredIDs()
-        updateValueFilterHeaderIndicators()
-        updateCache()
-        selectionController.clear()
-        tableView.reloadData()
-        startBackgroundPrewarm()
-    }
-
-    func invalidateCachesForUndoRedo() {
-        selectionSummaryTracker.dataDidChange()
-        invalidateAllDisplayCaches()
-        updateCache()
-        reloadVisibleRowsAndStates()
-    }
-
-    /// Repaints visible rows in the two layers a row needs: `repaintRows` covers the row-number
-    /// column and the drawn cells, and `refreshVisibleRowVisualStates` then visits each live
-    /// `NSTableRowView` so `applyVisualState` can carry the per-row decoration (deleted or inserted
-    /// tint, deleted-row context menu state) without recreating a view. Both delegates call this
-    /// after a model mutation that leaves the row count alone.
-    func reloadVisibleRowsAndStates() {
-        guard let tableView else { return }
-        let visibleRange = tableView.rows(in: tableView.visibleRect)
-        guard visibleRange.length > 0 else { return }
-        invalidateDisplayCache()
-        repaintRows(IndexSet(integersIn: visibleRange.location..<(visibleRange.location + visibleRange.length)))
-        refreshVisibleRowVisualStates()
-        startBackgroundPrewarm()
-    }
-
-    func reloadRowAndState(at row: Int) {
-        guard let tableView, row >= 0, row < tableView.numberOfRows else { return }
-        invalidateDisplayCache(forDisplayRow: row)
-        repaintRows(IndexSet(integer: row))
-        refreshRowVisualState(at: row)
-    }
-
-    private func reloadAfterRowMutationWithValueFilter() {
-        guard let tableView else { return }
-        recomputeValueFilteredIDs()
-        updateCache()
-        visualIndex.rebuild(from: changeManager)
-        tableView.reloadData()
-        startBackgroundPrewarm()
-    }
-
-    private func invalidateDisplayCache(forDisplayRow displayIndex: Int) {
-        guard let row = displayRow(at: displayIndex) else { return }
-        displayCache.clearValues(forID: row.id)
-    }
-
-    private func invalidateDisplayCache(forDisplayRow displayIndex: Int, column: Int) {
-        guard let row = displayRow(at: displayIndex) else { return }
-        displayCache.clearHighlight(forID: row.id)
-        guard let box = displayCache.box(forID: row.id),
-              column >= 0, column < box.values.count else { return }
-        box.values[column] = nil
-        displayCache.setBox(box, forID: row.id)
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridCoordinator+Scope.swift b/apple/TablePro/Views/Results/DataGridCoordinator+Scope.swift
deleted file mode 100644
index 609c1f5a1a..0000000000
--- a/apple/TablePro/Views/Results/DataGridCoordinator+Scope.swift
+++ /dev/null
@@ -1,13 +0,0 @@
-//
-//  DataGridCoordinator+Scope.swift
-//  TablePro
-//
-
-import Foundation
-
-extension TableViewCoordinator {
-    var tableScope: TableScope? {
-        guard let connectionId, let tableName else { return nil }
-        return TableScope(connectionId: connectionId, database: databaseName, schema: schemaName, table: tableName)
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridCoordinator.swift b/apple/TablePro/Views/Results/DataGridCoordinator.swift
deleted file mode 100644
index f3bea8d605..0000000000
--- a/apple/TablePro/Views/Results/DataGridCoordinator.swift
+++ /dev/null
@@ -1,1382 +0,0 @@
-import AppKit
-import Combine
-import os
-import SwiftUI
-import TableProPluginKit
-
-private let fkTraceLogger = Logger(subsystem: "com.TablePro", category: "DataGrid")
-
-/// Which columns need repainting because their accessory changed. Deliberately carries no width
-/// information: a column's width is decided when the column is built or auto-fitted, and metadata
-/// arriving afterwards repaints the cell without moving anything the user is already reading.
-struct DataGridColumnPresentationChanges {
-    var indices = IndexSet()
-
-    var isEmpty: Bool { indices.isEmpty }
-}
-
-struct DataGridColumnPresentationIdentity: Hashable {
-    let name: String
-    let occurrence: Int
-}
-
-struct PendingColumnLayoutPersistence: Equatable {
-    let layout: ColumnLayoutState
-    let tableKey: ColumnLayoutTableKey?
-    let writesToTableStorage: Bool
-}
-
-// MARK: - Coordinator
-
-@MainActor
-final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewDataSource,
-                                  NSMenuDelegate
-{
-    var tableRowsProvider: @MainActor () -> TableRows = { TableRows() }
-    var tableRowsMutator: @MainActor (@MainActor (inout TableRows) -> Delta) -> Delta = { _ in .none }
-    var paginationOffsetProvider: @MainActor () -> Int = { 0 }
-    var changeManager: AnyChangeManager
-    var isEditable: Bool
-    var editRefusalMessage: String?
-    /// Headings this grid must refuse an edit for while the rest of it stays editable. See
-    /// `DataGridConfiguration.lockedColumns`.
-    var lockedColumns: Set<String> = []
-    var checkboxColumns: Set<Int> = []
-    var supportsColumnCommands = true
-    var supportsValueFilter = true
-    var filterMenuColumnTypes: [ColumnType]?
-    var valueFilteredIDs: [RowID]? { didSet { bumpDisplayRevision() } }
-    /// Ticks whenever the displayed row order or the value filter changes.
-    ///
-    /// `displayIDs` reaches SwiftUI only through weak, observation-ignored hops, so a filter change
-    /// produces no signal on its own. Views that render the same rows outside the grid key off this
-    /// instead of comparing the id array, which is O(rows) on every body evaluation.
-    private(set) var displayRevision: Int = 0
-    /// Set by `DataGridView` when the grid has an owner that holds the filter for it. Without one
-    /// the filter lives here alone and dies with this coordinator, which is all a structure or
-    /// create-table grid needs.
-    var valueFilterBinding: Binding<GridValueFilterState>?
-    var displayOrderProvider: (@MainActor () -> [RowID]?)?
-    private var storedValueFilterState = GridValueFilterState()
-    /// Reads never go back through the binding, because a SwiftUI `Binding` built from a captured
-    /// value type returns the pre-write value until the next body pass. The mirror is authoritative
-    /// for this coordinator and `adoptValueFilter(_:)` pulls owner-driven changes in.
-    ///
-    /// A write reaches the owner's observable state, and `remapValueFilters` performs one from
-    /// inside `updateNSView` when a column's display format changes. That is bounded to a single
-    /// extra update: the guard below drops a no-op write, and the next pass finds the formats
-    /// already synced, so `syncDisplayFormats` returns before it can remap again.
-    var valueFilterState: GridValueFilterState {
-        get { storedValueFilterState }
-        set {
-            guard newValue != storedValueFilterState else { return }
-            storedValueFilterState = newValue
-            valueFilterBinding?.wrappedValue = newValue
-        }
-    }
-    var displayIDs: [RowID]? { valueFilteredIDs }
-    private(set) var columnDisplayFormats: [ValueDisplayFormat?] = []
-    private(set) var currentFindMatch: FindMatch?
-    /// Owned by whoever outlives this coordinator when there is one, so a remount reuses the text it
-    /// already formatted instead of formatting the whole result again. A grid with no owner keeps
-    /// its own, which is all a structure or create-table grid ever needs. (#2424)
-    private(set) var displayState = DataGridDisplayState()
-    var displayCache: RowDisplayCache { displayState.cache }
-    var pendingScrollAnchorRow: Int?
-    var pendingColumnJump: PendingColumnJump?
-    weak var delegate: (any DataGridViewDelegate)?
-    var rowReorder: DataGridRowReorder = .disabled
-    weak var activeFKPreviewPopover: NSPopover?
-    weak var activeCellEditorPopover: NSPopover?
-    weak var activePoppedOutEditor: JSONViewerWindowController?
-    weak var activeValueFilterPopover: NSPopover?
-    var activeFKPreviewModel: FKPreviewModel?
-    var activeFKPreviewColumnIndex: Int?
-    var dropdownColumns: Set<Int>?
-    var typePickerColumns: Set<Int>?
-    var customDropdownOptions: [Int: [GridMenuOption]]?
-    var connectionId: UUID?
-    var databaseType: DatabaseType?
-    var tableName: String?
-    var databaseName: String?
-    var schemaName: String?
-    var primaryKeyColumns: [String] = []
-    var primaryKeyColumn: String? { primaryKeyColumns.first }
-    var tabType: TabType?
-    var layoutPersister: any ColumnLayoutPersisting
-    var onColumnLayoutDidChange: ((ColumnLayoutState) -> Void)?
-    private(set) var identitySchema: ColumnIdentitySchema = .empty
-    var currentSortState = SortState()
-
-    /// The direction a first click on an unsorted column produces.
-    ///
-    /// `SortableHeaderView` and `DataGridColumnPool` are shared with the Structure, Create Table and
-    /// Inspector grids, which list columns rather than rows and have nothing to do with a Data Grid
-    /// setting, so the grid says whether the preference is its own.
-    var appliesRowSortPreferences: Bool = false
-    var supportsColumnSort: Bool = true
-
-    var firstClickSortDirection: SortDirection {
-        guard appliesRowSortPreferences else { return .ascending }
-        return AppSettingsManager.shared.dataGrid.defaultSortDirection
-    }
-
-    var appliesRowCopyFormat: Bool = false
-
-    var rowCopyFormat: RowCopyFormat {
-        guard appliesRowCopyFormat else { return .rows }
-        return AppSettingsManager.shared.dataGrid.rowCopyFormat
-    }
-
-    private var columnIndexByDataIndex: [Int: Int] = [:]
-    /// Display position to data index, rebuilt lazily. `presentedDataColumns` reads it; a drag and
-    /// the cell-range fill both ask per event and per row, and deriving it walks every attached
-    /// column, so it is not a lookup to repeat. See `DataGridView+ColumnDisplayOrder`.
-    var cachedPresentedDataColumns: [Int]?
-    /// The reverse of `cachedPresentedDataColumns`, invalidated with it.
-    var cachedDisplayPositionByDataColumn: [Int: Int]?
-    private static let selectionCacheLogger = Logger(subsystem: "com.TablePro", category: "DataGrid.ColumnIndexCache")
-
-    func tableColumnIndex(for dataIndex: Int) -> Int? {
-        if let cached = columnIndexByDataIndex[dataIndex] {
-            return cached
-        }
-        guard let tableView,
-              let identifier = identitySchema.identifier(for: dataIndex) else { return nil }
-        let resolved = tableView.column(withIdentifier: identifier)
-        guard resolved >= 0 else { return nil }
-        columnIndexByDataIndex[dataIndex] = resolved
-        return resolved
-    }
-
-    /// Takes an owner-driven filter change without writing it back, which a plain assignment would.
-    func adoptValueFilter(_ state: GridValueFilterState) {
-        storedValueFilterState = state
-    }
-
-    /// Takes over the formatted text and viewport anchor the owner kept while no grid was mounted.
-    ///
-    /// The owner hands back a fresh state whenever the inputs that decide the text have moved, so
-    /// there is nothing to validate here.
-    func adoptDisplayState(_ state: DataGridDisplayState) {
-        guard state !== displayState else { return }
-        displayState = state
-        pendingScrollAnchorRow = state.firstVisibleRow
-        /// Both directions, because either side can be the one that knows. A fresh coordinator
-        /// takes the schema and formats the state carries, so its first update does not report them
-        /// as a change and clear the text. A state handed over while the grid stays mounted carries
-        /// neither, and the writers that would fill them are change-gated and will not fire, so it
-        /// takes them from here instead and the next remount still restores.
-        if let schema = state.identitySchema {
-            identitySchema = schema
-        } else {
-            state.identitySchema = identitySchema
-        }
-        if let formats = state.displayFormats {
-            columnDisplayFormats = formats
-        } else {
-            state.displayFormats = columnDisplayFormats
-        }
-    }
-
-    /// Drops only the data index to `tableColumns` map, for a column that moved under a live reorder
-    /// drag. The display order, and the selection held in display positions, stay as they were
-    /// until the reorder commits, so the selection keeps naming the cells the user picked.
-    func invalidateTableColumnIndexMap() {
-        columnIndexByDataIndex.removeAll()
-    }
-
-    func invalidateColumnIndexCache() {
-        invalidatePresentedColumnCache()
-        guard !columnIndexByDataIndex.isEmpty else { return }
-        Self.selectionCacheLogger.debug("invalidate column index cache (had \(self.columnIndexByDataIndex.count))")
-        columnIndexByDataIndex.removeAll()
-    }
-
-    func columnIdentifier(for dataIndex: Int) -> NSUserInterfaceItemIdentifier? {
-        identitySchema.identifier(for: dataIndex)
-    }
-
-    func dataColumnIndex(from identifier: NSUserInterfaceItemIdentifier) -> Int? {
-        identitySchema.dataIndex(from: identifier)
-    }
-
-    /// Whether the result presents this column, regardless of whether the window has it mounted.
-    func presentsColumn(_ column: NSTableColumn) -> Bool {
-        columnPool.presentsColumn(column)
-    }
-
-    /// Whether this position in `tableColumns` holds one of the columns the result presents.
-    ///
-    /// The row-number column and the window's two spacers are attached columns as well, and one
-    /// spacer sits immediately before the first data column, so no fixed position answers this.
-    func presentsColumn(atTableColumnIndex index: Int) -> Bool {
-        guard let tableView else { return false }
-        return columnPool.presentsColumn(atTableColumnIndex: index, in: tableView)
-    }
-
-    func firstPresentedColumnIndex() -> Int? {
-        guard let tableView else { return nil }
-        return columnPool.firstPresentedColumnIndex(in: tableView)
-    }
-
-    func lastPresentedColumnIndex() -> Int? {
-        guard let tableView else { return nil }
-        return columnPool.lastPresentedColumnIndex(in: tableView)
-    }
-
-    func nextPresentedColumnIndex(after index: Int) -> Int? {
-        guard let tableView else { return nil }
-        return columnPool.nextPresentedColumnIndex(after: index, in: tableView)
-    }
-
-    func previousPresentedColumnIndex(before index: Int) -> Int? {
-        guard let tableView else { return nil }
-        return columnPool.previousPresentedColumnIndex(before: index, in: tableView)
-    }
-
-    /// The columns the user is looking at, which is every presented column and not merely the
-    /// mounted ones. Copy, find and size-all all read this, so narrowing it to the window would
-    /// silently drop the columns off screen from a copied row or a search.
-    func visibleColumnDataIndices() -> [Int]? {
-        guard let tableView else { return nil }
-        return tableView.tableColumns
-            .filter { presentsColumn($0) }
-            .compactMap { dataColumnIndex(from: $0.identifier) }
-    }
-
-    var columnLayoutKey: ColumnLayoutTableKey? {
-        guard let connectionId, let tableName, !tableName.isEmpty else { return nil }
-        return ColumnLayoutTableKey(
-            connectionId: connectionId,
-            databaseName: databaseName ?? "",
-            schemaName: schemaName,
-            tableName: tableName
-        )
-    }
-
-    func apply(configuration: DataGridConfiguration, isEditable: Bool) {
-        let identityChanged = connectionId != configuration.connectionId
-            || tableName != configuration.tableName
-            || databaseName != configuration.databaseName
-            || schemaName != configuration.schemaName
-            || tabType != configuration.tabType
-        if identityChanged {
-            flushPendingColumnLayoutPersistence()
-            columnLayoutPersistenceGeneration &+= 1
-        }
-        self.isEditable = isEditable
-        editRefusalMessage = configuration.editRefusalMessage
-        lockedColumns = configuration.lockedColumns
-        checkboxColumns = configuration.checkboxColumns
-        supportsColumnCommands = configuration.supportsColumnCommands
-        supportsValueFilter = configuration.supportsValueFilter
-        filterMenuColumnTypes = configuration.filterMenuColumnTypes
-        tableView?.toolTip = isEditable ? nil : configuration.editRefusalMessage
-        dropdownColumns = configuration.dropdownColumns
-        typePickerColumns = configuration.typePickerColumns
-        customDropdownOptions = configuration.customDropdownOptions
-        connectionId = configuration.connectionId
-        databaseType = configuration.databaseType
-        tableName = configuration.tableName
-        databaseName = configuration.databaseName
-        schemaName = configuration.schemaName
-        primaryKeyColumns = configuration.primaryKeyColumns
-        tabType = configuration.tabType
-        appliesRowSortPreferences = configuration.appliesRowSortPreferences
-        appliesRowCopyFormat = configuration.appliesRowCopyFormat
-        supportsColumnSort = configuration.supportsColumnSort
-    }
-
-    /// A grid with no table behind it keeps a saved column order only while its columns are still the
-    /// ones that order was saved for.
-    ///
-    /// A query result's columns are authored by the SELECT list and their order is meaningful, so an
-    /// order saved for a different set must not be replayed over it: `computeTargetOrder` appends
-    /// every column the saved order does not name, which landed a newly written column at the far
-    /// right instead of where it was typed (#1565). Dropping the order outright answered that and
-    /// also threw away orders the columns had never moved under, so a reorder was captured, persisted
-    /// and then silently undone on the next update.
-    func savedColumnLayout(binding: ColumnLayoutState) -> ColumnLayoutState? {
-        guard tabType == .table else {
-            var layout = binding
-            if let order = layout.columnOrder, !canRestoreColumnOrder(order) {
-                layout.columnOrder = nil
-            }
-            guard !layout.columnWidths.isEmpty
-                || layout.columnContentWidths?.isEmpty == false
-                || layout.columnOrder?.isEmpty == false
-                || layout.frozenColumnCount > 0 else { return nil }
-            return layout
-        }
-
-        if let columnLayoutKey, let stored = layoutPersister.load(for: columnLayoutKey) {
-            return stored
-        }
-        if binding.columnWidths.isEmpty,
-           binding.columnContentWidths?.isEmpty != false,
-           binding.columnOrder == nil,
-           binding.frozenColumnCount == 0 {
-            return nil
-        }
-        return binding
-    }
-
-    /// A saved order is a list of names, and a name identifies a column only while the names are
-    /// unique. `SELECT a.id, b.id` gives two columns called `id`, and `ColumnIdentitySchema` resolves
-    /// a duplicate name to its last slot, so replaying such an order swaps the two columns.
-    private func canRestoreColumnOrder(_ order: [String]) -> Bool {
-        let columns = identitySchema.columnNames
-        let names = Set(columns)
-        return names.count == columns.count && Set(order) == names
-    }
-
-    /// A saved width is the width the column had, accessory or not. Nothing here re-derives it from
-    /// the accessory, because the accessory no longer contributes to column width: a layout saved
-    /// while the arrow was showing and restored before it is known has to come back the same size.
-    func resolvedColumnLayout(
-        binding: ColumnLayoutState,
-        liveWidths: [String: CGFloat]
-    ) -> ColumnLayoutState? {
-        resolvedColumnLayout(saved: savedColumnLayout(binding: binding), liveWidths: liveWidths)
-    }
-
-    func resolvedColumnLayout(
-        saved: ColumnLayoutState?,
-        liveWidths: [String: CGFloat]
-    ) -> ColumnLayoutState? {
-        guard let saved else {
-            guard !liveWidths.isEmpty else { return nil }
-            return ColumnLayoutState(columnWidths: liveWidths)
-        }
-        guard !liveWidths.isEmpty else { return saved }
-        return saved.mergingWidths(liveWidths)
-    }
-
-    static func liveWidthsForSameTable(
-        previous: ColumnLayoutTableKey?,
-        current: ColumnLayoutTableKey?,
-        liveWidths: [String: CGFloat]
-    ) -> [String: CGFloat] {
-        previous == current ? liveWidths : [:]
-    }
-
-    func currentColumnWidths() -> [String: CGFloat] {
-        guard let tableView else { return [:] }
-        var widths: [String: CGFloat] = [:]
-        for column in tableView.tableColumns
-        where column.identifier != ColumnIdentitySchema.rowNumberIdentifier {
-            guard let dataIndex = dataColumnIndex(from: column.identifier),
-                  let name = identitySchema.columnName(for: dataIndex) else { continue }
-            widths[name] = max(widths[name] ?? 0, column.width)
-        }
-        return widths
-    }
-
-    func synchronizeUserSizedColumns(
-        with savedLayout: ColumnLayoutState?,
-        columns: [String],
-        tableIdentityChanged: Bool
-    ) {
-        let savedWidthNames = Set(savedLayout?.columnWidths.keys.map { $0 } ?? [])
-        let savedContentWidthNames = Set(savedLayout?.columnContentWidths?.keys.map { $0 } ?? [])
-        let savedNames = savedWidthNames.union(savedContentWidthNames)
-        if tableIdentityChanged || !hasUnpersistedColumnLayoutChanges {
-            userSizedColumnNames = savedNames
-        } else {
-            userSizedColumnNames.formUnion(savedNames)
-        }
-        userSizedColumnNames.formIntersection(columns)
-    }
-
-    @discardableResult
-    func markColumnWidthUserSized(_ column: NSTableColumn) -> Bool {
-        guard column.identifier != ColumnIdentitySchema.rowNumberIdentifier,
-              let dataIndex = dataColumnIndex(from: column.identifier),
-              let name = identitySchema.columnName(for: dataIndex)
-        else { return false }
-        userSizedColumnNames.insert(name)
-        unownedRestoredColumnNames.remove(name)
-        hasUnpersistedColumnLayoutChanges = true
-        return true
-    }
-
-    // A table tab's binding may never have carried the frozen count restored from disk.
-    func resetColumnGeometry() {
-        resetColumnWidthOwnership()
-        frozenColumnCount = 0
-    }
-
-    func resetColumnWidthOwnership() {
-        userSizedColumnNames.removeAll()
-        shouldRecalculateAutomaticColumnWidths = true
-        hasUnpersistedColumnLayoutChanges = false
-        layoutPersistTask?.cancel()
-        layoutPersistTask = nil
-        pendingColumnLayoutPersistence = nil
-    }
-
-    /// Dropping a live width is what asks the reconcile pass to size that column from its content
-    /// again, so only an explicit auto-fit does it. A column the user sized keeps its width even
-    /// then, and no accessory change reaches here at all.
-    func liveWidthsForReconciliation(_ liveWidths: [String: CGFloat]) -> [String: CGFloat] {
-        guard shouldRecalculateAutomaticColumnWidths else { return liveWidths }
-        shouldRecalculateAutomaticColumnWidths = false
-        return liveWidths.filter { userSizedColumnNames.contains($0.key) }
-    }
-
-    func captureColumnLayout() -> ColumnLayoutState? {
-        guard let tableView else { return nil }
-        let tableRows = tableRowsProvider()
-        guard !tableRows.columns.isEmpty else { return nil }
-
-        var legacyWidths: [String: CGFloat] = [:]
-        var contentWidths: [String: CGFloat] = [:]
-        var order: [String] = []
-        for column in tableView.tableColumns
-        where column.identifier != ColumnIdentitySchema.rowNumberIdentifier {
-            guard let colIndex = dataColumnIndex(from: column.identifier),
-                  colIndex < tableRows.columns.count else { continue }
-            let name = tableRows.columns[colIndex]
-            order.append(name)
-            if userSizedColumnNames.contains(name) {
-                legacyWidths[name] = max(legacyWidths[name] ?? 0, column.width)
-                contentWidths[name] = max(contentWidths[name] ?? 0, column.width)
-            }
-        }
-
-        guard !order.isEmpty else { return nil }
-        var layout = ColumnLayoutState()
-        layout.columnWidths = legacyWidths
-        layout.columnContentWidths = contentWidths.isEmpty ? nil : contentWidths
-        layout.columnOrder = order
-        layout.frozenColumnCount = frozenColumnCount
-        return layout
-    }
-
-    func persistColumnLayoutToStorage() {
-        layoutPersistTask?.cancel()
-        layoutPersistTask = nil
-        let pending = makePendingColumnLayoutPersistence()
-        pendingColumnLayoutPersistence = nil
-        guard let pending else { return }
-        persistColumnLayout(pending)
-    }
-
-    func makePendingColumnLayoutPersistence() -> PendingColumnLayoutPersistence? {
-        guard let layout = captureColumnLayout() else { return nil }
-        return PendingColumnLayoutPersistence(
-            layout: layout,
-            tableKey: columnLayoutKey,
-            writesToTableStorage: tabType == .table
-        )
-    }
-
-    func persistColumnLayout(_ pending: PendingColumnLayoutPersistence) {
-        onColumnLayoutDidChange?(pending.layout)
-        if pending.writesToTableStorage, let tableKey = pending.tableKey {
-            layoutPersister.save(pending.layout, for: tableKey)
-        }
-        hasUnpersistedColumnLayoutChanges = false
-    }
-
-    weak var tableView: NSTableView?
-    let cellFactory = DataGridCellFactory()
-    let cellRegistry: DataGridCellRegistry
-    let columnPool = DataGridColumnPool()
-    /// Draws every data cell in the grid. One renderer for the whole table, because its only state
-    /// is a cache of laid-out lines and every row draws the same values as it scrolls.
-    let cellRenderer = DataGridCellRenderer()
-    /// The cell an overlay editor or viewer is open over, which draws no text of its own behind it.
-    var overlayCell: CellPosition? {
-        didSet {
-            guard overlayCell != oldValue else { return }
-            for position in [oldValue, overlayCell].compactMap({ $0 }) {
-                redrawCell(row: position.row, columnIndex: position.column)
-            }
-        }
-    }
-
-    /// Repaints every drawn cell on screen, for a change that moves all of them at once.
-    func redrawVisibleCells() {
-        guard let tableView else { return }
-        tableView.enumerateAvailableRowViews { rowView, _ in
-            (rowView as? DataGridRowView)?.redrawCells()
-        }
-    }
-
-    /// Repaints whole rows, across the row-number column and every drawn cell.
-    ///
-    /// `reloadData(forRowIndexes:columnIndexes:)` rebuilds a cell view, and the row-number column is
-    /// the only one that still mounts one, so on its own it repaints a row's number and nothing
-    /// else. Every caller that used to reload a row's full column range goes through here (#2381).
-    ///
-    /// A row past the end is dropped rather than passed on: `reloadData(forRowIndexes:)` raises
-    /// `NSRangeException` for one, and a row view can outlive the result that shrank under it.
-    func repaintRows(_ rows: IndexSet) {
-        guard let tableView else { return }
-        let rows = rows.filteredIndexSet { $0 >= 0 && $0 < tableView.numberOfRows }
-        guard !rows.isEmpty else { return }
-        let rowNumberColumn = tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        if rowNumberColumn >= 0 {
-            tableView.reloadData(forRowIndexes: rows, columnIndexes: IndexSet(integer: rowNumberColumn))
-        }
-        for row in rows {
-            (tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView)?.redrawCells()
-        }
-        repaintRowGutter()
-    }
-
-    /// Repaints one drawn cell, which is what a mounted cell got from `setNeedsDisplay` on itself.
-    func redrawCell(row: Int, columnIndex: Int) {
-        guard let tableView,
-              let rowView = tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView,
-              let position = tableColumnIndex(for: columnIndex) else { return }
-        rowView.redrawCell(atTableColumnIndex: position)
-    }
-    let selectionController = GridSelectionController()
-    private(set) lazy var selectionSummaryTracker = SelectionSummaryTracker(
-        inputProvider: { [weak self] in self?.selectionSummaryInput() }
-    )
-    var overlayEditor: CellOverlayEditor?
-    var overlayViewer: CellOverlayViewer?
-
-    var settingsCancellable: AnyCancellable?
-    var themeCancellable: AnyCancellable?
-    private(set) var themeScope: ThemeScope
-    var systemTimeZoneCancellable: AnyCancellable?
-    private var accessibilityActivationObserver: (any NSObjectProtocol)?
-    private var accessibilityMountedRows = NSRange(location: 0, length: 0)
-    private var lastDataGridSettings: DataGridSettings
-
-    @Binding var selectedRowIndices: Set<Int>
-
-    private(set) var cachedRowCount: Int = 0
-    private(set) var cachedColumnCount: Int = 0
-    private(set) var enumOrSetColumns: Set<Int> = []
-    private(set) var fkColumns: Set<Int> = []
-    private(set) var columnPresentations: [DataGridColumnPresentationIdentity: DataGridColumnPresentation] = [:]
-    private(set) var userSizedColumnNames: Set<String> = []
-    /// Widths restored from a layout that recorded no ownership, so `userSizedColumnNames` counts
-    /// them only because they were saved at all. An accessory that resolves later is still allowed
-    /// to widen these, because nobody chose their width.
-    var unownedRestoredColumnNames: Set<String> = []
-    var isApplyingProgrammaticRowSelection = false
-    /// Called on the way out with what this grid had selected, so an owner can keep it.
-    var onSelectionTeardown: (@MainActor (Set<Int>, GridSelection) -> Void)?
-    /// Whether the owner's stored selection has been put back yet. A restore is one-shot per mount:
-    /// after it, the reader's own gestures are the only thing that moves the selection.
-    var hasRestoredSelection = false
-    weak var rowGutter: DataGridRowGutterView?
-    var frozenColumnCount = 0 {
-        didSet {
-            guard frozenColumnCount != oldValue else { return }
-            frozenColumnsDidChange()
-        }
-    }
-    // What the owner's binding last said, so only an owner-side change (Reset Columns) is adopted.
-    var lastBoundFrozenColumnCount = 0
-    /// The last value `publishRowSelection()` wrote, or nil before it has written one. `nil` has to
-    /// mean "nothing published yet" rather than "empty", or a tab restoring an empty selection would
-    /// be mistaken for one this coordinator produced and never reach the table view.
-    private(set) var lastPublishedRowSelection: Set<Int>?
-    /// What `NSTableView.selectedRowIndexes` last reported, which is what `resolvedFocus` compares
-    /// against. The binding cannot serve, because it carries the cell selection's rows too.
-    var lastTableViewRowSelection: Set<Int> = []
-    var isRebuildingColumns: Bool = false
-    var hasUnpersistedColumnLayoutChanges = false
-    var shouldRecalculateAutomaticColumnWidths = false
-    var pendingCellPresentationRefresh = false
-    var isEscapeCancelling = false
-    var isCommittingCellEdit = false
-    var layoutPersistTask: Task<Void, Never>?
-    var pendingColumnLayoutPersistence: PendingColumnLayoutPersistence?
-    var columnLayoutPersistenceGeneration = 0
-    var lastUpdateSnapshot: DataGridUpdateSnapshot?
-    var prewarmTask: Task<Void, Never>?
-    var prewarmResumeTask: Task<Void, Never>?
-    var scrollObservers: [NSObjectProtocol] = []
-    static let prewarmFrameBudget: Duration = .milliseconds(2)
-    static let prewarmResumeDelay: Duration = .milliseconds(300)
-
-    static let rowViewIdentifier = NSUserInterfaceItemIdentifier("TableRowView")
-    let visualIndex = RowVisualIndex()
-    var highlightRuleSet: HighlightRuleSet = .empty
-    private let largeDatasetThreshold = 5_000
-
-    var isLargeDataset: Bool { cachedRowCount > largeDatasetThreshold }
-
-    init(
-        changeManager: AnyChangeManager,
-        isEditable: Bool,
-        selectedRowIndices: Binding<Set<Int>>,
-        delegate: (any DataGridViewDelegate)?,
-        layoutPersister: any ColumnLayoutPersisting,
-        themeScope: ThemeScope = .live
-    ) {
-        self.changeManager = changeManager
-        self.isEditable = isEditable
-        self._selectedRowIndices = selectedRowIndices
-        self.delegate = delegate
-        self.layoutPersister = layoutPersister
-        self.themeScope = themeScope
-        self.lastDataGridSettings = AppSettingsManager.shared.dataGrid
-        self.cellRegistry = DataGridCellRegistry(scope: themeScope)
-        super.init()
-        cellRegistry.accessoryDelegate = self
-        updateCache()
-
-        observeThemeChanges()
-        observeSystemTimeZoneChanges()
-        observeAccessibilityActivation()
-
-        settingsCancellable = AppEvents.shared.dataGridSettingsChanged
-            .receive(on: RunLoop.main)
-            .sink { [weak self] _ in
-                guard let self else { return }
-                let settings = AppSettingsManager.shared.dataGrid
-                let prev = self.lastDataGridSettings
-                self.lastDataGridSettings = settings
-                self.applyDataGridSettingsChange(from: prev, to: settings)
-            }
-    }
-
-    func applyDataGridSettingsChange(from previous: DataGridSettings, to settings: DataGridSettings) {
-        guard tableView != nil else { return }
-        applyRowHeight(DataGridMetrics.rowHeight(settings.rowHeight, font: ThemeEngine.shared.dataGridFonts.regular))
-
-        let dataChanged = previous.dateFormat != settings.dateFormat
-            || previous.nullDisplay != settings.nullDisplay
-            || previous.enableSmartValueDetection != settings.enableSmartValueDetection
-
-        if dataChanged {
-            reformatDisplayedText()
-        } else if previous.showInvisibleCharacters != settings.showInvisibleCharacters {
-            redrawVisibleCells()
-        }
-    }
-
-    func applyRowHeight(_ rowHeight: CGFloat) {
-        guard let tableView, tableView.rowHeight != rowHeight else { return }
-        keepingFirstVisibleRow {
-            tableView.rowHeight = rowHeight
-            tableView.tile()
-        }
-        repaintRowGutter()
-    }
-
-    func observeThemeChanges() {
-        themeCancellable = themeScope.changes
-            .receive(on: RunLoop.main)
-            .sink { [weak self] _ in self?.themeDidChange() }
-    }
-
-    /// A fixed scope never changes, so the preview hands over a new one for each draft.
-    func adoptThemeScope(_ scope: ThemeScope) {
-        guard scope !== themeScope else { return }
-        themeScope = scope
-        cellRegistry.adopt(scope, in: tableView?.effectiveAppearance ?? NSApp?.effectiveAppearance ?? .currentDrawing())
-        if themeCancellable != nil {
-            observeThemeChanges()
-        }
-        themeDidChange()
-    }
-
-    // Also fires for Accent, Highlight and Increase Contrast, none of which moves a value: repaint, never reload.
-    func themeDidChange() {
-        guard let tableView else { return }
-        cellRegistry.preparePalette(in: tableView.effectiveAppearance)
-        DataGridBodyChrome.applyThemeColors(to: tableView, scope: themeScope)
-        tableView.headerView?.needsDisplay = true
-        tableView.cornerView?.needsDisplay = true
-        restyleRowNumberCells(in: tableView)
-        tableView.enumerateAvailableRowViews { rowView, _ in
-            rowView.needsDisplay = true
-            (rowView as? DataGridRowView)?.redrawCells()
-        }
-        let resize = {
-            // The row-number font decides the column's width, which the pinned gutter mirrors.
-            self.resizeRowNumberColumnForCurrentRange()
-            self.applyRowHeight(DataGridMetrics.rowHeight(
-                AppSettingsManager.shared.dataGrid.rowHeight,
-                font: ThemeEngine.shared.dataGridFonts.regular
-            ))
-        }
-        if let openOverlay = [overlayEditor as CellOverlayBase?, overlayViewer].compactMap({ $0 }).first(where: { $0.isActive }) {
-            openOverlay.followGrid(through: resize)
-        } else {
-            resize()
-        }
-        repaintRowGutter()
-        selectionController.overlay?.needsDisplay = true
-    }
-
-    /// The mounted row-number cells carry the number for accessibility and a row drag image, and
-    /// take their font and color when mounted, so the ones already on screen are restyled in place.
-    private func restyleRowNumberCells(in tableView: NSTableView) {
-        let column = tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        guard column >= 0 else { return }
-        let font = ThemeEngine.shared.dataGridFonts.rowNumber
-        tableView.enumerateAvailableRowViews { _, row in
-            guard let field = (tableView.view(atColumn: column, row: row, makeIfNecessary: false) as? NSTableCellView)?
-                .textField else { return }
-            field.font = font
-            field.textColor = cellRegistry.rowNumberColor(for: visualState(for: row))
-        }
-    }
-
-    /// The grid mounts no view for a data cell, so a client that attaches mid-session finds a table
-    /// of empty cells until the visible rows are built again. The remount is deferred off the
-    /// accessibility query that raised the flag, because rebuilding rows inside it would re-enter
-    /// the tree AppKit is walking.
-    private func observeAccessibilityActivation() {
-        accessibilityActivationObserver = NotificationCenter.default.addObserver(
-            forName: DataGridAccessibility.didActivateNotification,
-            object: nil,
-            queue: nil
-        ) { [weak self] _ in
-            Task { @MainActor [weak self] in
-                self?.remountAccessibilityCells()
-            }
-        }
-    }
-
-    /// Registered for the life of the coordinator, so it has to come off when the grid goes.
-    ///
-    /// `NotificationCenter` retains a block observer's closure, and a coordinator is built fresh on
-    /// every mount, so an entry left behind at teardown is never fired again and never reclaimed.
-    /// The closure captures `self` weakly, so this leaks the registration rather than the grid.
-    func detachAccessibilityActivationObserver() {
-        guard let accessibilityActivationObserver else { return }
-        NotificationCenter.default.removeObserver(accessibilityActivationObserver)
-        self.accessibilityActivationObserver = nil
-    }
-
-    var hasAccessibilityActivationObserver: Bool { accessibilityActivationObserver != nil }
-
-    /// Whether this row is one an assistive client can be reading right now.
-    ///
-    /// Walking the accessibility tree makes `NSTableView` prepare every row of the page, not the
-    /// twenty-five on screen, and it asks for a view for each one. Mounting a cell there put 9,000
-    /// views and a 21,000 element tree behind a 1,000-row page, which is the cost `#2381` removed
-    /// and enough to starve the app of the main thread. Only the viewport mounts, and scrolling
-    /// mounts what it brings into view.
-    func mountsAccessibilityCell(forRow row: Int) -> Bool {
-        guard let tableView else { return false }
-        return NSLocationInRange(row, tableView.rows(in: tableView.visibleRect))
-    }
-
-    /// Rebuilds the cells for the rows now on screen. A row prepared while it was off screen was
-    /// answered with no view and is never asked again, so the rows a scroll reveals have to be
-    /// reloaded rather than waited for.
-    func remountAccessibilityCells() {
-        guard DataGridAccessibility.isActive, let tableView else { return }
-        let visible = tableView.rows(in: tableView.visibleRect)
-        guard visible.length > 0, !NSEqualRanges(visible, accessibilityMountedRows) else { return }
-        let upperBound = min(visible.location + visible.length, tableView.numberOfRows)
-        guard visible.location >= 0, upperBound > visible.location, tableView.numberOfColumns > 0 else { return }
-        accessibilityMountedRows = visible
-        tableView.reloadData(
-            forRowIndexes: IndexSet(integersIn: visible.location..<upperBound),
-            columnIndexes: IndexSet(integersIn: 0..<tableView.numberOfColumns)
-        )
-    }
-
-    func releaseData() {
-        prewarmTask?.cancel()
-        prewarmTask = nil
-        prewarmResumeTask?.cancel()
-        prewarmResumeTask = nil
-        detachScrollObservers()
-        selectionController.clear()
-        pendingColumnJump = nil
-        overlayEditor?.dismiss(commit: false)
-        overlayViewer?.dismiss()
-        settingsCancellable?.cancel()
-        settingsCancellable = nil
-        themeCancellable?.cancel()
-        themeCancellable = nil
-        systemTimeZoneCancellable?.cancel()
-        systemTimeZoneCancellable = nil
-        detachAccessibilityActivationObserver()
-        visualIndex.clear()
-        highlightRuleSet = .empty
-        displayCache.removeAll()
-        columnDisplayFormats = []
-        cachedRowCount = 0
-        cachedColumnCount = 0
-        invalidateColumnIndexCache()
-        valueFilteredIDs = nil
-        // Local only: this runs while the window is being torn down, and the filter's owner is
-        // either about to go away with it or is deliberately keeping the filter for the next mount.
-        valueFilterBinding = nil
-        displayOrderProvider = nil
-        adoptValueFilter(GridValueFilterState())
-        lastUpdateSnapshot = nil
-        columnPool.detachFromTableView()
-        if let tableView {
-            while let col = tableView.tableColumns.last {
-                tableView.removeTableColumn(col)
-            }
-            tableView.reloadData()
-        }
-        delegate = nil
-        dismissPopoversBoundToDisplayPositions()
-        activeFKPreviewPopover?.close()
-        clearFKPreviewState()
-    }
-
-    func updateCache() {
-        let tableRows = tableRowsProvider()
-        cachedRowCount = displayIDs?.count ?? tableRows.count
-        cachedColumnCount = tableRows.columns.count
-        /// A reload throws away the cells that were mounted, so the record of which rows carry one
-        /// has to go with them or the next scroll decides there is nothing to remount.
-        accessibilityMountedRows = NSRange(location: 0, length: 0)
-        resizeRowNumberColumnForCurrentRange()
-    }
-
-    func resizeRowNumberColumnForCurrentRange() {
-        guard let tableView,
-              let column = tableView.tableColumns.first(where: {
-                  $0.identifier == ColumnIdentitySchema.rowNumberIdentifier
-              }),
-              !column.isHidden else { return }
-        let maxRowNumber = paginationOffsetProvider() + cachedRowCount
-        DataGridView.sizeRowNumberColumn(column, forMaxRowNumber: maxRowNumber)
-        synchronizeRowGutter()
-    }
-
-    private func bumpDisplayRevision() {
-        displayRevision &+= 1
-        delegate?.dataGridDisplayOrderChanged()
-    }
-
-    /// Drops the row selection before a wholesale replacement.
-    ///
-    /// `reloadData()` does clear `selectedRowIndexes` on its own, measured, whatever the new row
-    /// count is. What it does not do is tell anyone: it fires no `tableViewSelectionDidChange`, so
-    /// every mirror of the selection would go on reporting positions the table view no longer holds.
-    /// Deselecting here is what publishes the change.
-    func clearRowSelection() {
-        guard let tableView, !tableView.selectedRowIndexes.isEmpty else { return }
-        tableView.deselectAll(nil)
-    }
-
-    /// A selection the app made, not the reader. The flag is what keeps the selection delegate from
-    /// reading it back as a gesture.
-    func selectRowsProgrammatically(_ indexes: IndexSet, in tableView: NSTableView) {
-        isApplyingProgrammaticRowSelection = true
-        tableView.selectRowIndexes(indexes, byExtendingSelection: false)
-        isApplyingProgrammaticRowSelection = false
-    }
-
-    /// Publishes the rows every command already acts on, so the readouts name the same set.
-    ///
-    /// The cell selection's rows win, because a cell drag is how most multi-row work starts and
-    /// Delete, Copy and the row menu have always read it through `currentRowSelection()`. The
-    /// binding did not: it copied `NSTableView.selectedRowIndexes`, which `mouseDown` pins to the
-    /// single anchor row for the whole of a drag, so a drag over six rows reported one selected row
-    /// and deleted six.
-    ///
-    /// The row half is passed in rather than read back off the binding, which is the copy this
-    /// writes; reading it here would make the derivation circular and no row selection would ever
-    /// reach it. `lastPublishedRowSelection` is what lets `syncSelection` tell a value published
-    /// here from one the app set from outside.
-    func publishRowSelection(rowSelection: Set<Int>) {
-        let resolved = selectionController.isEmpty
-            ? rowSelection
-            : Set(selectionController.selection.affectedRows)
-        lastPublishedRowSelection = resolved
-        guard selectedRowIndices != resolved else { return }
-        selectedRowIndices = resolved
-    }
-
-    /// The cell selection moved and the row selection did not, so the row half comes off the table
-    /// view. A coordinator with no table view has only the binding to fall back on.
-    func publishRowSelection() {
-        publishRowSelection(rowSelection: tableView.map { Set($0.selectedRowIndexes) } ?? selectedRowIndices)
-    }
-
-    func displayRow(at displayIndex: Int) -> Row? {
-        displayRow(at: displayIndex, in: tableRowsProvider())
-    }
-
-    func displayRow(at displayIndex: Int, in tableRows: TableRows) -> Row? {
-        DisplayRowMapping.row(forDisplay: displayIndex, displayIDs: displayIDs, in: tableRows)
-    }
-
-    func tableRowsIndex(forDisplayRow displayIndex: Int) -> Int? {
-        DisplayRowMapping.rowIndex(forDisplay: displayIndex, displayIDs: displayIDs, in: tableRowsProvider())
-    }
-
-    func displayValue(forID id: RowID, column: Int, rawValue: PluginCellValue, columnType: ColumnType?) -> String? {
-        if let box = displayCache.box(forID: id),
-           column >= 0, column < box.values.count,
-           let cached = box.values[column] {
-            return cached
-        }
-        let format = column >= 0 && column < columnDisplayFormats.count ? columnDisplayFormats[column] : nil
-        let formatted = CellDisplayFormatter.format(
-            rawValue,
-            columnType: columnType,
-            displayFormat: format,
-            databaseType: databaseType
-        ) ?? rawValue.asText
-
-        let neededCount = max(column + 1, columnDisplayFormats.count, cachedColumnCount)
-        let box: RowDisplayBox
-        if let existing = displayCache.box(forID: id) {
-            box = existing
-            if box.values.count < neededCount {
-                box.values.reserveCapacity(neededCount)
-                for _ in box.values.count..<neededCount { box.values.append(nil) }
-            }
-        } else {
-            var values = ContiguousArray<String?>()
-            values.reserveCapacity(neededCount)
-            for _ in 0..<neededCount { values.append(nil) }
-            box = RowDisplayBox(values)
-        }
-        if column >= 0, column < box.values.count {
-            box.values[column] = formatted
-        }
-        displayCache.setBox(box, forID: id)
-        return formatted
-    }
-
-    func invalidateDisplayCache() {
-        displayCache.removeAll()
-    }
-
-    func invalidateAllDisplayCaches() {
-        displayCache.removeAll()
-        visualIndex.rebuild(from: changeManager)
-    }
-
-    @discardableResult
-    func updateDisplayFormats(_ formats: [ValueDisplayFormat?]) -> Bool {
-        applyDisplayFormats(formats)
-    }
-
-    @discardableResult
-    func syncDisplayFormats(_ formats: [ValueDisplayFormat?]) -> Bool {
-        guard formats != columnDisplayFormats else { return false }
-        return applyDisplayFormats(formats)
-    }
-
-    private func applyDisplayFormats(_ formats: [ValueDisplayFormat?]) -> Bool {
-        let remappedValueFilters = remapValueFilters(from: columnDisplayFormats, to: formats)
-        columnDisplayFormats = formats
-        displayState.displayFormats = formats
-        displayCache.removeAll()
-        delegate?.dataGridDisplayFormatChanged()
-        selectionSummaryTracker.rulesDidChange()
-        return remappedValueFilters
-    }
-
-    private func remapValueFilters(
-        from oldFormats: [ValueDisplayFormat?],
-        to newFormats: [ValueDisplayFormat?]
-    ) -> Bool {
-        let tableRows = tableRowsProvider()
-        var didRemap = valueFilterState.prune(againstColumns: tableRows.columns)
-
-        for column in valueFilterState.activeColumns {
-            let oldFormat = oldFormats.indices.contains(column) ? oldFormats[column] : nil
-            let newFormat = newFormats.indices.contains(column) ? newFormats[column] : nil
-            guard oldFormat != newFormat,
-                  let existing = valueFilterState.filter(forColumn: column),
-                  tableRows.columns.indices.contains(column) else { continue }
-
-            let columnType = tableRows.columnTypes.indices.contains(column)
-                ? tableRows.columnTypes[column]
-                : nil
-            var oldValuesToRemove = Set<String>()
-            var newValuesToInsert = Set<String>()
-            for row in tableRows.rows where row.values.indices.contains(column) {
-                let rawValue = row.values[column]
-                guard rawValue != .null else { continue }
-                let oldValue = filterValue(
-                    rawValue,
-                    columnType: columnType,
-                    displayFormat: oldFormat
-                )
-                guard existing.selectedValues.contains(oldValue) else { continue }
-                let newValue = filterValue(
-                    rawValue,
-                    columnType: columnType,
-                    displayFormat: newFormat
-                )
-                if oldValue != newValue {
-                    oldValuesToRemove.insert(oldValue)
-                    newValuesToInsert.insert(newValue)
-                }
-            }
-
-            var selectedValues = existing.selectedValues
-            selectedValues.subtract(oldValuesToRemove)
-            selectedValues.formUnion(newValuesToInsert)
-            guard selectedValues != existing.selectedValues else { continue }
-
-            valueFilterState.set(
-                ColumnValueFilter(selectedValues: selectedValues, includesNull: existing.includesNull),
-                columnName: tableRows.columns[column],
-                forColumn: column
-            )
-            didRemap = true
-        }
-        return didRemap
-    }
-
-    private func filterValue(
-        _ rawValue: PluginCellValue,
-        columnType: ColumnType?,
-        displayFormat: ValueDisplayFormat?
-    ) -> String {
-        CellDisplayFormatter.format(
-            rawValue,
-            columnType: columnType,
-            displayFormat: displayFormat,
-            databaseType: databaseType
-        ) ?? rawValue.asText ?? ""
-    }
-
-    func reloadAfterDisplayFormatChange() {
-        guard let tableView else { return }
-        tableView.reloadData()
-        startBackgroundPrewarm()
-    }
-
-    func cacheDisplayRow(at displayIndex: Int, in tableRows: TableRows) {
-        guard let row = displayRow(at: displayIndex, in: tableRows) else { return }
-        guard displayCache.box(forID: row.id) == nil else { return }
-
-        let columnCount = tableRows.columns.count
-        var values = ContiguousArray<String?>()
-        values.reserveCapacity(columnCount)
-        for _ in 0..<columnCount { values.append(nil) }
-        for col in 0..<min(row.values.count, columnCount) {
-            let columnType = col < tableRows.columnTypes.count ? tableRows.columnTypes[col] : nil
-            let format = col < columnDisplayFormats.count ? columnDisplayFormats[col] : nil
-            values[col] = CellDisplayFormatter.format(
-                row.values[col],
-                columnType: columnType,
-                displayFormat: format,
-                databaseType: databaseType
-            ) ?? row.values[col].asText
-        }
-        let box = RowDisplayBox(values)
-        displayCache.setBox(box, forID: row.id)
-    }
-
-    var hasOpenCellOverlay: Bool {
-        overlayEditor?.isActive == true || overlayViewer?.isActive == true
-    }
-
-    func commitActiveCellEdit() {
-        overlayEditor?.dismiss(commit: true)
-        overlayViewer?.dismiss()
-        guard let tableView, let window = tableView.window else { return }
-        if let firstResponder = window.firstResponder as? NSView,
-           firstResponder.isDescendant(of: tableView) {
-            window.makeFirstResponder(tableView)
-        }
-    }
-
-    @discardableResult
-    internal func focusGrid() -> Bool {
-        guard let tableView, let window = tableView.window else { return false }
-        window.makeFirstResponder(tableView)
-        return true
-    }
-
-    var selectedDisplayRow: Int? {
-        guard let tableView, tableView.selectedRow >= 0 else { return nil }
-        return tableView.selectedRow
-    }
-
-    func runFind(term: String) -> [FindMatch] {
-        let tableRows = tableRowsProvider()
-        let displayCount = displayIDs?.count ?? tableRows.count
-        let columnTypes = tableRows.columnTypes
-        let visible = visibleColumnDataIndices().map(Set.init)
-
-        return FindMatcher.matches(
-            term: term,
-            displayRowCount: displayCount,
-            columnCount: tableRows.columns.count,
-            isColumnSearchable: { column in
-                guard visible?.contains(column) ?? true else { return false }
-                guard column < columnTypes.count else { return true }
-                return FindMatcher.isSearchable(
-                    columnTypes[column],
-                    displayFormat: column < columnDisplayFormats.count ? columnDisplayFormats[column] : nil
-                )
-            },
-            cellText: { [weak self] displayIndex, column in
-                guard let self,
-                      let row = displayRow(at: displayIndex, in: tableRows),
-                      column < row.values.count
-                else { return nil }
-                let rawValue = row.values[column]
-                let columnType = column < columnTypes.count ? columnTypes[column] : nil
-                guard findSearches(rawValue, column: column, columnType: columnType) else { return nil }
-                let shown = displayValue(
-                    forID: row.id,
-                    column: column,
-                    rawValue: rawValue,
-                    columnType: columnType
-                )
-                return cellRegistry.showsInvisibleCharacters ? shown : shown?.shownWithoutMarks
-            }
-        )
-    }
-
-    /// A binary cell is searched only where its column's format actually turned those bytes into
-    /// characters. The format is chosen per column and the fallback to hex happens per value, so a
-    /// column of readable text can still hold one cell whose hex Find must not match.
-    private func findSearches(_ value: PluginCellValue, column: Int, columnType: ColumnType?) -> Bool {
-        switch value {
-        case .null:
-            return false
-        case .text:
-            return true
-        case .bytes(let data):
-            guard let format = column < columnDisplayFormats.count ? columnDisplayFormats[column] : nil,
-                  format.isApplicable(to: columnType, databaseType: databaseType) else { return false }
-            return ValueDisplayFormatter.apply(data, format: format, columnType: columnType) != nil
-        }
-    }
-
-    func applyFindMatch(_ match: FindMatch?) {
-        let previous = currentFindMatch
-        guard previous != match else { return }
-        currentFindMatch = match
-
-        guard let tableView else { return }
-        let affected = IndexSet([previous?.displayRow, match?.displayRow]
-            .compactMap(\.self)
-            .filter { $0 >= 0 && $0 < tableView.numberOfRows })
-        repaintRows(affected)
-
-        guard let match, match.displayRow >= 0, match.displayRow < tableView.numberOfRows else { return }
-        tableView.scrollRowToVisible(match.displayRow)
-        if let displayColumn = tableColumnIndex(for: match.columnIndex) {
-            scrollColumnToVisible(tableColumnIndex: displayColumn)
-        }
-        tableView.selectRowIndexes(IndexSet(integer: match.displayRow), byExtendingSelection: false)
-    }
-
-    func beginEditing(displayRow: Int, column: Int) {
-        guard let tableView,
-              let displayCol = tableColumnIndex(for: column)
-        else { return }
-        guard displayRow >= 0, displayRow < tableView.numberOfRows else { return }
-        tableView.scrollRowToVisible(displayRow)
-        tableView.selectRowIndexes(IndexSet(integer: displayRow), byExtendingSelection: false)
-        scrollColumnToVisible(tableColumnIndex: displayCol)
-        beginCellEdit(row: displayRow, tableColumnIndex: displayCol)
-    }
-
-    func beginEditingFirstEditableColumn(displayRow: Int, skipping prefilled: Set<Int> = []) {
-        beginEditing(displayRow: displayRow, column: firstEditableColumn(displayRow: displayRow, skipping: prefilled))
-    }
-
-    /// Where the caret goes on a row the user just made. Column 0 is where the row starts, not
-    /// necessarily where it can be typed into: a table whose first column the server owns, such as
-    /// an identity or a stored generated column, refuses the edit and opens nothing at all, which
-    /// reads as Add Row having done nothing. A column the row was given a value for, such as a new
-    /// UUID key, is passed over so the first keystroke does not replace it, unless nothing else
-    /// takes the editor. Falls back to column 0 so a row with no editable column at all is still
-    /// selected and scrolled to.
-    func firstEditableColumn(displayRow: Int, skipping prefilled: Set<Int> = []) -> Int {
-        let editable = (0..<tableRowsProvider().columns.count).lazy
-            .filter { self.canStartInlineEdit(row: displayRow, columnIndex: $0) }
-        return editable.first { !prefilled.contains($0) } ?? editable.first ?? 0
-    }
-
-    func refreshCellPresentations() {
-        guard let tableView else { return }
-        guard overlayEditor?.isActive != true, overlayViewer?.isActive != true else {
-            pendingCellPresentationRefresh = true
-            return
-        }
-        pendingCellPresentationRefresh = false
-        let tableRows = tableRowsProvider()
-        rebuildKindSets(from: tableRows)
-        let presentationChanges = updateColumnPresentations(from: tableRows)
-        guard !presentationChanges.isEmpty else { return }
-
-        applyAccessoryWidthChanges(presentationChanges, tableRows: tableRows)
-
-        let changedTableColumnIndices = IndexSet(presentationChanges.indices.compactMap { dataIndex in
-            guard let identifier = identitySchema.identifier(for: dataIndex) else { return nil }
-            let tableColumnIndex = tableView.column(withIdentifier: identifier)
-            return tableColumnIndex >= 0 ? tableColumnIndex : nil
-        })
-        guard !changedTableColumnIndices.isEmpty else { return }
-        let visibleRange = tableView.rows(in: tableView.visibleRect)
-        guard visibleRange.length > 0 else { return }
-        let visibleRows = IndexSet(
-            integersIn: visibleRange.location..<(visibleRange.location + visibleRange.length)
-        )
-        redrawCells(rows: visibleRows, tableColumnIndexes: changedTableColumnIndices)
-    }
-
-    /// Repaints a set of drawn cells.
-    ///
-    /// `reloadData(forRowIndexes:columnIndexes:)` rebuilt a cell view per pair, which is how a
-    /// mounted cell was refreshed. A data cell has no view now, so that call reaches nothing and the
-    /// change never appears; the rows that draw the cells are asked instead.
-    func redrawCells(rows: IndexSet, tableColumnIndexes: IndexSet) {
-        guard let tableView else { return }
-        for row in rows {
-            guard let rowView = tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView else {
-                continue
-            }
-            for tableColumnIndex in tableColumnIndexes {
-                rowView.redrawCell(atTableColumnIndex: tableColumnIndex)
-            }
-        }
-    }
-
-    func flushPendingCellPresentationRefresh() {
-        guard pendingCellPresentationRefresh else { return }
-        refreshCellPresentations()
-    }
-
-    @discardableResult
-    func rebuildColumnMetadataCache(from tableRows: TableRows) -> Bool {
-        let columns = tableRows.columns
-        let nextSchema = ColumnIdentitySchema(columns: columns)
-        let schemaChanged = nextSchema != identitySchema
-
-        rebuildKindSets(from: tableRows)
-
-        guard schemaChanged else { return false }
-        identitySchema = nextSchema
-        displayState.identitySchema = nextSchema
-        displayCache.removeAll()
-        invalidateColumnIndexCache()
-        return true
-    }
-
-    /// Whether this column's cells take typed text and offer a list beside it, which is what an
-    /// editable combo box is. Read by the accessibility cell, so a menu a pointer can reach has a
-    /// role a screen reader can reach too.
-    func presentsComboBoxCell(columnIndex: Int) -> Bool {
-        guard isEditable else { return false }
-        return dropdownColumns?.contains(columnIndex) == true
-            || typePickerColumns?.contains(columnIndex) == true
-    }
-
-    func columnPresentation(
-        for columnIndex: Int,
-        in tableRows: TableRows
-    ) -> DataGridColumnPresentation {
-        let columnType = columnIndex < tableRows.columnTypes.count
-            ? tableRows.columnTypes[columnIndex]
-            : nil
-        return DataGridColumnPresentation.resolve(
-            columnType: columnType,
-            isForeignKey: fkColumns.contains(columnIndex),
-            isDropdown: dropdownColumns?.contains(columnIndex) == true,
-            isTypePicker: typePickerColumns?.contains(columnIndex) == true,
-            isEnumOrSet: enumOrSetColumns.contains(columnIndex),
-            isEditable: isEditable,
-            isCheckbox: checkboxColumns.contains(columnIndex)
-        )
-    }
-
-    @discardableResult
-    func updateColumnPresentations(from tableRows: TableRows) -> DataGridColumnPresentationChanges {
-        var next: [DataGridColumnPresentationIdentity: DataGridColumnPresentation] = [:]
-        next.reserveCapacity(tableRows.columns.count)
-        var changes = DataGridColumnPresentationChanges()
-        var occurrences: [String: Int] = [:]
-
-        for (index, name) in tableRows.columns.enumerated() {
-            let occurrence = occurrences[name, default: 0]
-            occurrences[name] = occurrence + 1
-            let identity = DataGridColumnPresentationIdentity(name: name, occurrence: occurrence)
-            let presentation = columnPresentation(for: index, in: tableRows)
-            next[identity] = presentation
-            if columnPresentations[identity] != presentation {
-                changes.indices.insert(index)
-            }
-        }
-
-        columnPresentations = next
-        return changes
-    }
-
-    private func rebuildKindSets(from tableRows: TableRows) {
-        var enumSet = Set<Int>()
-        var fkSet = Set<Int>()
-        let columns = tableRows.columns
-        let types = tableRows.columnTypes
-        let enumValues = tableRows.columnEnumValues
-        let fkKeys = tableRows.columnForeignKeys
-
-        for i in 0..<columns.count {
-            let name = columns[i]
-            let columnType = i < types.count ? types[i] : nil
-            if columnType?.supportsElementEditing == true || columnType?.isVectorType == true {
-                enumSet.insert(i)
-            } else if let values = enumValues[name], !values.isEmpty {
-                let isExcluded = columnType?.isJsonType == true
-                    || columnType?.isBlobType == true
-                    || columnType?.isBooleanType == true
-                if !isExcluded {
-                    enumSet.insert(i)
-                }
-            }
-            if fkKeys[name] != nil {
-                fkSet.insert(i)
-            }
-        }
-        enumOrSetColumns = enumSet
-        if fkSet != fkColumns {
-            fkTraceLogger.info(
-                "[fk] grid columns=\(columns.count) fkColumns=\(fkSet.count) fkMeta=\(fkKeys.count)"
-            )
-        }
-        fkColumns = fkSet
-    }
-
-    // MARK: - Row Visual State
-
-    func visualState(for row: Int) -> RowVisualState {
-        if let delegateState = delegate?.dataGridVisualState(forRow: row) {
-            return delegateState
-        }
-        guard !visualIndex.isEmpty || !highlightRuleSet.isEmpty,
-              let displayed = displayRow(at: row) else { return .empty }
-        return visualState(of: displayed, atDisplayRow: row)
-    }
-
-    // MARK: - NSTableViewDataSource
-
-    func numberOfRows(in tableView: NSTableView) -> Int {
-        displayIDs?.count ?? cachedRowCount
-    }
-}
-
-// MARK: - DataGridCellAccessoryDelegate
-
-extension TableViewCoordinator: DataGridCellAccessoryDelegate {
-    func dataGridCellDidClickFKArrow(row: Int, columnIndex: Int, intent: ReferenceOpenIntent) {
-        handleFKArrowAction(row: row, columnIndex: columnIndex, intent: intent)
-    }
-
-    func dataGridCellDidClickChevron(row: Int, columnIndex: Int) {
-        handleChevronAction(row: row, columnIndex: columnIndex)
-    }
-
-    func dataGridCellDidDoubleClick(row: Int, columnIndex: Int) {
-        guard row >= 0, columnIndex >= 0, let tableView else { return }
-        guard let tableColumn = tableColumnIndex(for: columnIndex) else { return }
-        handleCellInteraction(row: row, tableColumn: tableColumn, columnIndex: columnIndex, tableView: tableView)
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridPinnedBand.swift b/apple/TablePro/Views/Results/DataGridPinnedBand.swift
deleted file mode 100644
index c2917475bc..0000000000
--- a/apple/TablePro/Views/Results/DataGridPinnedBand.swift
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-//  DataGridPinnedBand.swift
-//  TablePro
-//
-
-import AppKit
-
-// Row-number gutter plus frozen columns, in table coordinates as they stand at scroll offset zero.
-struct DataGridPinnedBand: Equatable {
-    // Frozen columns that would leave the rest less than a third of the viewport scroll instead.
-    static let maximumViewportShare: CGFloat = 2.0 / 3.0
-
-    static let none = DataGridPinnedBand(gutterWidth: 0, width: 0, frozenColumns: [], offset: 0)
-
-    let gutterWidth: CGFloat
-    let width: CGFloat
-    let frozenColumns: IndexSet
-    let offset: CGFloat
-
-    var isFreezing: Bool { !frozenColumns.isEmpty }
-
-    static func resolve(
-        gutterWidth: CGFloat,
-        frozenColumns: IndexSet,
-        frozenTrailingEdge: CGFloat,
-        viewportWidth: CGFloat,
-        offset: CGFloat
-    ) -> DataGridPinnedBand {
-        guard !frozenColumns.isEmpty,
-              frozenTrailingEdge > gutterWidth,
-              fits(width: frozenTrailingEdge, viewportWidth: viewportWidth) else {
-            return DataGridPinnedBand(gutterWidth: gutterWidth, width: gutterWidth, frozenColumns: [], offset: offset)
-        }
-        return DataGridPinnedBand(
-            gutterWidth: gutterWidth,
-            width: frozenTrailingEdge,
-            frozenColumns: frozenColumns,
-            offset: offset
-        )
-    }
-
-    static func fits(width: CGFloat, viewportWidth: CGFloat) -> Bool {
-        viewportWidth > 0 && width <= viewportWidth * maximumViewportShare
-    }
-
-    func pins(_ tableColumnIndex: Int) -> Bool {
-        frozenColumns.contains(tableColumnIndex)
-    }
-
-    func displayed(_ rect: NSRect, ofColumn tableColumnIndex: Int) -> NSRect {
-        pins(tableColumnIndex) ? rect.offsetBy(dx: offset, dy: 0) : rect
-    }
-
-    func unscrolledPoint(_ point: NSPoint) -> NSPoint? {
-        guard isFreezing else { return nil }
-        let x = point.x - offset
-        guard x >= 0, x < width else { return nil }
-        return NSPoint(x: x, y: point.y)
-    }
-
-    // The offset moves on every scroll and changes nothing the band draws.
-    func hasSameLayout(as other: DataGridPinnedBand) -> Bool {
-        gutterWidth == other.gutterWidth && width == other.width && frozenColumns == other.frozenColumns
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridRowGutterView.swift b/apple/TablePro/Views/Results/DataGridRowGutterView.swift
deleted file mode 100644
index c32887f0d3..0000000000
--- a/apple/TablePro/Views/Results/DataGridRowGutterView.swift
+++ /dev/null
@@ -1,501 +0,0 @@
-//
-//  DataGridRowGutterView.swift
-//  TablePro
-//
-
-import AppKit
-
-/// The row-number strip, held at the viewport's leading edge however far the grid is scrolled.
-///
-/// The `__rowNumber__` column is an ordinary `NSTableColumn` at attached index 0, and clicking it is
-/// the only mouse route into whole-row selection: `KeyHandlingTableView.mouseDown` hands a press to
-/// `GridSelectionController` for every data column and falls through to `super.mouseDown` only
-/// outside one. So scrolling right took the column off screen and took whole-row selection with it,
-/// with no keyboard route either (#2664).
-///
-/// `NSScrollView.addFloatingSubview(_:for:)` is AppKit's own answer, the one it uses for floating
-/// group rows. Measured on a real `NSTableView`: for `.horizontal` the view holds window x at the
-/// leading edge across every horizontal offset, still moves in y with vertical scroll so the numbers
-/// stay level with their rows, and hit-tests normally. AppKit reparents it into a private container
-/// under the clip view, so it is not in `NSTableView.subviews` and costs nothing on a wide result,
-/// which is the whole point of the drawn-cell grid (#2381). It is document-tall, and measured, its
-/// `visibleRect` stays viewport-sized at every offset and it never takes a layer, so drawing is
-/// bounded by the viewport rather than by the row count.
-///
-/// The column stays attached underneath. It reserves the leading width, keeps every column-index
-/// computation in the grid working untouched, and keeps mounting the one cell view the grid still
-/// mounts, which is the row number's only `AXCell` and the tooltip host for the reason a reorder is
-/// unavailable. That cell carries the number for accessibility only and paints nothing, so a bounce
-/// past the leading edge, which slides the column out from under this view, shows no second number.
-@MainActor
-final class DataGridRowGutterView: NSView {
-    weak var coordinator: TableViewCoordinator?
-
-    /// Where a Shift-extend measures from. AppKit keeps its own anchor for the row selection it
-    /// owns, and does not expose it, so the strip keeps the one its own clicks establish.
-    private var selectionAnchorRow: Int?
-
-    override var isFlipped: Bool { true }
-
-    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
-
-    private var tableView: KeyHandlingTableView? { coordinator?.tableView as? KeyHandlingTableView }
-
-    /// Held so a second `observeTableGeometry()` replaces rather than stacks, and so the mount that
-    /// registered it can take it off again.
-    ///
-    /// It has to be taken off explicitly. `NotificationCenter` does NOT drop a block observer when
-    /// its token is deallocated: measured, a token that is never stored still fires, and one that is
-    /// stored and then released still fires. Only the `object:` parameter is held weakly. This
-    /// comment used to claim the opposite, which is why the gutter kept a registration per grid
-    /// mount for the life of the process. (#2667)
-    private var frameObservers: [any NSObjectProtocol] = []
-
-    private var lastBand: DataGridPinnedBand?
-    private var lastViewport: NSRect?
-
-    /// Taken off with the mount that made it, beside the coordinator's own observers.
-    var hasTableGeometryObserver: Bool { !frameObservers.isEmpty }
-
-    func detachTableGeometryObserver() {
-        frameObservers.forEach(NotificationCenter.default.removeObserver)
-        frameObservers.removeAll()
-    }
-
-    /// Follows the table view's own height.
-    ///
-    /// `NSTableView` resizes its frame to its content, and every path that changes the row count
-    /// does it: `reloadData`, `insertRows`, `removeRows`, and a row-height settings change. The
-    /// strip is not a subview of the table, so no autoresizing mask reaches it, and the geometry
-    /// sync it does get runs from `updateCache()`, which is *before* the reload. Left on that alone
-    /// the strip keeps the height the table had when it was empty, and the numbers stop as soon as
-    /// the reader scrolls past it. Observing the frame is the one hook that sees all of them.
-    func observeTableGeometry() {
-        guard let tableView else { return }
-        detachTableGeometryObserver()
-        // The clip view too: its width decides whether the frozen columns fit, with no column change.
-        for view in [tableView, tableView.enclosingScrollView?.contentView].compactMap({ $0 }) {
-            view.postsFrameChangedNotifications = true
-            frameObservers.append(NotificationCenter.default.addObserver(
-                forName: NSView.frameDidChangeNotification,
-                object: view,
-                queue: .main
-            ) { [weak self] _ in
-                MainActor.assumeIsolated { self?.synchronizeGeometry() }
-            })
-        }
-        synchronizeGeometry()
-    }
-
-    // MARK: - Geometry
-
-    /// The span the grid gives the attached column, its intercell spacing included, which is what the
-    /// strip has to cover. Zero when row numbers are off, which is what hides the strip.
-    ///
-    /// Not `column.width`: `rect(ofColumn:)` is a point wider, and the grid's separator stands on that
-    /// point. A strip one point short drew its edge beside the grid's line instead of on it, and the
-    /// two translucent lines read as one rule twice as thick as every other.
-    static func width(of tableView: NSTableView) -> CGFloat {
-        let index = tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        guard index >= 0, !tableView.tableColumns[index].isHidden else { return 0 }
-        return tableView.rect(ofColumn: index).width
-    }
-
-    /// Re-reads the width and height from the table. The width moves when the row count crosses a
-    /// digit boundary and when the Data Grid Font changes; the height moves with the row count.
-    func synchronizeGeometry() {
-        guard let tableView, let coordinator else { return }
-        let band = coordinator.pinnedBand()
-        let width = band.width
-        let height = max(tableView.bounds.height, superview?.bounds.height ?? 0)
-        isHidden = width <= 0
-        /// The same help tag the mounted row-number cell carries. The strip is the handle a reorder
-        /// drag starts from once the column has scrolled away, so the reason it cannot run has to be
-        /// reachable here too.
-        removeAllToolTips()
-        if let reason = coordinator.rowReorder.unavailableReason, band.gutterWidth > 0 {
-            addToolTip(NSRect(x: 0, y: 0, width: band.gutterWidth, height: height), owner: reason as NSString, userData: nil)
-        }
-        let layoutChanged = lastBand.map { !$0.hasSameLayout(as: band) } ?? false
-        lastBand = band
-        if layoutChanged {
-            coordinator.pinnedBandLayoutDidChange()
-        }
-        guard frame.size != NSSize(width: width, height: height) else { return }
-        setFrameSize(NSSize(width: width, height: height))
-        needsDisplay = true
-    }
-
-    // The band draws offset-zero content, so only a vertical move or a resize exposes anything new.
-    func viewportDidMove(to visible: NSRect) {
-        defer { lastViewport = visible }
-        if let lastViewport, lastViewport.minY == visible.minY, lastViewport.size == visible.size { return }
-        needsDisplay = true
-    }
-
-    // MARK: - Drawing
-
-    /// The grid's leading strip as it stands at scroll offset zero, pinned, over the strip's whole
-    /// height: each row's background and number, the frozen columns, the stripes the grid continues
-    /// past the last row, and the separator at the first data column's leading edge.
-    ///
-    /// Opaque everywhere, because the columns scroll underneath it, past the last row included. That
-    /// area matches only because the grid paints its own background there,
-    /// `DataGridBodyChrome.drawTableBackground(in:of:)`, with the same stripe this strip paints.
-    override func draw(_ dirtyRect: NSRect) {
-        guard let tableView, let coordinator else { return }
-        let band = coordinator.pinnedBand()
-        let rowNumberColumn = band.gutterWidth > 0
-            ? tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-            : -1
-        guard rowNumberColumn >= 0 || band.isFreezing else { return }
-
-        /// The same rule the header uses. An identity check on the first responder is not it: while
-        /// a cell is being edited or viewed the responder is the overlay's text view beside the
-        /// table, and the header stays emphasized, so the strip would turn grey on its own.
-        let emphasized = SortableHeaderEmphasis.isEmphasized(
-            tableViewHoldsFocus: SortableHeaderEmphasis.holdsFocus(tableView: tableView, in: tableView.window),
-            isKeyWindow: tableView.window?.isKeyWindow ?? false
-        )
-        let font = ThemeEngine.shared.dataGridFonts.rowNumber
-        let pageOffset = coordinator.paginationOffsetProvider()
-        coordinator.cellRegistry.preparePalette(in: NSAppearance.currentDrawing())
-        let palette = coordinator.cellRegistry.palette
-        let scope = coordinator.themeScope
-
-        for rowBand in DataGridBodyChrome.rowBands(in: dirtyRect, of: self, tableView: tableView) {
-            let stripRect = NSRect(x: 0, y: rowBand.rect.minY, width: bounds.width, height: rowBand.rect.height)
-            guard stripRect.intersects(dirtyRect) else { continue }
-
-            let isSelected = rowBand.isTableRow && tableView.selectedRowIndexes.contains(rowBand.row)
-            let state = rowBand.isTableRow ? coordinator.visualState(for: rowBand.row) : .empty
-            DataGridBodyChrome.fill(
-                stripRect,
-                with: rowLayers(
-                    row: rowBand.row,
-                    isSelected: isSelected,
-                    emphasized: emphasized,
-                    state: state,
-                    tableView: tableView,
-                    scope: scope
-                ),
-                over: tableView.backgroundColor
-            )
-            guard rowBand.isTableRow else { continue }
-            if rowNumberColumn >= 0 {
-                let cellFrame = tableView.frameOfCell(atColumn: rowNumberColumn, row: rowBand.row)
-                drawNumber(
-                    rowBand.row + pageOffset + 1,
-                    in: NSRect(x: cellFrame.minX, y: stripRect.minY, width: cellFrame.width, height: stripRect.height),
-                    font: font,
-                    color: palette.rowNumberColor(for: state, onEmphasizedSelection: isSelected && emphasized)
-                )
-            }
-            if band.isFreezing {
-                drawFrozenCells(ofRow: rowBand.row, in: stripRect.intersection(dirtyRect), band: band, tableView: tableView)
-            }
-        }
-
-        drawColumnSeparator(in: dirtyRect, tableView: tableView, coordinator: coordinator)
-        guard band.isFreezing else { return }
-        drawFrozenDivider(in: dirtyRect, band: band, tableView: tableView)
-        drawSelectionOutline(in: dirtyRect, band: band, tableView: tableView)
-    }
-
-    static let frozenDividerThickness: CGFloat = 2
-
-    private func frozenArea(of band: DataGridPinnedBand, in rect: NSRect) -> NSRect {
-        NSRect(x: band.gutterWidth, y: rect.minY, width: band.width - band.gutterWidth, height: rect.height)
-            .intersection(rect)
-    }
-
-    // The row's own drawing, translated to where the row sits in the band.
-    private func drawFrozenCells(ofRow row: Int, in rect: NSRect, band: DataGridPinnedBand, tableView: NSTableView) {
-        let area = frozenArea(of: band, in: rect)
-        guard !area.isEmpty,
-              let rowView = tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView,
-              let context = NSGraphicsContext.current?.cgContext else { return }
-        let rowTop = convert(tableView.rect(ofRow: row), from: tableView).minY
-        context.saveGState()
-        area.clip()
-        context.translateBy(x: 0, y: rowTop)
-        rowView.drawFrozenColumns(in: area.offsetBy(dx: 0, dy: -rowTop))
-        context.restoreGState()
-    }
-
-    private func drawFrozenDivider(in rect: NSRect, band: DataGridPinnedBand, tableView: NSTableView) {
-        let divider = NSRect(
-            x: band.width - Self.frozenDividerThickness,
-            y: rect.minY,
-            width: Self.frozenDividerThickness,
-            height: rect.height
-        )
-        guard divider.intersects(rect) else { return }
-        tableView.gridColor.setFill()
-        divider.fill()
-    }
-
-    // The overlay outlines in the table beneath, where the band covers the frozen part of it.
-    private func drawSelectionOutline(in rect: NSRect, band: DataGridPinnedBand, tableView: NSTableView) {
-        let area = frozenArea(of: band, in: rect)
-        guard !area.isEmpty,
-              let overlay = (tableView as? KeyHandlingTableView)?.selectionOverlay,
-              let context = NSGraphicsContext.current?.cgContext else { return }
-        let tableOriginY = convert(NSPoint.zero, from: tableView).y
-        context.saveGState()
-        area.clip()
-        context.translateBy(x: 0, y: tableOriginY)
-        overlay.drawSelection(in: area.offsetBy(dx: 0, dy: -tableOriginY))
-        context.restoreGState()
-    }
-
-    /// What the row under the strip paints, in its order, for `DataGridBodyChrome.fill` to blend over
-    /// the table's background: the row's stripe, then either its selection or the tint
-    /// `DataGridRowView` gives an unselected row. A band past the last row has the stripe alone.
-    private func rowLayers(
-        row: Int,
-        isSelected: Bool,
-        emphasized: Bool,
-        state: RowVisualState,
-        tableView: NSTableView,
-        scope: ThemeScope
-    ) -> [NSColor] {
-        var layers: [NSColor] = []
-        if let stripe = DataGridBodyChrome.stripeColor(forRow: row, of: tableView, scope: scope) {
-            layers.append(stripe)
-        }
-        if isSelected {
-            layers.append(DataGridBodyChrome.selectionColor(emphasized: emphasized, scope: scope))
-        } else if let tint = state.tint(in: scope) {
-            layers.append(tint)
-        }
-        return layers
-    }
-
-    /// Right-aligned inside the cell frame AppKit gives the mounted row-number cell, with the insets
-    /// that cell uses, so the two renderings land on the same pixels at scroll offset zero.
-    private func drawNumber(_ number: Int, in rect: NSRect, font: NSFont, color: NSColor) {
-        let attributes: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: color]
-        let text = "\(number)" as NSString
-        let size = text.size(withAttributes: attributes)
-        let inset = DataGridMetrics.cellHorizontalInset
-        let origin = NSPoint(
-            x: max(rect.minX + inset, rect.maxX - inset - size.width),
-            y: rect.midY - size.height / 2
-        )
-        text.draw(at: origin, withAttributes: attributes)
-    }
-
-    /// The first data column's leading separator where it stands at scroll offset zero, which is the
-    /// strip's own trailing edge.
-    ///
-    /// Drawn by `DataGridBodyChrome` over the grid's unscrolled leading strip rather than from a
-    /// width of this view's own, so at offset zero it is the very line the row beneath draws, on the
-    /// same pixel, and the opaque strip leaves exactly one of them showing.
-    private func drawColumnSeparator(
-        in rect: NSRect,
-        tableView: NSTableView,
-        coordinator: TableViewCoordinator
-    ) {
-        guard !rect.isEmpty, let context = NSGraphicsContext.current?.cgContext else { return }
-        let tableOriginY = convert(NSPoint.zero, from: tableView).y
-        let unscrolledStrip = NSRect(x: 0, y: rect.minY - tableOriginY, width: bounds.width, height: rect.height)
-        context.saveGState()
-        context.translateBy(x: 0, y: tableOriginY)
-        DataGridBodyChrome.drawColumnSeparators(
-            in: unscrolledStrip,
-            of: tableView,
-            tableView: tableView,
-            presentsColumn: { coordinator.presentsColumn(atTableColumnIndex: $0) }
-        )
-        context.restoreGState()
-    }
-
-    // MARK: - Selection
-
-    override func mouseDown(with event: NSEvent) {
-        guard let tableView, let coordinator else { return }
-        let row = row(at: event)
-        guard row >= 0 else { return }
-
-        tableView.window?.makeFirstResponder(tableView)
-
-        let modifiers = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-        selectRows(clickedRow: row, modifiers: modifiers)
-
-        guard event.clickCount == 1 else { return }
-        trackDrag(from: row, modifiers: modifiers, tableView: tableView, coordinator: coordinator, event: event)
-    }
-
-    /// The same reset the attached column's click performs, so the two routes leave the grid in one
-    /// state: a whole-row selection owns the grid. The selection change then seeds a cursor for the
-    /// keyboard, and the mark keeps a Shift+click or Cmd+click from selecting it as a cell.
-    func selectRows(clickedRow row: Int, modifiers: NSEvent.ModifierFlags) {
-        guard let tableView, let coordinator else { return }
-        coordinator.selectionController.clear()
-        tableView.focusedRow = -1
-        tableView.focusedColumn = -1
-        tableView.isCursorSeededByRowSelection = true
-        applySelection(row: row, modifiers: modifiers, tableView: tableView)
-    }
-
-    private func applySelection(row: Int, modifiers: NSEvent.ModifierFlags, tableView: NSTableView) {
-        if modifiers.contains(.command) {
-            var rows = tableView.selectedRowIndexes
-            if rows.contains(row) {
-                rows.remove(row)
-            } else {
-                rows.insert(row)
-            }
-            tableView.selectRowIndexes(rows, byExtendingSelection: false)
-            selectionAnchorRow = row
-            return
-        }
-        if modifiers.contains(.shift), let anchor = extendAnchor(in: tableView) {
-            tableView.selectRowIndexes(IndexSet(integersIn: min(anchor, row)...max(anchor, row)), byExtendingSelection: false)
-            selectionAnchorRow = anchor
-            return
-        }
-        tableView.selectRowIndexes(IndexSet(integer: row), byExtendingSelection: false)
-        selectionAnchorRow = row
-    }
-
-    /// Extends the selection while the button is held, and hands over to a reorder drag once the
-    /// pointer leaves the row it started on and the grid offers reordering.
-    ///
-    /// The strip runs its own tracking loop for the same reason `KeyHandlingTableView.trackDrag`
-    /// does: `NSTableView`'s own loop is unreachable from here, because this view is not the table.
-    private func trackDrag(
-        from origin: Int,
-        modifiers: NSEvent.ModifierFlags,
-        tableView: KeyHandlingTableView,
-        coordinator: TableViewCoordinator,
-        event: NSEvent
-    ) {
-        guard let window = tableView.window else { return }
-        let canReorder = coordinator.rowReorder.isEnabled && !modifiers.contains(.command)
-        let mask: NSEvent.EventTypeMask = [.leftMouseDragged, .leftMouseUp]
-
-        while let next = window.nextEvent(matching: mask) {
-            if next.type == .leftMouseUp { return }
-            let row = self.row(at: next)
-            guard row >= 0 else { continue }
-            if canReorder, row != origin {
-                beginReorderDrag(from: origin, tableView: tableView, event: next)
-                return
-            }
-            tableView.autoscroll(with: next)
-            guard row != origin || tableView.selectedRowIndexes.count != 1 else { continue }
-            tableView.selectRowIndexes(
-                IndexSet(integersIn: min(origin, row)...max(origin, row)),
-                byExtendingSelection: false
-            )
-        }
-    }
-
-    /// Starts the drag `NSTableView` would have started from the attached column.
-    ///
-    /// The session's source has to be the table view, not this strip: `validateDrop` refuses any
-    /// session whose `draggingSource` is not the table it is dropping into, so a strip-sourced drag
-    /// would lift the row, open the gap and move nothing.
-    private func beginReorderDrag(from row: Int, tableView: KeyHandlingTableView, event: NSEvent) {
-        guard let source = tableView.dataSource,
-              let writer = source.tableView?(tableView, pasteboardWriterForRow: row) else { return }
-        let item = NSDraggingItem(pasteboardWriter: writer)
-        let rowRect = convert(tableView.rect(ofRow: row), from: tableView)
-        item.setDraggingFrame(NSRect(x: 0, y: rowRect.minY, width: bounds.width, height: rowRect.height), contents: nil)
-        tableView.beginDraggingSession(with: [item], event: event, source: tableView)
-    }
-
-    // MARK: - Context menu
-
-    /// The row menu the attached column produces: the click resolves no data column, so the copy
-    /// item targets the whole row and the cell-only entries stay out.
-    override func menu(for event: NSEvent) -> NSMenu? {
-        guard let tableView, let coordinator else { return nil }
-        let row = row(at: event)
-        guard row >= 0, row < tableView.numberOfRows else { return nil }
-
-        if !tableView.selectedRowIndexes.contains(row) {
-            coordinator.selectionController.clear()
-            tableView.isCursorSeededByRowSelection = true
-            tableView.selectRowIndexes(IndexSet(integer: row), byExtendingSelection: false)
-            selectionAnchorRow = row
-        }
-        guard let rowView = tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView else {
-            return nil
-        }
-        return rowView.contextMenu(target: .row)
-    }
-
-    /// Where a Shift-extend measures from.
-    ///
-    /// The remembered anchor is only believed while it is still in range and still selected. A page
-    /// load, a new result or a selection made outside the strip all replace the table's selection
-    /// without telling this view, and an anchor that outlives one of those extends from a row in a
-    /// result that is gone, or past the end of the new one.
-    private func extendAnchor(in tableView: NSTableView) -> Int? {
-        if let anchor = selectionAnchorRow,
-           anchor >= 0, anchor < tableView.numberOfRows,
-           tableView.selectedRowIndexes.contains(anchor) {
-            return anchor
-        }
-        selectionAnchorRow = nil
-        return tableView.selectedRowIndexes.first
-    }
-
-    private func row(at event: NSEvent) -> Int {
-        row(atLocalPoint: convert(event.locationInWindow, from: nil))
-    }
-
-    private func row(atLocalPoint point: NSPoint) -> Int {
-        guard let tableView else { return -1 }
-        return tableView.row(at: convert(point, to: tableView))
-    }
-
-    // MARK: - Hit testing
-
-    /// Only the rows take a press. Past the last row the strip still paints the grid's stripes, but a
-    /// click there belongs to the grid: a double click adds a row and a single click clears the
-    /// selection, both of which the strip used to swallow.
-    override func hitTest(_ point: NSPoint) -> NSView? {
-        guard let hit = super.hitTest(point), let tableView else { return nil }
-        let local = convert(point, from: superview)
-        // A frozen cell's press goes on to the grid, which resolves it through `column(at:)`.
-        guard local.x < Self.width(of: tableView) else { return nil }
-        return row(atLocalPoint: local) >= 0 ? hit : nil
-    }
-
-    // MARK: - Accessibility
-
-    /// The strip is drawn chrome and has no place in the accessibility tree, so AppKit's own hit test
-    /// stopped at the nearest element above it, the scroll area, and a pointer over a row's number
-    /// found no row at all. Measured, AppKit does consult this override for the floating view. The
-    /// strip answers with what it shows: the row's mounted row-number cell view, which is the element
-    /// `NSTableView` publishes as that row's cell, while the column is in the viewport; the row once
-    /// it is not. `NSTableView` keeps that cell mounted at the column's own position however far the
-    /// grid scrolls, measured, so handing it over then would point a client at a frame hundreds of
-    /// points off screen. Below the last row, the grid.
-    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
-        guard let tableView, let window else { return super.accessibilityHitTest(point) }
-        let local = convert(window.convertPoint(fromScreen: point), from: nil)
-        let row = row(atLocalPoint: local)
-        let frozen = tableView.column(at: convert(local, to: tableView))
-        if row >= 0, local.x >= Self.width(of: tableView), coordinator?.freezingBand()?.pins(frozen) == true {
-            DataGridAccessibility.markActive()
-            return tableView.view(atColumn: frozen, row: row, makeIfNecessary: false)
-                ?? tableView.rowView(atRow: row, makeIfNecessary: false)
-                ?? tableView.accessibilityHitTest(point)
-        }
-        let column = tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        guard row >= 0, column >= 0 else { return tableView.accessibilityHitTest(point) }
-        if tableView.visibleRect.intersects(tableView.rect(ofColumn: column)),
-           let cell = tableView.view(atColumn: column, row: row, makeIfNecessary: false) {
-            return cell
-        }
-        if let rowView = tableView.rowView(atRow: row, makeIfNecessary: false) {
-            return rowView
-        }
-        return tableView.accessibilityHitTest(point)
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridRowView.swift b/apple/TablePro/Views/Results/DataGridRowView.swift
deleted file mode 100644
index 21d4d7d3c8..0000000000
--- a/apple/TablePro/Views/Results/DataGridRowView.swift
+++ /dev/null
@@ -1,1039 +0,0 @@
-//
-//  DataGridRowView.swift
-//  TablePro
-//
-
-import AppKit
-import Combine
-import TableProPluginKit
-import TableProTheme
-
-@MainActor
-class DataGridRowView: NSTableRowView {
-    enum CopyContextTarget {
-        case cell(Int)
-        case row
-        case unresolved
-    }
-
-    weak var coordinator: TableViewCoordinator?
-
-    /// The row this view is showing now, asked of the table rather than remembered.
-    ///
-    /// `insertRows(at:)` and `removeRows(at:)` move an already-built row view to its new slot
-    /// without calling `tableView(_:rowViewForRow:)` for it again, so an index captured at mount
-    /// goes stale the moment a row is inserted or removed above this one, and every read of it then
-    /// names a different row. Measured: after `removeRows(at: [1])` the view at display row 1 still
-    /// carried 2, the one at 2 carried 3, and an insert left two views both claiming 0, while
-    /// `row(for:)` answered correctly throughout at 26ns a call. AppKit keeps that mapping itself,
-    /// so it is asked for it. The seed answers only for a row view that is in no table, which is how
-    /// the copy tests build one.
-    var rowIndex: Int {
-        get {
-            guard let tableView = coordinator?.tableView else { return seededRowIndex }
-            let resolved = tableView.row(for: self)
-            return resolved >= 0 ? resolved : seededRowIndex
-        }
-        set { seededRowIndex = newValue }
-    }
-
-    private var seededRowIndex: Int = 0
-
-    var visualState: RowVisualState {
-        coordinator?.visualState(for: rowIndex) ?? .empty
-    }
-
-    /// A row outside a grid, as the copy tests build one, draws with the app's theme.
-    private var themeScope: ThemeScope {
-        coordinator?.themeScope ?? .live
-    }
-
-    /// Draws the row's data cells.
-    ///
-    /// A subview rather than the row view's own `draw(_:)`, so the cells land after AppKit has
-    /// painted the row background and the selection, which is the order a mounted cell view got.
-    private let contentView = DataGridRowContentView()
-
-    override init(frame frameRect: NSRect) {
-        super.init(frame: frameRect)
-        wantsLayer = true
-        layerContentsRedrawPolicy = .onSetNeedsDisplay
-        canDrawSubviewsIntoLayer = true
-        contentView.rowView = self
-        contentView.autoresizingMask = [.width, .height]
-        contentView.frame = bounds
-        addSubview(contentView)
-    }
-
-    /// Repaints one cell, the way a mounted cell view repainted itself.
-    func redrawCell(atTableColumnIndex tableColumnIndex: Int) {
-        guard let tableView = coordinator?.tableView else {
-            contentView.needsDisplay = true
-            return
-        }
-        let columnRect = tableView.rect(ofColumn: tableColumnIndex)
-        contentView.setNeedsDisplay(
-            NSRect(x: columnRect.minX, y: 0, width: columnRect.width, height: contentView.bounds.height)
-        )
-    }
-
-    func redrawCells() {
-        cellsNeedDisplay = true
-    }
-
-    /// Whether the drawn cells are waiting on a repaint. The row's own `needsDisplay` answers for
-    /// the background and the selection fill, which are painted separately from the cells.
-    var cellsNeedDisplay: Bool {
-        get { contentView.needsDisplay }
-        set { contentView.needsDisplay = newValue }
-    }
-
-    // MARK: - Accessibility
-
-    override func accessibilityRole() -> NSAccessibility.Role? { .row }
-
-    /// The row answers for every point it covers that no cell does: the row-number column, and the
-    /// width past the last column on a result narrower than the grid.
-    ///
-    /// AppKit's own hit test descends into subviews, and `contentView` covers the whole row, so a
-    /// point outside every cell used to resolve to a view that is not in the accessibility tree. A
-    /// client reads an element outside the row's subtree as the row not being reachable there, which
-    /// is what a mounted cell view left behind when it covered only its own column.
-    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
-        DataGridAccessibility.markActive()
-        guard let window else { return super.accessibilityHitTest(point) }
-        let local = convert(window.convertPoint(fromScreen: point), from: nil)
-        for subview in subviews where subview !== contentView && subview.frame.contains(local) {
-            if let hit = subview.accessibilityHitTest(point) { return hit }
-        }
-        return bounds.contains(local) ? self : nil
-    }
-
-    /// The click a cell view used to take for itself: the in-cell accessory, then a double click.
-    ///
-    /// - Returns: whether the click was consumed, leaving the table view's own selection handling
-    ///   to everything else.
-    func handleCellClick(at point: NSPoint, in view: NSView, clickCount: Int, modifiers: NSEvent.ModifierFlags) -> Bool {
-        guard let coordinator, let tableView = coordinator.tableView else { return false }
-        let inTableView = view.convert(point, to: tableView)
-        let tableColumnIndex = tableView.column(at: inTableView)
-        guard tableColumnIndex >= 0, tableColumnIndex < tableView.tableColumns.count,
-              let dataColumn = coordinator.dataColumnIndex(from: tableView.tableColumns[tableColumnIndex].identifier)
-        else { return false }
-
-        let columnRect = view.convert(coordinator.displayedRect(ofColumn: tableColumnIndex), from: tableView)
-        let cellRect = NSRect(x: columnRect.minX, y: 0, width: columnRect.width, height: view.bounds.height)
-        if coordinator.presentsCheckboxCell(columnIndex: dataColumn) {
-            guard DataGridCheckboxMark.frame(in: cellRect).contains(point) else { return false }
-            return coordinator.toggleCheckbox(row: rowIndex, columnIndex: dataColumn)
-        }
-        guard let appearance = coordinator.cellAppearance(
-            row: rowIndex,
-            columnIndex: dataColumn,
-            onEmphasizedSelection: isSelected && isEmphasized
-        ) else { return false }
-
-        let accessoryRect = appearance.accessory.frame(in: cellRect)
-        guard !accessoryRect.isEmpty, accessoryRect.contains(point) else {
-            guard clickCount == 2 else { return false }
-            coordinator.dataGridCellDidDoubleClick(row: rowIndex, columnIndex: dataColumn)
-            return true
-        }
-
-        switch appearance.accessory {
-        case .foreignKey:
-            coordinator.dataGridCellDidClickFKArrow(
-                row: rowIndex,
-                columnIndex: dataColumn,
-                intent: modifiers.contains(.command) ? .newTab : .follow
-            )
-            return true
-        case .chevron where !visualState.isDeleted:
-            coordinator.dataGridCellDidClickChevron(row: rowIndex, columnIndex: dataColumn)
-            return true
-        case .none, .chevron:
-            return false
-        }
-    }
-
-    /// Draws every data cell the dirty area touches.
-    ///
-    /// The columns are still real `NSTableColumn`s, so AppKit answers which of them the area covers
-    /// and where each one sits; only the cell content is drawn rather than mounted.
-    func drawCells(in dirtyRect: NSRect, of view: NSView, includesFrozenColumns: Bool = false) {
-        guard let coordinator, let tableView = coordinator.tableView else { return }
-        coordinator.cellRegistry.preparePalette(in: NSAppearance.currentDrawing())
-        let inTableView = view.convert(dirtyRect, to: tableView)
-        let dragged = Self.draggedColumnIndex(of: tableView)
-        let themedRange = themedRangeColumns()
-        // The pinned band draws these, as the row-number cell leaves its number to the gutter.
-        let frozen = includesFrozenColumns ? IndexSet() : coordinator.freezingBand()?.frozenColumns ?? IndexSet()
-
-        for tableColumnIndex in tableView.columnIndexes(in: inTableView)
-        where tableColumnIndex != dragged && !frozen.contains(tableColumnIndex) {
-            drawCell(
-                atTableColumnIndex: tableColumnIndex,
-                in: tableView.rect(ofColumn: tableColumnIndex),
-                of: view,
-                onThemedRange: themedRange.contains(tableColumnIndex)
-            )
-        }
-    }
-
-    // Called by the pinned band inside a context translated to this row's origin.
-    func drawFrozenColumns(in rect: NSRect) {
-        drawCellSelectionFill(in: rect, scope: themeScope)
-        drawCells(in: rect, of: contentView, includesFrozenColumns: true)
-        drawDraggedColumn(in: rect, of: contentView)
-    }
-
-    fileprivate func forwardInvalidationToPinnedBand(_ rect: NSRect) {
-        guard let coordinator, coordinator.frozenColumnCount > 0, let tableView = coordinator.tableView else { return }
-        coordinator.pinnedBandNeedsDisplay(rowRect: rect, row: tableView.row(for: self))
-    }
-
-    override func setNeedsDisplay(_ invalidRect: NSRect) {
-        super.setNeedsDisplay(invalidRect)
-        forwardInvalidationToPinnedBand(invalidRect)
-    }
-
-    /// The columns of an unselected row that a cell range covers with a theme's opaque selection,
-    /// whose text has to switch to the theme's selection text like a selected row's does.
-    func themedRangeColumns() -> Set<Int> {
-        guard !isSelected, isEmphasized, let coordinator,
-              DataGridBodyChrome.isSelectionThemed(emphasized: true, scope: coordinator.themeScope) else { return [] }
-        let columns = coordinator.selectionController.selection.columns(in: rowIndex)
-        return Set(columns.compactMap { coordinator.tableColumnIndex(forDisplayPosition: $0) })
-    }
-
-    /// Draws the column a header drag is moving at the pointer, the way `NSTableView` floats a dragged
-    /// column's cell views: over its neighbours and the separators, its own slot left empty.
-    ///
-    /// The position is read at draw time. `draggedDistance` is measured from the column's current
-    /// slot, which moves as it passes each neighbour, and the two disagree for a moment inside that
-    /// move, measured on macOS 27.
-    func drawDraggedColumn(in dirtyRect: NSRect, of view: NSView) {
-        guard let tableView = coordinator?.tableView,
-              let dragged = Self.draggedColumnIndex(of: tableView),
-              let distance = tableView.headerView?.draggedDistance,
-              let context = NSGraphicsContext.current?.cgContext else { return }
-        let floating = tableView.rect(ofColumn: dragged).offsetBy(dx: distance, dy: 0)
-        guard floating.intersects(view.convert(dirtyRect, to: tableView)) else { return }
-        context.saveGState()
-        context.setAlpha(Self.draggedColumnAlpha)
-        context.beginTransparencyLayer(auxiliaryInfo: nil)
-        drawCell(atTableColumnIndex: dragged, in: floating, of: view)
-        context.endTransparencyLayer()
-        context.restoreGState()
-    }
-
-    /// The `alphaValue` AppKit gives the view it floats a dragged column's cells in, measured on
-    /// macOS 27; AppKit does not publish it.
-    private static let draggedColumnAlpha: CGFloat = 0.6
-
-    private static func draggedColumnIndex(of tableView: NSTableView) -> Int? {
-        guard let dragged = tableView.headerView?.draggedColumn,
-              dragged >= 0, dragged < tableView.numberOfColumns else { return nil }
-        return dragged
-    }
-
-    private func drawCell(
-        atTableColumnIndex tableColumnIndex: Int,
-        in rectInTable: NSRect,
-        of view: NSView,
-        onThemedRange: Bool = false
-    ) {
-        guard let coordinator, let tableView = coordinator.tableView,
-              tableColumnIndex < tableView.tableColumns.count,
-              let dataColumn = coordinator.dataColumnIndex(from: tableView.tableColumns[tableColumnIndex].identifier),
-              let appearance = coordinator.cellAppearance(
-                  row: rowIndex,
-                  columnIndex: dataColumn,
-                  onEmphasizedSelection: (isSelected && isEmphasized) || onThemedRange
-              ) else { return }
-
-        let columnRect = view.convert(rectInTable, from: tableView)
-        coordinator.cellRenderer.draw(
-            appearance,
-            in: NSRect(x: columnRect.minX, y: 0, width: columnRect.width, height: view.bounds.height),
-            controlView: view
-        )
-    }
-
-    /// Draws the column separators crossing this row. See `DataGridBodyChrome`.
-    func drawColumnSeparators(in dirtyRect: NSRect, of view: NSView) {
-        guard let coordinator, let tableView = coordinator.tableView else { return }
-        DataGridBodyChrome.drawColumnSeparators(
-            in: dirtyRect,
-            of: view,
-            tableView: tableView,
-            presentsColumn: { coordinator.presentsColumn(atTableColumnIndex: $0) }
-        )
-    }
-
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-
-    override func makeBackingLayer() -> CALayer {
-        let layer = super.makeBackingLayer()
-        layer.actions = Self.disabledLayerActions
-        return layer
-    }
-
-    private static let disabledLayerActions: [String: any CAAction] = [
-        "position": NSNull(),
-        "bounds": NSNull(),
-        "frame": NSNull(),
-        "contents": NSNull(),
-        "hidden": NSNull(),
-    ]
-
-    func invalidateVisualState() {
-        needsDisplay = true
-    }
-
-    override var isSelected: Bool {
-        didSet {
-            guard isSelected != oldValue else { return }
-            propagateEmphasisToCells()
-            needsDisplay = true
-        }
-    }
-
-    override var isEmphasized: Bool {
-        didSet {
-            guard isEmphasized != oldValue else { return }
-            propagateEmphasisToCells()
-            needsDisplay = true
-        }
-    }
-
-    /// Selection recolours every cell's text, so the row repaints its own cells rather than telling
-    /// a set of cell views to repaint themselves.
-    private func propagateEmphasisToCells() {
-        redrawCells()
-    }
-
-    override func drawBackground(in dirtyRect: NSRect) {
-        let scope = themeScope
-        drawRowBackground(in: dirtyRect, scope: scope)
-        if !isSelected, let tint = visualState.tint(in: scope) {
-            tint.setFill()
-            bounds.fill()
-        }
-        drawCellSelectionFill(in: dirtyRect, scope: scope)
-    }
-
-    /// The row's stripe from `DataGridBodyChrome`, the owner the pinned gutter and the area past the
-    /// last row read too, rather than the `backgroundColor` the table assigns, which is only ever the
-    /// system's. A row outside a table has no stripe, and AppKit's own drawing already leaves it clear:
-    /// its `backgroundColor` is nil there, so it must not be read.
-    private func drawRowBackground(in dirtyRect: NSRect, scope: ThemeScope) {
-        guard let tableView = coordinator?.tableView else {
-            super.drawBackground(in: dirtyRect)
-            return
-        }
-        DataGridBodyChrome.rowBackgroundColor(forRow: rowIndex, of: tableView, scope: scope).setFill()
-        dirtyRect.fill()
-    }
-
-    override func drawSelection(in dirtyRect: NSRect) {
-        guard isSelected else { return }
-        guard let themed = DataGridBodyChrome.themedSelectionColor(emphasized: isEmphasized, scope: themeScope) else {
-            super.drawSelection(in: dirtyRect)
-            return
-        }
-        themed.setFill()
-        dirtyRect.fill()
-    }
-
-    /// A cell range on a row the table has selected is already covered by the row's own selection
-    /// fill, which runs after this, so only the remaining rows are painted here.
-    private func drawCellSelectionFill(in dirtyRect: NSRect, scope: ThemeScope) {
-        guard !isSelected,
-              let coordinator,
-              let tableView = coordinator.tableView else { return }
-        let selection = coordinator.selectionController.selection
-        guard !selection.isEmpty else { return }
-        let columns = selection.columns(in: rowIndex)
-        guard !columns.isEmpty else { return }
-
-        cellSelectionFill(scope: scope).setFill()
-
-        for position in columns {
-            guard let tableColumnIndex = coordinator.tableColumnIndex(forDisplayPosition: position) else { continue }
-            let columnRect = tableView.rect(ofColumn: tableColumnIndex)
-            let localRect = NSRect(x: columnRect.minX, y: 0, width: columnRect.width, height: bounds.height)
-            guard localRect.intersects(dirtyRect) else { continue }
-            localRect.fill()
-        }
-    }
-
-    /// `unemphasizedSelectedContentBackgroundColor` is a background colour and is used as one, the
-    /// way AppKit fills a selection in a view that does not hold focus. Thinning it out instead
-    /// left the range at 1.09:1 against a white grid, which is no visible selection at all. The
-    /// system's emphasized accent is far too dark to sit behind text these rows do not recolour, so
-    /// that one goes on as a tint; a theme's selection is chosen to sit behind its own text.
-    private func cellSelectionFill(scope: ThemeScope) -> NSColor {
-        if let themed = DataGridBodyChrome.themedSelectionColor(emphasized: isEmphasized, scope: scope) {
-            return themed
-        }
-        let native = scope.resolved[DataGridBodyChrome.selectionSlot(emphasized: isEmphasized)]
-        guard isEmphasized else { return native }
-        return native.withAlphaComponent(Self.emphasizedCellSelectionAlpha)
-    }
-
-    private static let emphasizedCellSelectionAlpha: CGFloat = 0.28
-
-    private func addForeignKeyMenuItems(to menu: NSMenu, dataColumnIndex: Int, tableRows: TableRows) {
-        guard let coordinator, dataColumnIndex >= 0, dataColumnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[dataColumnIndex]
-        guard let fkInfo = tableRows.columnForeignKeys[columnName] else { return }
-
-        /// Choosing a value is offered on an empty cell too, which is where it is needed most,
-        /// while previewing and following a key still need one to resolve.
-        let hasValue = coordinator.cellValue(at: rowIndex, column: dataColumnIndex)?.isEmpty == false
-        let canChoose = coordinator.canStartInlineEdit(row: rowIndex, columnIndex: dataColumnIndex)
-            && !ForeignKeyConstraintSpan.isMultiColumn(fkInfo, among: tableRows.columnForeignKeys)
-        guard hasValue || canChoose else { return }
-
-        menu.addItem(NSMenuItem.separator())
-
-        if canChoose {
-            let chooseItem = NSMenuItem(
-                title: String(format: String(localized: "Choose %@ Row…"), fkInfo.referencedTable),
-                action: #selector(chooseForeignKeyValue(_:)),
-                keyEquivalent: ""
-            )
-            chooseItem.representedObject = dataColumnIndex
-            chooseItem.target = self
-            menu.addItem(chooseItem)
-        }
-
-        guard hasValue else { return }
-
-        let previewItem = NSMenuItem(
-            title: String(localized: "Preview Referenced Row"),
-            action: #selector(previewForeignKey(_:)),
-            keyEquivalent: ""
-        )
-        previewItem.representedObject = dataColumnIndex
-        previewItem.target = self
-        menu.addItem(previewItem)
-
-        let navItem = NSMenuItem(
-            title: String(format: String(localized: "Open %@"), fkInfo.referencedTable),
-            action: #selector(navigateToForeignKey(_:)),
-            keyEquivalent: ""
-        )
-        navItem.representedObject = dataColumnIndex
-        navItem.target = self
-        menu.addItem(navItem)
-
-        let navInNewTabItem = NSMenuItem(
-            title: String(format: String(localized: "Open %@ in New Tab"), fkInfo.referencedTable),
-            action: #selector(navigateToForeignKeyInNewTab(_:)),
-            keyEquivalent: ""
-        )
-        navInNewTabItem.representedObject = dataColumnIndex
-        navInNewTabItem.target = self
-        menu.addItem(navInNewTabItem)
-    }
-
-    /// What a right-click landed on, as much as the row menu needs to know. A click that hit no
-    /// column at all is not the same as one that hit a column carrying no data, such as the row
-    /// number, so the two misses stay apart.
-    enum MenuTarget: Equatable {
-        case cell(dataColumn: Int)
-        case row
-        case unresolved
-
-        var dataColumn: Int {
-            guard case .cell(let index) = self else { return -1 }
-            return index
-        }
-    }
-
-    /// Where a right-click landed, resolved through the table view the row belongs to.
-    private func menuTarget(for event: NSEvent) -> MenuTarget {
-        guard let coordinator, let tableView = coordinator.tableView else { return .unresolved }
-        let locationInRow = convert(event.locationInWindow, from: nil)
-        let locationInTable = tableView.convert(locationInRow, from: self)
-        let clickedColumn = tableView.column(at: locationInTable)
-        guard clickedColumn >= 0 else { return .unresolved }
-        guard let dataColumn = DataGridView.dataColumnIndex(
-            for: clickedColumn, in: tableView, schema: coordinator.identitySchema
-        ) else { return .row }
-        return .cell(dataColumn: dataColumn)
-    }
-
-    /// Copy, meaning the cell under the pointer. Shared so a grid that builds its own row menu
-    /// offers the same item rather than leaving the pointer with no route to a value the keyboard
-    /// can already copy: the Structure tab had `Cmd+C` copying the clicked cell and no menu item
-    /// for it at all.
-    func makeCopyItem(target: MenuTarget) -> NSMenuItem {
-        let copyTarget: CopyContextTarget = switch target {
-        case .cell(let dataColumn): .cell(dataColumn)
-        case .row: .row
-        case .unresolved: .unresolved
-        }
-        let item = NSMenuItem(
-            title: String(localized: "Copy"), action: #selector(copyFromContextMenu(_:)), keyEquivalent: ""
-        )
-        item.representedObject = copyTarget
-        item.target = self
-        return item
-    }
-
-    // Copy over a cell range copies the range, so the clicked cell needs a command of its own.
-    private func makeCopyCellValueItem(dataColumn: Int) -> NSMenuItem {
-        let item = NSMenuItem(
-            title: String(localized: "Copy Cell Value"), action: #selector(copyClickedCellValue(_:)), keyEquivalent: ""
-        )
-        item.representedObject = dataColumn
-        item.target = self
-        return item
-    }
-
-    /// Deliberately not `menu(for:)`. The table view owns context-menu handling because it
-    /// is the only level that can re-target the selection to the clicked row first; a row
-    /// view answering `menuForEvent:` would swallow the event and act on the old selection.
-    func contextMenu(for event: NSEvent) -> NSMenu? {
-        contextMenu(target: menuTarget(for: event))
-    }
-
-    /// The row menu for a click whose target is already known.
-    ///
-    /// The pinned row gutter needs this: it overlays whatever data column is scrolled under the
-    /// leading edge, so resolving its click through the table view would report a cell and give the
-    /// gutter the cell menu, with Set Value and IN Clause on a column the pointer never touched.
-    func contextMenu(target: MenuTarget) -> NSMenu? {
-        guard let coordinator = coordinator,
-              let tableView = coordinator.tableView else { return nil }
-
-        let dataColumnIndex = target.dataColumn
-
-        let menu = NSMenu()
-
-        if coordinator.isRowDeleted(displayRow: rowIndex) {
-            menu.addItem(
-                withTitle: String(localized: "Undo Delete"), action: #selector(undoDeleteRow), keyEquivalent: ""
-            ).target = self
-            return menu
-        }
-
-        menu.addItem(makeCopyItem(target: target))
-        if case .cell(let clickedColumn) = target {
-            menu.addItem(makeCopyCellValueItem(dataColumn: clickedColumn))
-        }
-
-        let copyAsMenu = NSMenu()
-
-        let copyRowsItem = NSMenuItem(
-            title: String(localized: "Rows"),
-            action: #selector(copySelectedOrCurrentRow),
-            keyEquivalent: ""
-        )
-        copyRowsItem.target = self
-        copyAsMenu.addItem(copyRowsItem)
-
-        let copyWithHeadersItem = NSMenuItem(
-            title: String(localized: "With Headers"),
-            action: #selector(copySelectedOrCurrentRowWithHeaders),
-            keyEquivalent: "")
-        copyWithHeadersItem.target = self
-        copyAsMenu.addItem(copyWithHeadersItem)
-
-        let jsonItem = NSMenuItem(
-            title: String(localized: "JSON"),
-            action: #selector(copyAsJson),
-            keyEquivalent: "")
-        jsonItem.target = self
-        copyAsMenu.addItem(jsonItem)
-
-        let csvItem = NSMenuItem(
-            title: String(localized: "CSV"),
-            action: #selector(copyAsCsv),
-            keyEquivalent: "")
-        csvItem.target = self
-        copyAsMenu.addItem(csvItem)
-
-        let csvHeadersItem = NSMenuItem(
-            title: String(localized: "CSV with Headers"),
-            action: #selector(copyAsCsvWithHeaders),
-            keyEquivalent: "")
-        csvHeadersItem.target = self
-        copyAsMenu.addItem(csvHeadersItem)
-
-        let markdownItem = NSMenuItem(
-            title: String(localized: "Markdown"),
-            action: #selector(copyAsMarkdown),
-            keyEquivalent: "")
-        markdownItem.target = self
-        copyAsMenu.addItem(markdownItem)
-
-        if dataColumnIndex >= 0 {
-            let inClauseItem = NSMenuItem(
-                title: String(localized: "IN Clause"),
-                action: #selector(copyAsInClause(_:)),
-                keyEquivalent: "")
-            inClauseItem.representedObject = dataColumnIndex
-            inClauseItem.target = self
-            copyAsMenu.addItem(inClauseItem)
-        }
-
-        if coordinator.canCopyRowsAsInsert {
-            copyAsMenu.addItem(NSMenuItem.separator())
-
-            let insertItem = NSMenuItem(
-                title: String(localized: "INSERT Statement(s)"),
-                action: #selector(copyAsInsert),
-                keyEquivalent: "")
-            insertItem.target = self
-            copyAsMenu.addItem(insertItem)
-
-            if coordinator.canCopyRowsAsUpdate {
-                let updateItem = NSMenuItem(
-                    title: String(localized: "UPDATE Statement(s)"),
-                    action: #selector(copyAsUpdate),
-                    keyEquivalent: "")
-                updateItem.target = self
-                copyAsMenu.addItem(updateItem)
-            }
-        }
-
-        let copyAsItem = NSMenuItem(title: String(localized: "Copy as"), action: nil, keyEquivalent: "")
-        copyAsItem.submenu = copyAsMenu
-        menu.addItem(copyAsItem)
-        addSelectionSummaryCopyItems(to: menu, coordinator: coordinator)
-
-        if coordinator.isEditable {
-            let pasteItem = NSMenuItem(
-                title: String(localized: "Paste"), action: #selector(pasteRows), keyEquivalent: "")
-            pasteItem.target = self
-            menu.addItem(pasteItem)
-        }
-
-        menu.addItem(NSMenuItem.separator())
-
-        if coordinator.supportsColumnCommands {
-            let jsonViewItem = NSMenuItem(
-                title: String(localized: "Show Row as JSON"),
-                action: #selector(showRowAsJSON),
-                keyEquivalent: ""
-            )
-            jsonViewItem.target = self
-            menu.addItem(jsonViewItem)
-        }
-
-        addCellValueMenuItems(to: menu, dataColumnIndex: dataColumnIndex, delegate: coordinator.delegate)
-
-        let tableRows = coordinator.tableRowsProvider()
-        addForeignKeyMenuItems(to: menu, dataColumnIndex: dataColumnIndex, tableRows: tableRows)
-
-        if coordinator.isEditable {
-            menu.addItem(NSMenuItem.separator())
-        }
-
-        addValueEditingItems(to: menu, dataColumnIndex: dataColumnIndex, tableRows: tableRows, coordinator: coordinator)
-
-        menu.addItem(NSMenuItem.separator())
-
-        if coordinator.supportsColumnCommands {
-            let exportItem = NSMenuItem(
-                title: String(localized: "Export Results…"),
-                action: #selector(exportResults),
-                keyEquivalent: ""
-            )
-            exportItem.target = self
-            menu.addItem(exportItem)
-        }
-
-        if coordinator.delegate?.dataGridCanClearResults() == true {
-            let clearResultsItem = NSMenuItem(
-                title: String(localized: "Clear Results"),
-                action: #selector(clearResults),
-                keyEquivalent: ""
-            )
-            clearResultsItem.target = self
-            menu.addItem(clearResultsItem)
-        }
-
-        if coordinator.isEditable {
-            let rowStructureItems = coordinator.delegate?.dataGridRowStructureMenuItems(forRow: rowIndex) ?? []
-            if !rowStructureItems.isEmpty {
-                menu.addItem(NSMenuItem.separator())
-                for item in rowStructureItems {
-                    menu.addItem(item)
-                }
-            }
-
-            let documentItems = coordinator.delegate?.dataGridDocumentMenuItems(forRow: rowIndex) ?? []
-            if !documentItems.isEmpty {
-                menu.addItem(NSMenuItem.separator())
-                for item in documentItems {
-                    menu.addItem(item)
-                }
-            }
-
-            /// The copy resets the columns the server owns, which only the schema names, so the item
-            /// stays away until it has arrived rather than appearing and doing nothing.
-            if tableRows.hasAuthoritativeSchema {
-                let duplicateItem = NSMenuItem(
-                    title: String(localized: "Duplicate"), action: #selector(duplicateRow), keyEquivalent: "")
-                duplicateItem.target = self
-                menu.addItem(duplicateItem)
-            }
-
-            let deleteItem = NSMenuItem(
-                title: String(localized: "Delete"),
-                action: #selector(deleteRow),
-                keyEquivalent: ""
-            )
-            deleteItem.target = self
-            menu.addItem(deleteItem)
-        }
-
-        return menu
-    }
-
-    private func addCellValueMenuItems(
-        to menu: NSMenu,
-        dataColumnIndex: Int,
-        delegate: (any DataGridViewDelegate)?
-    ) {
-        guard dataColumnIndex >= 0, let delegate else { return }
-        if let filterItem = delegate.dataGridFilterMenuItem(forRow: rowIndex, dataColumn: dataColumnIndex) {
-            menu.addItem(filterItem)
-        }
-        if let highlightItem = delegate.dataGridHighlightMenuItem(forRow: rowIndex, dataColumn: dataColumnIndex) {
-            menu.addItem(highlightItem)
-        }
-    }
-
-    /// Set Value, and Remove Field on an engine that tells a missing field from NULL while the cell
-    /// still has a field to remove.
-    private func addValueEditingItems(
-        to menu: NSMenu,
-        dataColumnIndex: Int,
-        tableRows: TableRows,
-        coordinator: TableViewCoordinator
-    ) {
-        guard coordinator.isEditable, dataColumnIndex >= 0 else { return }
-
-        let clicked = SetValueTarget(displayRow: rowIndex, columnIndex: dataColumnIndex)
-        let targets = coordinator.setValueTargets(clicked: clicked)
-        let setValueMenu = buildSetValueMenu(
-            commands: coordinator.setValueCommands(for: targets),
-            clickedColumn: dataColumnIndex
-        )
-        if coordinator.isSetCellsToValueOffered(for: targets) {
-            if !setValueMenu.items.isEmpty {
-                setValueMenu.addItem(.separator())
-            }
-            let item = NSMenuItem(
-                title: String(localized: "Set Cells to Value…"),
-                action: #selector(setCellsToValueFromContextMenu(_:)),
-                keyEquivalent: ""
-            )
-            item.representedObject = dataColumnIndex
-            item.target = self
-            setValueMenu.addItem(item)
-        }
-        if !setValueMenu.items.isEmpty {
-            let setValueItem = NSMenuItem(title: String(localized: "Set Value"), action: nil, keyEquivalent: "")
-            setValueItem.submenu = setValueMenu
-            menu.addItem(setValueItem)
-        }
-
-        guard dataColumnIndex < tableRows.columns.count,
-              coordinator.isColumnWritable(tableRows.columns[dataColumnIndex]),
-              coordinator.supportsFieldRemoval,
-              coordinator.displayRow(at: rowIndex)?.isAbsent(dataColumnIndex) == false else { return }
-        let removeFieldItem = NSMenuItem(
-            title: String(localized: "Remove Field"), action: #selector(removeFieldValue(_:)), keyEquivalent: "")
-        removeFieldItem.representedObject = dataColumnIndex
-        removeFieldItem.target = self
-        menu.addItem(removeFieldItem)
-    }
-
-    /// Placeholders, then the engine's functions, then UUIDs, a separator between the groups.
-    func buildSetValueMenu(commands: [SetValueCommand], clickedColumn: Int) -> NSMenu {
-        let setValueMenu = NSMenu()
-        var lastGroup: Int?
-        for command in commands {
-            let group = Self.setValueMenuGroup(command)
-            if let lastGroup, lastGroup != group {
-                setValueMenu.addItem(.separator())
-            }
-            lastGroup = group
-            let item = NSMenuItem(
-                title: SetValueOptions.title(for: command), action: #selector(applySetValue(_:)), keyEquivalent: ""
-            )
-            item.representedObject = SetValueMenuChoice(command: command, clickedColumn: clickedColumn)
-            item.target = self
-            setValueMenu.addItem(item)
-        }
-        return setValueMenu
-    }
-
-    private static func setValueMenuGroup(_ command: SetValueCommand) -> Int {
-        switch command {
-        case .empty, .null, .defaultValue: 0
-        case .expression: 1
-        case .uuid: 2
-        }
-    }
-
-    /// The targets are taken when the item is chosen, from the same selection the menu was built over.
-    @objc private func applySetValue(_ sender: NSMenuItem) {
-        guard let coordinator, let choice = sender.representedObject as? SetValueMenuChoice else { return }
-        let clicked = SetValueTarget(displayRow: rowIndex, columnIndex: choice.clickedColumn)
-        coordinator.applySetValue(choice.command, to: coordinator.setValueTargets(clicked: clicked))
-    }
-
-    @objc private func setCellsToValueFromContextMenu(_ sender: NSMenuItem) {
-        guard let coordinator, let column = sender.representedObject as? Int else { return }
-        coordinator.setCellsToValue(
-            coordinator.setValueTargets(clicked: SetValueTarget(displayRow: rowIndex, columnIndex: column))
-        )
-    }
-
-    @objc private func deleteRow() {
-        guard let coordinator else { return }
-        coordinator.delegate?.dataGridDeleteRows(coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func duplicateRow() {
-        coordinator?.delegate?.dataGridDuplicateRow()
-    }
-
-    @objc private func undoDeleteRow() {
-        coordinator?.undoDeleteRow(at: rowIndex)
-    }
-
-    @objc private func copySelectedOrCurrentRowWithHeaders() {
-        guard let coordinator else { return }
-        coordinator.copyRowsWithHeaders(at: coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func copySelectedOrCurrentRow() {
-        guard let coordinator else { return }
-        coordinator.delegate?.dataGridCopyRows(coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func copyFromContextMenu(_ sender: NSMenuItem) {
-        guard let coordinator else { return }
-        if !coordinator.selectionController.isEmpty {
-            coordinator.copyGridSelection(coordinator.selectionController.selection)
-            return
-        }
-        switch sender.representedObject as? CopyContextTarget {
-        case .cell(let columnIndex):
-            coordinator.copyCellValue(at: rowIndex, columnIndex: columnIndex)
-        case .unresolved:
-            if let columnIndex = focusedDataColumnIndex(in: coordinator) {
-                coordinator.copyCellValue(at: rowIndex, columnIndex: columnIndex)
-            } else {
-                copySelectedOrCurrentRowInCopyFormat()
-            }
-        case .row, .none:
-            copySelectedOrCurrentRowInCopyFormat()
-        }
-    }
-
-    private func copySelectedOrCurrentRowInCopyFormat() {
-        guard let coordinator else { return }
-        coordinator.copyRowsInCopyFormat(at: coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func copyClickedCellValue(_ sender: NSMenuItem) {
-        guard let coordinator, let columnIndex = sender.representedObject as? Int else { return }
-        coordinator.copyCellValue(at: rowIndex, columnIndex: columnIndex)
-    }
-
-    @objc private func pasteRows() {
-        coordinator?.delegate?.dataGridPasteRows()
-    }
-
-    private func addSelectionSummaryCopyItems(to menu: NSMenu, coordinator: TableViewCoordinator) {
-        guard let numbers = coordinator.selectionSummaryTracker.currentSummary?.numbers else { return }
-        for figure in [SelectionSummaryFigures.Figure.sum, .average] {
-            guard let text = SelectionSummaryFigures.copyText(figure, of: numbers) else { continue }
-            let item = NSMenuItem(
-                title: figure.copyTitle,
-                action: #selector(copySelectionSummaryFigure(_:)),
-                keyEquivalent: ""
-            )
-            item.representedObject = text
-            item.target = self
-            menu.addItem(item)
-        }
-    }
-
-    @objc private func copySelectionSummaryFigure(_ sender: NSMenuItem) {
-        guard let text = sender.representedObject as? String else { return }
-        ClipboardService.shared.writeText(text)
-    }
-
-    private func focusedDataColumnIndex(in coordinator: TableViewCoordinator) -> Int? {
-        guard let tableView = coordinator.tableView as? KeyHandlingTableView,
-              !tableView.isCursorSeededByRowSelection,
-              tableView.focusedRow == rowIndex,
-              tableView.presentsDataColumn(at: tableView.focusedColumn) else { return nil }
-        return DataGridView.dataColumnIndex(
-            for: tableView.focusedColumn,
-            in: tableView,
-            schema: coordinator.identitySchema
-        )
-    }
-
-    @objc private func removeFieldValue(_ sender: NSMenuItem) {
-        guard let columnIndex = sender.representedObject as? Int else { return }
-        coordinator?.removeField(row: rowIndex, columnIndex: columnIndex)
-    }
-
-    @objc private func copyAsInsert() {
-        guard let coordinator else { return }
-        coordinator.copyRowsAsInsert(at: coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func copyAsUpdate() {
-        guard let coordinator else { return }
-        coordinator.copyRowsAsUpdate(at: coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func exportResults() {
-        AppCommands.shared.exportQueryResults.send(())
-    }
-
-    @objc private func clearResults() {
-        coordinator?.delegate?.dataGridClearResults()
-    }
-
-    @objc private func copyAsJson() {
-        guard let coordinator else { return }
-        coordinator.copyRowsAsJson(at: coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func copyAsCsv() {
-        guard let coordinator else { return }
-        coordinator.copyRowsAsCsv(at: coordinator.currentRowSelection(fallbackRow: rowIndex), includeHeaders: false)
-    }
-
-    @objc private func copyAsCsvWithHeaders() {
-        guard let coordinator else { return }
-        coordinator.copyRowsAsCsv(at: coordinator.currentRowSelection(fallbackRow: rowIndex), includeHeaders: true)
-    }
-
-    @objc private func copyAsMarkdown() {
-        guard let coordinator else { return }
-        coordinator.copyRowsAsMarkdown(at: coordinator.currentRowSelection(fallbackRow: rowIndex))
-    }
-
-    @objc private func copyAsInClause(_ sender: NSMenuItem) {
-        guard let coordinator, let columnIndex = sender.representedObject as? Int else { return }
-        coordinator.copyRowsAsInClause(
-            at: coordinator.currentRowSelection(fallbackRow: rowIndex),
-            columnIndex: columnIndex
-        )
-    }
-
-    @objc private func showRowAsJSON() {
-        coordinator?.delegate?.dataGridShowRowAsJSON()
-    }
-
-    @objc private func chooseForeignKeyValue(_ sender: NSMenuItem) {
-        guard let columnIndex = sender.representedObject as? Int,
-              let coordinator, let tableView = coordinator.tableView,
-              let column = coordinator.tableColumnIndex(for: columnIndex) else { return }
-        coordinator.showForeignKeyPicker(
-            tableView: tableView, row: rowIndex, column: column, columnIndex: columnIndex
-        )
-    }
-
-    @objc private func previewForeignKey(_ sender: NSMenuItem) {
-        guard let columnIndex = sender.representedObject as? Int,
-              let coordinator, let tableView = coordinator.tableView,
-              let column = coordinator.tableColumnIndex(for: columnIndex) else { return }
-        coordinator.showForeignKeyPreview(
-            tableView: tableView, row: rowIndex, column: column, columnIndex: columnIndex
-        )
-    }
-
-    @objc private func navigateToForeignKey(_ sender: NSMenuItem) {
-        performForeignKeyNavigation(from: sender, intent: .follow)
-    }
-
-    @objc private func navigateToForeignKeyInNewTab(_ sender: NSMenuItem) {
-        performForeignKeyNavigation(from: sender, intent: .newTab)
-    }
-
-    private func performForeignKeyNavigation(from sender: NSMenuItem, intent: ReferenceOpenIntent) {
-        guard let columnIndex = sender.representedObject as? Int,
-              let coordinator else { return }
-        let tableRows = coordinator.tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-        guard let fkInfo = tableRows.columnForeignKeys[columnName],
-              let value = coordinator.cellValue(at: rowIndex, column: columnIndex) else { return }
-        coordinator.delegate?.dataGridNavigateFK(value: value, fkInfo: fkInfo, intent: intent)
-    }
-}
-
-private struct SetValueMenuChoice {
-    let command: SetValueCommand
-    let clickedColumn: Int
-}
-
-/// The view a row's data cells are drawn into.
-///
-/// Its own class so the drawing lands after the row's background and selection, and so one row
-/// costs exactly one view however many columns the result has.
-@MainActor
-final class DataGridRowContentView: NSView {
-    weak var rowView: DataGridRowView?
-
-    override var isFlipped: Bool { true }
-    override var allowsVibrancy: Bool { false }
-
-    /// Chrome, not content. The row publishes one accessibility element per data column and this
-    /// view carries none of them, so leaving it in the tree puts a nameless group between the row
-    /// and its cells and lets an accessibility hit test land on it.
-    override func isAccessibilityElement() -> Bool { false }
-
-    /// AppKit hit-tests down the view hierarchy, and this view covers the whole row, so every point
-    /// in the row that no cell covers used to resolve to it. The row is the answer there; forwarding
-    /// keeps the one implementation. The row never calls back into `super` while it has a window, so
-    /// this cannot loop.
-    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
-        rowView?.accessibilityHitTest(point) ?? super.accessibilityHitTest(point)
-    }
-
-    /// The separators go down in a second pass, after every cell, because a cell fills its whole
-    /// rect for a modified or find-match tint and would paint over a line drawn beside it. AppKit's
-    /// own separator views composite above the rows for the same reason.
-    override func draw(_ dirtyRect: NSRect) {
-        rowView?.drawCells(in: dirtyRect, of: self)
-        rowView?.drawColumnSeparators(in: dirtyRect, of: self)
-        rowView?.drawDraggedColumn(in: dirtyRect, of: self)
-    }
-
-    override func setNeedsDisplay(_ invalidRect: NSRect) {
-        super.setNeedsDisplay(invalidRect)
-        rowView?.forwardInvalidationToPinnedBand(convert(invalidRect, to: rowView))
-    }
-
-    override func mouseDown(with event: NSEvent) {
-        let point = convert(event.locationInWindow, from: nil)
-        let consumed = rowView?.handleCellClick(
-            at: point,
-            in: self,
-            clickCount: event.clickCount,
-            modifiers: event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-        ) ?? false
-        guard !consumed else { return }
-        super.mouseDown(with: event)
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridScrollView.swift b/apple/TablePro/Views/Results/DataGridScrollView.swift
deleted file mode 100644
index fc5d2a6c67..0000000000
--- a/apple/TablePro/Views/Results/DataGridScrollView.swift
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-//  DataGridScrollView.swift
-//  TablePro
-//
-
-import AppKit
-
-// Zoom lives here rather than on the table because a cell being edited sits in an overlay mounted on
-// this scroll view, so the table is not in that responder chain and this view is in both.
-final class DataGridScrollView: NSScrollView, ZoomCommandResponding {
-    @objc func zoomIn(_ sender: Any?) {
-        FontSizeZoom.dataGrid.zoom(by: 1)
-    }
-
-    @objc func zoomOut(_ sender: Any?) {
-        FontSizeZoom.dataGrid.zoom(by: -1)
-    }
-}
-
-extension DataGridScrollView: NSMenuItemValidation {
-    // At either end of the range the item dims rather than falling through to the editor's size.
-    func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
-        guard let action = menuItem.action else { return false }
-        return FontSizeZoom.dataGrid.enablement(action, typography: AppSettingsManager.shared.typography) ?? true
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridUpdateSnapshot.swift b/apple/TablePro/Views/Results/DataGridUpdateSnapshot.swift
deleted file mode 100644
index c5a1359b4c..0000000000
--- a/apple/TablePro/Views/Results/DataGridUpdateSnapshot.swift
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-//  DataGridUpdateSnapshot.swift
-//  TablePro
-//
-
-import AppKit
-import Foundation
-
-/// Equatable input signature; coordinator bails the updateNSView pipeline when unchanged.
-struct DataGridUpdateSnapshot: Equatable {
-    let rowDisplayCount: Int
-    let columnCount: Int
-    let columns: [String]
-    let valueFilteredIDsCount: Int?
-    let displayFormats: [ValueDisplayFormat?]
-    let highlightRules: [HighlightRule]
-    let configuration: DataGridConfiguration
-    let isEditable: Bool
-    let rowReorder: DataGridRowReorder
-    let rowHeight: CGFloat
-    let alternatingRows: Bool
-    let reloadVersion: Int
-    let contentRevision: Int
-    let columnComments: [String: String]
-}
diff --git a/apple/TablePro/Views/Results/DataGridView+RowActions.swift b/apple/TablePro/Views/Results/DataGridView+RowActions.swift
deleted file mode 100644
index 3021f8733d..0000000000
--- a/apple/TablePro/Views/Results/DataGridView+RowActions.swift
+++ /dev/null
@@ -1,567 +0,0 @@
-//
-//  DataGridView+RowActions.swift
-//  TablePro
-//
-
-import AppKit
-import os
-import TableProAutocomplete
-import TableProPluginKit
-
-private let rowActionsLogger = Logger(subsystem: "com.TablePro", category: "DataGridView+RowActions")
-
-// MARK: - Row Actions
-
-extension TableViewCoordinator {
-    @MainActor
-    func undoDeleteRow(at index: Int) {
-        guard let rowID = rowID(forDisplayRow: index) else { return }
-        changeManager.undoRowDeletion(rowID: rowID)
-        selectionSummaryTracker.dataDidChange()
-        visualIndex.updateRow(rowID, from: changeManager)
-        repaintRows(IndexSet(integer: index))
-        refreshRowVisualState(at: index)
-    }
-
-    func addNewRow() {
-        delegate?.dataGridAddRow()
-    }
-
-    func copyRows(at indices: Set<Int>, as format: RowCopyFormat) {
-        guard unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copyRows(at: indices, as: format)
-        }) else { return }
-        switch format {
-        case .rows: delegate?.dataGridCopyRows(indices)
-        case .rowsWithHeaders: copyRowsWithHeaders(at: indices)
-        case .json: copyRowsAsJson(at: indices)
-        case .csv: copyRowsAsCsv(at: indices, includeHeaders: false)
-        case .csvWithHeaders: copyRowsAsCsv(at: indices, includeHeaders: true)
-        case .markdown: copyRowsAsMarkdown(at: indices)
-        }
-    }
-
-    func copyRowsInCopyFormat(at indices: Set<Int>) {
-        copyRows(at: indices, as: rowCopyFormat)
-    }
-
-    func copyRowsWithHeaders(at indices: Set<Int>) {
-        copyRowsAsTSV(at: indices, includeHeaders: true)
-    }
-
-    func copyRowsAsTSV(at indices: Set<Int>, includeHeaders: Bool) {
-        guard unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copyRowsAsTSV(at: indices, includeHeaders: includeHeaders)
-        }) else { return }
-        let sortedIndices = clipboardDisplayIndices(indices)
-        let tableRows = tableRowsProvider()
-        let projection = visibleColumnProjection
-        let columnTypes = projection.columnTypes(tableRows.columnTypes)
-        let columns = projection.columns(tableRows.columns)
-        var tsvRows: [String] = includeHeaders ? [columns.joined(separator: "\t")] : []
-        var htmlRows: [[String]] = []
-        var copiedRows: [Row] = []
-
-        for index in sortedIndices {
-            guard let row = displayRow(at: index) else { continue }
-            let formatted = formatRowValues(values: projection.values(Array(row.values)), columnTypes: columnTypes)
-            tsvRows.append(formatted.joined(separator: "\t"))
-            htmlRows.append(formatted)
-            copiedRows.append(row)
-        }
-        guard !copiedRows.isEmpty else { return }
-
-        let tsv = tsvRows.joined(separator: "\n")
-        let html = includeHeaders ? HtmlTableEncoder.encode(rows: htmlRows, headers: columns) : nil
-        ClipboardService.shared.writeRows(
-            tsv: tsv,
-            html: html,
-            gridRows: rowsPayload(copiedRows, columns: columns, projection: projection)
-        )
-    }
-
-    // The ceiling each format's converter already puts on its text, taken first so the paste payload holds the same rows.
-    private func clipboardDisplayIndices(_ indices: Set<Int>) -> [Int] {
-        let sorted = indices.sorted()
-        let limit = RowOperationsManager.maxClipboardRows
-        guard sorted.count > limit else { return sorted }
-        rowActionsLogger.warning("Clipboard copy truncated: \(sorted.count) rows selected, capping at \(limit)")
-        return Array(sorted.prefix(limit))
-    }
-
-    // Carried by every row copy, so a paste into a grid takes the rows rather than parsing the text.
-    private func rowsPayload(
-        _ rows: [Row],
-        columns: [String],
-        projection: VisibleColumnProjection
-    ) -> GridRowsClipboardPayload {
-        GridRowsClipboardPayload(
-            columns: columns,
-            copying: rows,
-            expressionColumns: rows.map { changeManager.expressionColumns(forRow: $0.id) },
-            projection: projection
-        )
-    }
-
-    func copyCellValue(at rowIndex: Int, columnIndex: Int) {
-        guard unloadedValuesAreLoaded(displayRows: [rowIndex], columns: IndexSet(integer: columnIndex), retry: { [weak self] in
-            self?.copyCellValue(at: rowIndex, columnIndex: columnIndex)
-        }) else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0 && columnIndex < tableRows.columns.count else { return }
-        guard let row = displayRow(at: rowIndex), columnIndex < row.values.count else { return }
-
-        let cell = row.values[columnIndex]
-        if changeManager.isExpression(rowID: row.id, columnIndex: columnIndex), let sql = cell.asText {
-            ClipboardService.shared.writeCells(
-                GridCellsClipboardPayload(text: sql, fields: [[sql]], expressionFields: [0: [0]])
-            )
-            return
-        }
-        let columnTypes = tableRows.columnTypes
-        let columnType = columnTypes.indices.contains(columnIndex) ? columnTypes[columnIndex] : nil
-        let text = cellCopyText(cell, columnIndex: columnIndex, columnType: columnType)
-        ClipboardService.shared.writeCells(GridCellsClipboardPayload(text: text, fields: [[cell.isNull ? nil : text]]))
-    }
-
-    private func cellCopyText(_ cell: PluginCellValue, columnIndex: Int, columnType: ColumnType?) -> String {
-        if case .bytes(let data) = cell {
-            let format = columnIndex < columnDisplayFormats.count ? columnDisplayFormats[columnIndex] : nil
-            return format.flatMap { format in
-                guard format.isApplicable(to: columnType, databaseType: databaseType) else { return nil }
-                return ValueDisplayFormatter.apply(data, format: format, columnType: columnType)
-            }
-                ?? BlobFormattingService.shared.format(data, for: .copy)
-                ?? ""
-        }
-
-        let value = cell.asText ?? "NULL"
-
-        // A format saved before the column changed type is skipped here as the cell skips it.
-        if columnIndex < columnDisplayFormats.count, let format = columnDisplayFormats[columnIndex], format != .raw,
-           format.isApplicable(to: columnType, databaseType: databaseType),
-           let formatted = ValueDisplayFormatter.apply(value, format: format, columnType: columnType) {
-            return formatted
-        }
-
-        return BlobFormattingService.shared.formatIfNeeded(value, columnType: columnType, for: .copy)
-    }
-
-    // The statements leave out the columns the server owns, which only the schema names, so they wait for it as Duplicate does.
-    var canCopyRowsAsInsert: Bool {
-        guard let databaseType, databaseType != .mongodb, databaseType != .redis, tableName != nil else { return false }
-        return tableRowsProvider().hasAuthoritativeSchema
-    }
-
-    // A table without a key is matched on every column, so one no match can compare leaves nothing to find the row by.
-    var canCopyRowsAsUpdate: Bool {
-        guard canCopyRowsAsInsert else { return false }
-        return !primaryKeyColumns.isEmpty || tableRowsProvider().rowMatchPolicy.excludedColumns.isEmpty
-    }
-
-    func copyRowsAsInsert(at indices: Set<Int>) {
-        guard let tableName, let databaseType else { return }
-        guard unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copyRowsAsInsert(at: indices)
-        }) else { return }
-        let tableRows = tableRowsProvider()
-        let projection = selectedColumnProjection()
-        let driver = resolveDriver()
-        do {
-            let converter = try SQLRowToStatementConverter(
-                tableName: tableName,
-                schemaName: schemaName,
-                columns: projection.columns(tableRows.columns),
-                primaryKeyColumns: primaryKeyColumns,
-                databaseType: databaseType,
-                unwritableColumns: unwritableColumns(in: tableRows),
-                quoteIdentifier: driver?.quoteIdentifier,
-                escapeStringLiteral: driver?.escapeStringLiteral,
-                identifierSpelling: copiedIdentifierSpelling(for: databaseType)
-            )
-            let rows = indices.sorted().compactMap(displayRow(at:)).map { row in
-                SQLRowToStatementConverter.SourceRow(
-                    values: projection.values(Array(row.values)),
-                    defaultedColumns: projection.positions(of: stagedDefaults(of: row)),
-                    expressionColumns: projection.positions(of: stagedExpressions(of: row))
-                )
-            }
-            writeCopiedStatements(converter.generateInserts(rows: rows))
-        } catch {
-            rowActionsLogger.error("copyRowsAsInsert failed: \(error.publicLogShape, privacy: .public)")
-        }
-    }
-
-    /// Every column takes part: SET is limited to the selected or visible ones, but the row is found by all of its
-    /// key, or with no key by every column it has, hidden ones included, as it is stored rather than as edited.
-    func copyRowsAsUpdate(at indices: Set<Int>) {
-        guard let tableName, let databaseType else { return }
-        guard unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copyRowsAsUpdate(at: indices)
-        }) else { return }
-        let tableRows = tableRowsProvider()
-        let settable = selectionController.isEmpty ? visibleColumnProjection : selectedColumnProjection()
-        let driver = resolveDriver()
-        do {
-            let converter = try SQLRowToStatementConverter(
-                tableName: tableName,
-                schemaName: schemaName,
-                columns: tableRows.columns,
-                primaryKeyColumns: primaryKeyColumns,
-                databaseType: databaseType,
-                unwritableColumns: unwritableColumns(in: tableRows),
-                rowMatchPolicy: tableRows.rowMatchPolicy,
-                settableColumns: settable.columns(tableRows.columns),
-                quoteIdentifier: driver?.quoteIdentifier,
-                escapeStringLiteral: driver?.escapeStringLiteral,
-                identifierSpelling: copiedIdentifierSpelling(for: databaseType),
-                rowUpdateStatement: driver?.rowUpdateStatement,
-                matchesEveryColumn: driver?.primaryKeyNamesOneRow == false
-            )
-            let rows = indices.sorted().compactMap { displayRow(at: $0).map(copiedSourceRow) }
-            writeCopiedStatements(converter.generateUpdates(rows: rows))
-        } catch {
-            rowActionsLogger.error("copyRowsAsUpdate failed: \(error.publicLogShape, privacy: .public)")
-        }
-    }
-
-    private func copiedIdentifierSpelling(for databaseType: DatabaseType) -> SQLIdentifierSpelling? {
-        guard let rules = databaseType.identifierRules else { return nil }
-        return SQLIdentifierSpelling(rules: rules, policy: SQLIdentifierCase.stored(for: connectionId))
-    }
-
-    private func unwritableColumns(in tableRows: TableRows) -> Set<String> {
-        Set(tableRows.columns.filter { tableRows.generatedColumns.contains($0) || !isColumnWritable($0) })
-    }
-
-    private func copiedSourceRow(_ row: Row) -> SQLRowToStatementConverter.SourceRow {
-        var stored = Array(row.values)
-        let pendingUpdate = changeManager.rowChanges.first { $0.rowID == row.id && $0.type == .update }
-        for cellChange in pendingUpdate?.cellChanges ?? [] where stored.indices.contains(cellChange.columnIndex) {
-            stored[cellChange.columnIndex] = cellChange.oldValue
-        }
-        return SQLRowToStatementConverter.SourceRow(
-            values: Array(row.values),
-            storedValues: stored,
-            isPendingInsert: changeManager.insertedRowIDs.contains(row.id),
-            defaultedColumns: stagedDefaults(of: row),
-            expressionColumns: stagedExpressions(of: row)
-        )
-    }
-
-    /// The cells the grid itself set to the server's default: every marker in a row not saved yet, and in a saved row
-    /// the cells a pending edit set to Default. Anything else that reads `__DEFAULT__` is what the table holds.
-    private func stagedDefaults(of row: Row) -> Set<Int> {
-        let marker = PluginCellValue.text("__DEFAULT__")
-        if changeManager.insertedRowIDs.contains(row.id) {
-            return Set(row.values.indices.filter { row.values[$0] == marker })
-        }
-        let pendingUpdate = changeManager.rowChanges.first { $0.rowID == row.id && $0.type == .update }
-        return Set(pendingUpdate?.cellChanges.filter { $0.newValue == marker }.map(\.columnIndex) ?? [])
-    }
-
-    private func stagedExpressions(of row: Row) -> Set<Int> {
-        changeManager.expressionColumns(forRow: row.id)
-    }
-
-    /// A copy that produced no statement leaves the clipboard as it was, rather than replacing it with nothing.
-    private func writeCopiedStatements(_ statements: String) {
-        guard !statements.isEmpty else { return }
-        ClipboardService.shared.writeText(statements)
-    }
-
-    func copyRowsAsJson(at indices: Set<Int>) {
-        guard !indices.isEmpty else { return }
-        guard unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copyRowsAsJson(at: indices)
-        }) else { return }
-        let tableRows = tableRowsProvider()
-        let projection = selectedColumnProjection()
-        let displayIndices = clipboardDisplayIndices(indices)
-        let output = ResultJsonSerializer.serialize(
-            tableRows: tableRows,
-            displayIDs: displayIDs,
-            selectedDisplayIndices: Set(displayIndices),
-            columns: projection
-        )
-        guard output.rowCount > 0 else { return }
-        let copied = displayIndices.compactMap(displayRow(at:))
-        ClipboardService.shared.writeText(
-            output.json,
-            gridRows: rowsPayload(copied, columns: projection.columns(tableRows.columns), projection: projection)
-        )
-    }
-
-    func copyRowsAsCsv(at indices: Set<Int>, includeHeaders: Bool) {
-        guard unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copyRowsAsCsv(at: indices, includeHeaders: includeHeaders)
-        }) else { return }
-        let projection = selectedColumnProjection()
-        let copied = clipboardDisplayIndices(indices).compactMap(displayRow(at:))
-        guard !copied.isEmpty else { return }
-        let tableRows = tableRowsProvider()
-        let columns = projection.columns(tableRows.columns)
-        let converter = CsvRowConverter(columns: columns, columnTypes: projection.columnTypes(tableRows.columnTypes))
-        ClipboardService.shared.writeCsv(
-            converter.generateCsv(rows: copied.map { projection.values(Array($0.values)) }, includeHeaders: includeHeaders),
-            gridRows: rowsPayload(copied, columns: columns, projection: projection)
-        )
-    }
-
-    func copyRowsAsMarkdown(at indices: Set<Int>) {
-        guard unloadedValuesAreLoaded(displayRows: indices, retry: { [weak self] in
-            self?.copyRowsAsMarkdown(at: indices)
-        }) else { return }
-        let projection = selectedColumnProjection()
-        let copied = clipboardDisplayIndices(indices).compactMap(displayRow(at:))
-        guard !copied.isEmpty else { return }
-        let tableRows = tableRowsProvider()
-        let columns = projection.columns(tableRows.columns)
-        let converter = MarkdownTableConverter(columns: columns, columnTypes: projection.columnTypes(tableRows.columnTypes))
-        ClipboardService.shared.writeText(
-            converter.generateMarkdown(rows: copied.map { projection.values(Array($0.values)) }),
-            gridRows: rowsPayload(copied, columns: columns, projection: projection)
-        )
-    }
-
-    func copyRowsAsInClause(at indices: Set<Int>, columnIndex: Int) {
-        guard unloadedValuesAreLoaded(displayRows: indices, columns: IndexSet(integer: columnIndex), retry: { [weak self] in
-            self?.copyRowsAsInClause(at: indices, columnIndex: columnIndex)
-        }) else { return }
-        let rows: [[PluginCellValue]] = indices.sorted().compactMap { displayRow(at: $0).map { Array($0.values) } }
-        guard !rows.isEmpty else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let driver = resolveDriver()
-        let converter = InClauseConverter(
-            columnIndex: columnIndex,
-            columnTypes: tableRows.columnTypes,
-            escapeStringLiteral: driver?.escapeStringLiteral,
-            stringLiteralPrefix: SQLStringLiteralPrefix.forDatabaseType(databaseType)
-        )
-        ClipboardService.shared.writeText(converter.generateInClause(rows: rows))
-    }
-
-    func copyColumnValues(columnIndex: Int) {
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let totalRows = displayIDs?.count ?? tableRows.rows.count
-        let rowCount = min(totalRows, PluginRowLimits.emergencyMax)
-        guard rowCount > 0 else { return }
-        guard unloadedValuesAreLoaded(displayRows: 0..<rowCount, columns: IndexSet(integer: columnIndex), retry: { [weak self] in
-            self?.copyColumnValues(columnIndex: columnIndex)
-        }) else { return }
-
-        let columnType = tableRows.columnTypes.indices.contains(columnIndex)
-            ? tableRows.columnTypes[columnIndex]
-            : nil
-
-        var lines: [String] = []
-        lines.reserveCapacity(rowCount)
-        for rowIndex in 0..<rowCount {
-            guard let row = displayRow(at: rowIndex), row.values.indices.contains(columnIndex) else { continue }
-            let text = RowValueCopyFormatter.copyText(cell: row.values[columnIndex], columnType: columnType) ?? "NULL"
-            lines.append(text)
-        }
-        guard !lines.isEmpty else { return }
-        ClipboardService.shared.writeText(lines.joined(separator: "\n"))
-    }
-
-    private func formatRowValues(values: [PluginCellValue], columnTypes: [ColumnType]?) -> [String] {
-        values.enumerated().map { index, cell in
-            switch cell {
-            case .null:
-                return "NULL"
-            case .text(let value):
-                let columnType = columnTypes.flatMap { $0.indices.contains(index) ? $0[index] : nil }
-                return BlobFormattingService.shared.formatIfNeeded(value, columnType: columnType, for: .copy)
-            case .bytes(let data):
-                return BlobFormattingService.shared.format(data, for: .copy) ?? ""
-            }
-        }
-    }
-
-    private var visibleColumnProjection: VisibleColumnProjection {
-        VisibleColumnProjection(indices: visibleColumnDataIndices())
-    }
-
-    /// The selection's columns as data indices, already in display order because that is the order
-    /// its display positions run in.
-    private func selectedColumnProjection() -> VisibleColumnProjection {
-        guard !selectionController.isEmpty else { return visibleColumnProjection }
-        let ordered = dataColumnIndices(in: selectionController.selection.affectedColumns)
-        return ordered.isEmpty ? visibleColumnProjection : VisibleColumnProjection(indices: ordered)
-    }
-
-    func resolveDriver() -> (any DatabaseDriver)? {
-        guard let connectionId else { return nil }
-        return DatabaseManager.shared.driver(for: connectionId)
-    }
-
-    // MARK: - Row Drag and Drop
-
-    private static let rowDragType = NSPasteboard.PasteboardType("com.TablePro.rowDrag")
-
-    /// Writes the reorder type only where a reorder can actually run. The text and HTML flavours
-    /// are written either way: dragging a row into another app is a copy, and it stays available on
-    /// an engine whose columns cannot move.
-    func tableView(_ tableView: NSTableView, pasteboardWriterForRow row: Int) -> (any NSPasteboardWriting)? {
-        guard delegate != nil else { return nil }
-        let item = NSPasteboardItem()
-        if rowReorder.isEnabled {
-            item.setString(String(row), forType: Self.rowDragType)
-        }
-
-        if let values = displayRow(at: row)?.values {
-            let tableRows = tableRowsProvider()
-            let projection = visibleColumnProjection
-            let formatted = formatRowValues(
-                values: projection.values(Array(values)),
-                columnTypes: projection.columnTypes(tableRows.columnTypes)
-            )
-            item.setString(formatted.joined(separator: "\t"), forType: .string)
-            item.setString(
-                HtmlTableEncoder.encode(rows: [formatted], headers: projection.columns(tableRows.columns)),
-                forType: .html
-            )
-        }
-
-        return item
-    }
-
-    func tableView(
-        _ tableView: NSTableView,
-        validateDrop info: any NSDraggingInfo,
-        proposedRow row: Int,
-        proposedDropOperation dropOperation: NSTableView.DropOperation
-    ) -> NSDragOperation {
-        guard delegate != nil, rowReorder.isEnabled else { return [] }
-        guard info.draggingSource as? NSTableView === tableView else { return [] }
-        guard info.draggingPasteboard.availableType(from: [Self.rowDragType]) != nil else { return [] }
-        guard dropOperation == .above else {
-            tableView.setDropRow(row, dropOperation: .above)
-            return .move
-        }
-        return .move
-    }
-
-    func tableView(
-        _ tableView: NSTableView,
-        acceptDrop info: any NSDraggingInfo,
-        row: Int,
-        dropOperation: NSTableView.DropOperation
-    ) -> Bool {
-        guard let delegate, rowReorder.isEnabled else { return false }
-        guard let item = info.draggingPasteboard.pasteboardItems?.first,
-              let rowString = item.string(forType: Self.rowDragType),
-              let fromRow = Int(rowString) else {
-            return false
-        }
-        guard fromRow != row && fromRow != row - 1 else { return false }
-        delegate.dataGridMoveRow(from: fromRow, to: row)
-        return true
-    }
-
-    /// The header hands over the data index of the column it drew; a selection is built from
-    /// display positions, so the two are translated here rather than inside the controller.
-    func selectColumn(_ dataColumnIndex: Int) {
-        guard let position = displayPosition(ofDataColumnIndex: dataColumnIndex) else { return }
-        let totalRows = displayIDs?.count ?? tableRowsProvider().rows.count
-        selectionController.selectEntireColumn(position, totalRows: totalRows)
-        if let keyTableView = tableView as? KeyHandlingTableView {
-            keyTableView.deselectAll(nil)
-        }
-    }
-
-    func extendColumnSelection(_ dataColumnIndex: Int) {
-        guard let position = displayPosition(ofDataColumnIndex: dataColumnIndex) else { return }
-        let totalRows = displayIDs?.count ?? tableRowsProvider().rows.count
-        selectionController.addEntireColumn(position, totalRows: totalRows)
-        if let keyTableView = tableView as? KeyHandlingTableView {
-            keyTableView.deselectAll(nil)
-        }
-    }
-
-    /// Copies the selected block in the order the user is looking at it.
-    ///
-    /// The rect's column axis is display positions, so the walk is over positions and each one is
-    /// resolved to its data index before a value is read. Walking the rect as though its bounds were
-    /// data indices copied whatever slots happened to lie between them, which after a column reorder
-    /// is not the block that was swept and can include a column the user hid.
-    func copyGridSelection(_ selection: GridSelection) {
-        guard let rect = selection.boundingRectangle else { return }
-        if rect.rows.count == 1, rect.columns.count == 1,
-           let dataColumn = dataColumnIndex(atDisplayPosition: rect.columns.lowerBound) {
-            copyCellValue(at: rect.rows.lowerBound, columnIndex: dataColumn)
-            return
-        }
-
-        let tableRows = tableRowsProvider()
-        let columnTypes = tableRows.columnTypes
-        let rowCount = displayIDs?.count ?? tableRows.rows.count
-
-        /// The same ceiling the row copy has always had. Copy reads the cell selection first, so a
-        /// Select All that keeps its rectangle now arrives here instead of on the row path, and
-        /// without this a Fetch All over millions of rows builds the whole string on the main
-        /// thread. (#2667)
-        let maxRows = RowOperationsManager.maxClipboardRows
-        let selectedRowCount = min(rect.rows.upperBound, rowCount - 1) - rect.rows.lowerBound + 1
-        let lastRow = min(
-            rect.rows.upperBound,
-            max(0, rowCount - 1),
-            rect.rows.lowerBound + maxRows - 1
-        )
-        let rowRange = rect.rows.lowerBound...lastRow
-        let positions = Array(rect.columns.lowerBound...rect.columns.upperBound)
-            .filter { $0 >= 0 && $0 < presentedColumnCount }
-        guard rowRange.lowerBound <= rowRange.upperBound, !positions.isEmpty else { return }
-        let copiedColumns = IndexSet(positions.compactMap { dataColumnIndex(atDisplayPosition: $0) })
-        guard unloadedValuesAreLoaded(displayRows: rowRange, columns: copiedColumns, retry: { [weak self] in
-            self?.copyGridSelection(selection)
-        }) else { return }
-        let isTruncated = selectedRowCount > maxRows
-        if isTruncated {
-            rowActionsLogger.warning("Clipboard copy truncated: \(selectedRowCount) rows selected, capping at \(maxRows)")
-        }
-
-        var copiedLines: [[String?]] = []
-        copiedLines.reserveCapacity(rowRange.count)
-        var expressionFields: [Int: Set<Int>] = [:]
-        for rowIndex in rowRange {
-            guard let row = displayRow(at: rowIndex) else {
-                copiedLines.append(Array(repeating: "", count: positions.count))
-                continue
-            }
-            let expressionColumns = changeManager.expressionColumns(forRow: row.id)
-            var fields: [String?] = []
-            fields.reserveCapacity(positions.count)
-            for position in positions {
-                guard selection.contains(row: rowIndex, displayColumn: position),
-                      let columnIndex = dataColumnIndex(atDisplayPosition: position),
-                      row.values.indices.contains(columnIndex) else {
-                    fields.append("")
-                    continue
-                }
-                let cell = row.values[columnIndex]
-                if expressionColumns.contains(columnIndex), let sql = cell.asText {
-                    expressionFields[copiedLines.count, default: []].insert(fields.count)
-                    fields.append(sql)
-                    continue
-                }
-                let columnType = columnTypes.indices.contains(columnIndex) ? columnTypes[columnIndex] : nil
-                fields.append(RowValueCopyFormatter.copyText(cell: cell, columnType: columnType))
-            }
-            copiedLines.append(fields)
-        }
-
-        var text = copiedLines.map { $0.map { $0 ?? "NULL" }.joined(separator: "\t") }.joined(separator: "\n")
-        if isTruncated {
-            text.append("\n(truncated, showing first \(maxRows) of \(selectedRowCount) rows)")
-        }
-        ClipboardService.shared.writeCells(GridCellsClipboardPayload(
-            text: text,
-            fields: copiedLines,
-            expressionFields: expressionFields.isEmpty ? nil : expressionFields
-        ))
-    }
-}
diff --git a/apple/TablePro/Views/Results/DataGridView.swift b/apple/TablePro/Views/Results/DataGridView.swift
deleted file mode 100644
index a2a912ab28..0000000000
--- a/apple/TablePro/Views/Results/DataGridView.swift
+++ /dev/null
@@ -1,765 +0,0 @@
-//
-//  DataGridView.swift
-//  TablePro
-//
-//  High-performance NSTableView wrapper for SwiftUI.
-//  Custom views extracted to separate files for maintainability.
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import TableProTheme
-
-struct CellPosition: Hashable {
-    let row: Int
-    let column: Int
-}
-
-enum DataGridChangeVocabulary: Equatable {
-    case pendingEdit
-    case comparison
-    case resultComparison
-}
-
-struct RowVisualState: Equatable {
-    let isDeleted: Bool
-    let isInserted: Bool
-    let modifiedColumns: Set<Int>
-    let struckColumns: Set<Int>
-    /// Pending cells staged as SQL, which draw like a pending DEFAULT.
-    let expressionColumns: Set<Int>
-    let vocabulary: DataGridChangeVocabulary
-    let highlight: RowHighlight
-
-    init(
-        isDeleted: Bool,
-        isInserted: Bool,
-        modifiedColumns: Set<Int>,
-        struckColumns: Set<Int> = [],
-        expressionColumns: Set<Int> = [],
-        vocabulary: DataGridChangeVocabulary = .pendingEdit,
-        highlight: RowHighlight = .none
-    ) {
-        self.isDeleted = isDeleted
-        self.isInserted = isInserted
-        self.modifiedColumns = modifiedColumns
-        self.struckColumns = struckColumns
-        self.expressionColumns = expressionColumns
-        self.vocabulary = vocabulary
-        self.highlight = highlight
-    }
-
-    func isModified(columnIndex: Int) -> Bool {
-        modifiedColumns.contains(columnIndex)
-    }
-
-    func isStruck(columnIndex: Int) -> Bool {
-        struckColumns.contains(columnIndex)
-    }
-
-    func isExpression(columnIndex: Int) -> Bool {
-        expressionColumns.contains(columnIndex)
-    }
-
-    func highlighted(_ highlight: RowHighlight) -> RowVisualState {
-        RowVisualState(
-            isDeleted: isDeleted,
-            isInserted: isInserted,
-            modifiedColumns: modifiedColumns,
-            struckColumns: struckColumns,
-            expressionColumns: expressionColumns,
-            vocabulary: vocabulary,
-            highlight: highlight
-        )
-    }
-
-    static let empty = RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [])
-}
-
-extension RowVisualState {
-    /// The wash a row in this state carries, read by the row and by the pinned row gutter over it so
-    /// the two cannot disagree.
-    @MainActor func tint(in scope: ThemeScope) -> NSColor? {
-        if isDeleted { return scope.resolved[.gridDeleted] }
-        if isInserted { return scope.resolved[.gridInserted] }
-        return highlight.rowColor?.washColor
-    }
-
-    func cellHighlightColor(forColumn column: Int) -> HighlightColor? {
-        guard !isDeleted, !isInserted else { return nil }
-        return highlight.cellRule(forColumn: column)?.color
-    }
-
-    func drawnHighlightRule(forColumn column: Int) -> HighlightRule? {
-        guard !isDeleted, !isInserted else { return nil }
-        if !isModified(columnIndex: column), let cellRule = highlight.cellRule(forColumn: column) {
-            return cellRule
-        }
-        return highlight.rowRule
-    }
-}
-
-struct DataGridView: NSViewRepresentable {
-    var tableRowsProvider: @MainActor () -> TableRows = { TableRows() }
-    var tableRowsMutator: @MainActor (@MainActor (inout TableRows) -> Delta) -> Delta = { _ in .none }
-    var paginationOffsetProvider: @MainActor () -> Int = { 0 }
-    var changeManager: AnyChangeManager
-    let isEditable: Bool
-    var configuration: DataGridConfiguration = .init()
-    var displayFormats: [ValueDisplayFormat?] = []
-    var highlightRules: [HighlightRule] = []
-    var delegate: (any DataGridViewDelegate)?
-    var layoutPersister: (any ColumnLayoutPersisting)?
-    /// Whether a row may be dragged to a new position, and why not when it may not.
-    var rowReorder: DataGridRowReorder = .disabled
-
-    @Binding var selectedRowIndices: Set<Int>
-    @Binding var sortState: SortState
-    @Binding var columnLayout: ColumnLayoutState
-    /// The per-column value filter, bound to an owner that outlives this view.
-    ///
-    /// SwiftUI destroys the coordinator whenever the grid leaves the view tree, and the display
-    /// order this filter produces has to survive that: JSON mode, the row inspector and the Edit
-    /// menu's row commands all read it with no grid mounted. A grid with no owner keeps the filter
-    /// on its own coordinator, which is all a structure or create-table grid ever needs. (#2251)
-    var valueFilter: Binding<GridValueFilterState>?
-    var displayOrderProvider: (@MainActor () -> [RowID]?)?
-    /// The formatted text and viewport anchor for this result, owned the same way and for the same
-    /// reason as the value filter above. The owner hands back a fresh instance whenever the inputs
-    /// that decide the text have moved, so adopting one is always safe. (#2424)
-    var displayState: DataGridDisplayState?
-    /// The selection to put back once the rows are in, owned the same way again. A grid with no
-    /// owner has nothing to restore and keeps whatever its own gestures build. (#2667)
-    ///
-    /// The rows come from the tab rather than from `selectedRowIndices`, which is the shared
-    /// `GridSelectionState`: the structure grid clears that channel and then publishes its own
-    /// schema rows into it, so on a Data to Structure to Data round trip it holds either nothing or
-    /// positions belonging to another grid entirely.
-    var restoredRowSelection: Set<Int>?
-    var restoredCellSelection: GridSelection?
-    /// Handed this grid's selection on the way out, for the owner to keep until the next mount.
-    var onSelectionTeardown: (@MainActor (Set<Int>, GridSelection) -> Void)?
-    var viewportPlacementProvider: (@MainActor () -> GridViewportPlacement?)?
-    var contentRevision: Int = 0
-    var selectionSummary: SelectionSummaryState?
-    /// Where every color the grid draws comes from. Only the theme editor's preview passes another.
-    var themeScope: ThemeScope = .live
-
-    // MARK: - NSViewRepresentable
-
-    func makeNSView(context: Context) -> NSScrollView {
-        let scrollView = DataGridScrollView()
-        scrollView.hasVerticalScroller = true
-        scrollView.hasHorizontalScroller = true
-        scrollView.autohidesScrollers = true
-        scrollView.borderType = .noBorder
-        scrollView.contentView.wantsLayer = true
-        scrollView.contentView.layerContentsRedrawPolicy = .onSetNeedsDisplay
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = context.coordinator
-        tableView.style = .plain
-        tableView.wantsLayer = true
-        tableView.layerContentsRedrawPolicy = .onSetNeedsDisplay
-        tableView.setAccessibilityIdentifier("data-grid")
-        tableView.setAccessibilityLabel(String(localized: "Data grid"))
-        tableView.setAccessibilityRole(.table)
-        let settings = AppSettingsManager.shared.dataGrid
-        tableView.usesAlternatingRowBackgroundColors = settings.showAlternateRows
-        tableView.allowsMultipleSelection = true
-        tableView.allowsColumnReordering = true
-        tableView.allowsColumnResizing = true
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = DataGridMetrics.rowHeight(settings.rowHeight, font: ThemeEngine.shared.dataGridFonts.regular)
-        tableView.usesAutomaticRowHeights = false
-        DataGridBodyChrome.applyThemeColors(to: tableView, scope: context.coordinator.themeScope)
-
-        tableView.delegate = context.coordinator
-        tableView.dataSource = context.coordinator
-
-        let rowNumberColumn = Self.makeRowNumberColumn()
-        tableView.addTableColumn(rowNumberColumn)
-        rowNumberColumn.isHidden = !configuration.showRowNumbers
-
-        let sortableHeader = SortableHeaderView(frame: tableView.headerView?.frame ?? .zero)
-        sortableHeader.coordinator = context.coordinator
-        let headerMenu = NSMenu()
-        headerMenu.delegate = context.coordinator
-        sortableHeader.menu = headerMenu
-        tableView.headerView = sortableHeader
-
-        scrollView.documentView = tableView
-
-        let coordinator = context.coordinator
-        coordinator.tableView = tableView
-        coordinator.tableRowsProvider = tableRowsProvider
-        coordinator.tableRowsMutator = tableRowsMutator
-        coordinator.paginationOffsetProvider = paginationOffsetProvider
-        coordinator.valueFilterBinding = valueFilter
-        coordinator.displayOrderProvider = displayOrderProvider
-        if let valueFilter {
-            coordinator.adoptValueFilter(valueFilter.wrappedValue)
-        }
-        if let displayState {
-            coordinator.adoptDisplayState(displayState)
-        }
-        coordinator.delegate = delegate
-        coordinator.syncDisplayFormats(displayFormats)
-        // A remount inherits the owner's filter, so resolve the order before the first update
-        // builds its snapshot from it. Otherwise the grid reports the unfiltered count once.
-        coordinator.recomputeValueFilteredIDs()
-        coordinator.apply(configuration: configuration, isEditable: isEditable)
-        delegate?.dataGridAttach(tableViewCoordinator: coordinator)
-
-        let initialRows = tableRowsProvider()
-        coordinator.rebuildColumnMetadataCache(from: initialRows)
-        coordinator.syncHighlightRules(highlightRules, tableRows: initialRows)
-
-        coordinator.isRebuildingColumns = true
-        let storedInitialLayout = coordinator.layoutDiscardingUnownedWidths(
-            coordinator.savedColumnLayout(binding: columnLayout),
-            tableRows: initialRows
-        )
-        coordinator.synchronizeUserSizedColumns(
-            with: storedInitialLayout,
-            columns: initialRows.columns,
-            tableIdentityChanged: true
-        )
-        reconcileColumnPool(
-            tableView: tableView,
-            coordinator: coordinator,
-            tableRows: initialRows,
-            columnComments: Self.effectiveColumnComments(for: initialRows),
-            savedLayout: storedInitialLayout
-        )
-        coordinator.isRebuildingColumns = false
-        coordinator.updateColumnPresentations(from: initialRows)
-        coordinator.frozenColumnCount = storedInitialLayout?.frozenColumnCount ?? 0
-        coordinator.lastBoundFrozenColumnCount = columnLayout.frozenColumnCount
-
-        coordinator.rowReorder = rowReorder
-        if rowReorder.isEnabled {
-            tableView.registerForDraggedTypes([NSPasteboard.PasteboardType("com.TablePro.rowDrag")])
-            tableView.draggingDestinationFeedbackStyle = .gap
-        }
-
-        installSelectionOverlay(tableView: tableView, coordinator: coordinator)
-        Self.installRowGutter(scrollView: scrollView, tableView: tableView, coordinator: coordinator)
-        coordinator.attachScrollObservers(scrollView: scrollView)
-        // Intentionally do not prime cachedRowCount/cachedColumnCount here.
-        // They represent what NSTableView has actually rendered. Leaving them
-        // at 0 ensures the first `updateNSView` detects a structure change
-        // and triggers `reloadData()` — without this, a recreated grid (e.g.
-        // after a Structure/JSON tab toggle) finds the cache already matching
-        // the registry rows and skips the reload, leaving the table empty.
-        return scrollView
-    }
-
-    func updateNSView(_ scrollView: NSScrollView, context: Context) {
-        guard let tableView = scrollView.documentView as? NSTableView else { return }
-        let coordinator = context.coordinator
-        coordinator.adoptThemeScope(themeScope)
-
-        if tableView.editedRow >= 0 { return }
-        if let editor = coordinator.overlayEditor, editor.isActive { return }
-        if let viewer = coordinator.overlayViewer, viewer.isActive { return }
-
-        coordinator.tableRowsProvider = tableRowsProvider
-        coordinator.tableRowsMutator = tableRowsMutator
-        coordinator.paginationOffsetProvider = paginationOffsetProvider
-        coordinator.changeManager = changeManager
-        coordinator.selectionSummaryTracker.attach(selectionSummary)
-        // Only a change on the owner's side: Reset Columns, or a tab pointed at another table.
-        if columnLayout.frozenColumnCount != coordinator.lastBoundFrozenColumnCount {
-            coordinator.lastBoundFrozenColumnCount = columnLayout.frozenColumnCount
-            coordinator.frozenColumnCount = columnLayout.frozenColumnCount
-        }
-
-        // The owner can change the filter while the grid is unmounted, so adopt and re-resolve
-        // before the snapshot is built. A snapshot taken from the stale order would report no
-        // change and skip the reload.
-        coordinator.valueFilterBinding = valueFilter
-        coordinator.displayOrderProvider = displayOrderProvider
-        if let valueFilter, coordinator.valueFilterState != valueFilter.wrappedValue {
-            coordinator.adoptValueFilter(valueFilter.wrappedValue)
-            coordinator.recomputeValueFilteredIDs()
-        }
-        if let displayState {
-            coordinator.adoptDisplayState(displayState)
-        }
-
-        let latestRows = tableRowsProvider()
-        let rowDisplayCount = coordinator.valueFilteredIDs?.count ?? latestRows.count
-        let columnCount = latestRows.columns.count
-        let settings = AppSettingsManager.shared.dataGrid
-        let rowHeight = DataGridMetrics.rowHeight(settings.rowHeight, font: ThemeEngine.shared.dataGridFonts.regular)
-        let alternatingRows = settings.showAlternateRows
-        let columnComments = Self.effectiveColumnComments(for: latestRows)
-
-        let snapshot = DataGridUpdateSnapshot(
-            rowDisplayCount: rowDisplayCount,
-            columnCount: columnCount,
-            columns: latestRows.columns,
-            valueFilteredIDsCount: coordinator.valueFilteredIDs?.count,
-            displayFormats: displayFormats,
-            highlightRules: highlightRules,
-            configuration: configuration,
-            isEditable: isEditable,
-            rowReorder: rowReorder,
-            rowHeight: rowHeight,
-            alternatingRows: alternatingRows,
-            reloadVersion: changeManager.reloadVersion,
-            contentRevision: contentRevision,
-            columnComments: columnComments
-        )
-
-        var contentReplaced = false
-        if snapshot != coordinator.lastUpdateSnapshot {
-            // Read from the retained state rather than from `lastUpdateSnapshot`, which is nil on a
-            // freshly mounted coordinator and would therefore report every remount as a content
-            // change and discard the text the owner just handed over.
-            let contentIdentity = DataGridContentIdentity(
-                reloadVersion: changeManager.reloadVersion,
-                contentRevision: contentRevision
-            )
-            let contentChanged = coordinator.displayState.contentIdentity != contentIdentity
-            contentReplaced = contentChanged
-            coordinator.displayState.contentIdentity = contentIdentity
-            applyStructuralUpdate(
-                tableView: tableView,
-                coordinator: coordinator,
-                latestRows: latestRows,
-                rowDisplayCount: rowDisplayCount,
-                columnCount: columnCount,
-                rowHeight: rowHeight,
-                alternatingRows: alternatingRows,
-                rowReorder: snapshot.rowReorder,
-                contentChanged: contentChanged,
-                columnComments: columnComments
-            )
-            coordinator.lastUpdateSnapshot = snapshot
-        }
-
-        syncSortState(tableView: tableView, coordinator: coordinator)
-        restoreSelection(tableView: tableView, coordinator: coordinator)
-        syncSelection(tableView: tableView, coordinator: coordinator)
-        if let placement = viewportPlacementProvider?() {
-            coordinator.applyViewportPlacement(placement)
-        }
-        coordinator.schedulePendingColumnJump(contentReplaced: contentReplaced)
-    }
-
-    private func applyStructuralUpdate(
-        tableView: NSTableView,
-        coordinator: TableViewCoordinator,
-        latestRows: TableRows,
-        rowDisplayCount: Int,
-        columnCount: Int,
-        rowHeight: CGFloat,
-        alternatingRows: Bool,
-        rowReorder: DataGridRowReorder,
-        contentChanged: Bool,
-        columnComments: [String: String]
-    ) {
-        let rowsKeptAcrossReload = contentChanged ? [] : coordinator.selectedRowIDs()
-
-        if let rowNumCol = tableView.tableColumns.first(where: { $0.identifier == ColumnIdentitySchema.rowNumberIdentifier }) {
-            let shouldHide = !configuration.showRowNumbers
-            if rowNumCol.isHidden != shouldHide {
-                rowNumCol.isHidden = shouldHide
-                if !shouldHide {
-                    coordinator.resizeRowNumberColumnForCurrentRange()
-                }
-                coordinator.columnGeometryDidChange()
-            }
-        }
-
-        coordinator.rowReorder = rowReorder
-        let rowDragType = NSPasteboard.PasteboardType("com.TablePro.rowDrag")
-        let hasDragRegistered = tableView.registeredDraggedTypes.contains(rowDragType)
-        if rowReorder.isEnabled && !hasDragRegistered {
-            tableView.registerForDraggedTypes([rowDragType])
-            tableView.draggingDestinationFeedbackStyle = .gap
-        } else if !rowReorder.isEnabled && hasDragRegistered {
-            let remaining = tableView.registeredDraggedTypes.filter { $0 != rowDragType }
-            tableView.unregisterDraggedTypes()
-            if !remaining.isEmpty {
-                tableView.registerForDraggedTypes(remaining)
-            }
-        }
-
-        coordinator.applyRowHeight(rowHeight)
-        if tableView.usesAlternatingRowBackgroundColors != alternatingRows {
-            tableView.usesAlternatingRowBackgroundColors = alternatingRows
-            coordinator.repaintRowGutter()
-        }
-
-        let oldRowCount = coordinator.cachedRowCount
-        let oldColumnCount = coordinator.cachedColumnCount
-        let structureChanged = oldRowCount != rowDisplayCount || oldColumnCount != columnCount
-
-        let previousColumnKey = coordinator.columnLayoutKey
-        let liveColumnWidths = latestRows.columns.isEmpty ? [:] : coordinator.currentColumnWidths()
-        coordinator.apply(configuration: configuration, isEditable: isEditable)
-        let schemaChanged = coordinator.rebuildColumnMetadataCache(from: latestRows)
-        let highlightsChanged = coordinator.syncHighlightRules(highlightRules, tableRows: latestRows)
-        let presentationChanges = coordinator.updateColumnPresentations(from: latestRows)
-        let needsFullReload = structureChanged
-            || schemaChanged
-            || contentChanged
-            || !presentationChanges.isEmpty
-        if contentChanged {
-            coordinator.invalidateDisplayCache()
-        }
-
-        if oldRowCount == 0, rowDisplayCount > 0, rowHeight > 0 {
-            let visibleRows = Int(tableView.visibleRect.height / rowHeight) + 5
-            coordinator.preWarmDisplayCache(rowCount: visibleRows, from: coordinator.scrollAnchorRow)
-        }
-
-        coordinator.updateCache()
-        coordinator.delegate = delegate
-        let displayFormatsChanged = coordinator.columnDisplayFormats != displayFormats
-        let remappedValueFilters = coordinator.syncDisplayFormats(displayFormats)
-        delegate?.dataGridAttach(tableViewCoordinator: coordinator)
-        coordinator.recomputeValueFilteredIDs()
-        coordinator.updateCache()
-        coordinator.visualIndex.rebuild(from: coordinator.changeManager)
-
-        /// Reconciled for a result with no columns as well, which hides every slot, exactly as
-        /// `makeNSView` does for whatever it mounts over. An error result is one: a failed run
-        /// leaves it active over an empty buffer, and skipping the pool there kept the previous
-        /// result's headings over a grid with no rows.
-        coordinator.isRebuildingColumns = true
-        let sameTableLiveWidths = TableViewCoordinator.liveWidthsForSameTable(
-            previous: previousColumnKey,
-            current: coordinator.columnLayoutKey,
-            liveWidths: liveColumnWidths
-        )
-        let storedLayout = coordinator.layoutDiscardingUnownedWidths(
-            coordinator.savedColumnLayout(binding: columnLayout),
-            tableRows: latestRows
-        )
-        coordinator.synchronizeUserSizedColumns(
-            with: storedLayout,
-            columns: latestRows.columns,
-            tableIdentityChanged: previousColumnKey != coordinator.columnLayoutKey
-        )
-        let reconciliationWidths = coordinator.liveWidthsForReconciliation(sameTableLiveWidths)
-        let savedLayout = coordinator.resolvedColumnLayout(
-            saved: storedLayout,
-            liveWidths: reconciliationWidths
-        )
-        reconcileColumnPool(
-            tableView: tableView,
-            coordinator: coordinator,
-            tableRows: latestRows,
-            columnComments: columnComments,
-            savedLayout: savedLayout
-        )
-        coordinator.isRebuildingColumns = false
-        coordinator.invalidateColumnIndexCache()
-        coordinator.frozenColumnCount = storedLayout?.frozenColumnCount ?? 0
-        coordinator.applyAccessoryWidthChanges(presentationChanges, tableRows: latestRows)
-
-        coordinator.updateValueFilterHeaderIndicators()
-
-        if needsFullReload || remappedValueFilters {
-            coordinator.selectionController.clear()
-            tableView.reloadData()
-            coordinator.restoreScrollAnchor()
-            coordinator.reselectRows(rowsKeptAcrossReload)
-            coordinator.startBackgroundPrewarm()
-        } else if displayFormatsChanged {
-            coordinator.reloadAfterDisplayFormatChange()
-        } else if highlightsChanged {
-            coordinator.repaintVisibleRowDecorations()
-        }
-    }
-
-    /// Puts back the selection the owner kept while this tab had no grid.
-    ///
-    /// Runs after `applyStructuralUpdate`, never before: that pass ends in
-    /// `selectionController.clear()` and `reloadData()`, and `reloadData()` drops the row selection
-    /// unconditionally even when the row count has not changed (measured). Anything restored ahead
-    /// of it is thrown away on the same update.
-    ///
-    /// Clamped, because the rows can have shrunk while the grid was gone and
-    /// `NSTableView.selectRowIndexes` is all-or-nothing on an out-of-range member (measured): an
-    /// unclamped push selects nothing at all rather than the rows that do still exist. A grid whose
-    /// rows have not landed yet is left for the next pass rather than clamped away to nothing.
-    private func restoreSelection(tableView: NSTableView, coordinator: TableViewCoordinator) {
-        guard !coordinator.hasRestoredSelection else { return }
-        let rowLimit = tableView.numberOfRows
-        guard rowLimit > 0 else { return }
-        coordinator.hasRestoredSelection = true
-
-        let restored = GridSelectionRestore.resolve(
-            storedRows: restoredRowSelection ?? selectedRowIndices,
-            storedCells: restoredCellSelection ?? .empty,
-            rowLimit: rowLimit,
-            columnLimit: coordinator.presentedColumnCount
-        )
-        /// Published even when nothing survived the clamp. Returning early here would leave the
-        /// shared channel holding the old out-of-range positions, and `syncSelection` would then
-        /// push them at a table view that refuses them whole and republish them anyway: an empty
-        /// grid under a status bar and a row menu that both still report a selection.
-        coordinator.selectRowsProgrammatically(IndexSet(restored.nativeRows), in: tableView)
-        if restored.cells.isEmpty {
-            coordinator.publishRowSelection(rowSelection: restored.publishedRows)
-        } else {
-            coordinator.selectionController.update(restored.cells)
-        }
-        /// `focusedColumn` indexes `tableColumns`, which also holds the row-number column, both
-        /// spacers and the unused pool slots, while a `GridCoord` carries a display position. Writing
-        /// one into the other lands the cell cursor on chrome, and Return, Tab and column navigation
-        /// then act on the wrong column or on none.
-        guard let keyTableView = tableView as? KeyHandlingTableView,
-              let active = restored.cells.activeCell,
-              let column = coordinator.tableColumnIndex(forDisplayPosition: active.displayColumn) else { return }
-        keyTableView.focusedRow = active.row
-        keyTableView.focusedColumn = column
-    }
-
-    /// Pushes a selection the app set from outside into the table view.
-    ///
-    /// The binding now carries `currentRowSelection()`, which spans every row a cell drag covers
-    /// while the table view holds only the anchor. Pushing that back would turn a cell rectangle
-    /// into a full row selection, and `DataGridRowView.drawCellSelectionFill` skips a selected row
-    /// because AppKit already fills it, so the rectangle would be painted as whole rows. A value
-    /// this coordinator published is therefore not a value to sync.
-    private func syncSelection(tableView: NSTableView, coordinator: TableViewCoordinator) {
-        guard selectedRowIndices != coordinator.lastPublishedRowSelection else { return }
-        let currentSelection = tableView.selectedRowIndexes
-        let targetSelection = IndexSet(selectedRowIndices)
-        guard currentSelection != targetSelection else { return }
-        /// The cell selection outranks the row selection in `publishRowSelection`, and this write is
-        /// programmatic, so the delegate will not clear it. Leaving it would let the old range win
-        /// and republish its rows, rejecting the row the owner just asked for: `RowEditingCoordinator`
-        /// selecting the row after a delete is exactly that case.
-        coordinator.selectionController.clear()
-        coordinator.selectRowsProgrammatically(targetSelection, in: tableView)
-        coordinator.publishRowSelection(rowSelection: Set(targetSelection))
-    }
-
-    private static func effectiveColumnComments(for tableRows: TableRows) -> [String: String] {
-        guard AppSettingsManager.shared.general.showObjectComments else { return [:] }
-        return tableRows.columnComments
-    }
-
-    private func reconcileColumnPool(
-        tableView: NSTableView,
-        coordinator: TableViewCoordinator,
-        tableRows: TableRows,
-        columnComments: [String: String],
-        savedLayout: ColumnLayoutState?
-    ) {
-        let visibilityChanged = coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: tableRows.columnTypes,
-            columnComments: columnComments,
-            savedLayout: savedLayout,
-            isEditable: isEditable,
-            hiddenColumnNames: configuration.hiddenColumns,
-            firstClickSortDirection: coordinator.firstClickSortDirection,
-            supportsColumnSort: configuration.supportsColumnSort,
-            supportsValueFilter: configuration.supportsValueFilter,
-            minimumWidths: configuration.columnMinimumWidths,
-            widthCalculator: { columnName, slot in
-                coordinator.automaticColumnWidth(
-                    for: columnName,
-                    columnIndex: slot,
-                    tableRows: tableRows
-                )
-            }
-        )
-        guard visibilityChanged else { return }
-        coordinator.columnGeometryDidChange()
-    }
-
-    private func syncSortState(tableView: NSTableView, coordinator: TableViewCoordinator) {
-        let schema = coordinator.identitySchema
-        let resolved = SortColumnResolver.reindexed(sortState, displayColumns: schema.columnNames)
-        coordinator.currentSortState = resolved
-        guard let header = tableView.headerView as? SortableHeaderView else { return }
-        header.applySortState(resolved, schema: schema)
-    }
-
-    // MARK: - Column Layout Helpers
-
-    @MainActor
-    static func makeRowNumberColumn() -> NSTableColumn {
-        let column = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        column.title = "#"
-        column.isEditable = false
-        column.resizingMask = []
-        sizeRowNumberColumn(column, forMaxRowNumber: 1)
-        let defaultHeaderFont = column.headerCell.font
-        let headerCell = SortableHeaderCell(textCell: "#")
-        headerCell.font = defaultHeaderFont
-        headerCell.alignment = .right
-        headerCell.supportsValueFilter = false
-        headerCell.setAccessibilityLabel(String(localized: "Row number"))
-        column.headerCell = headerCell
-        return column
-    }
-
-    @MainActor
-    /// The column is pinned to one width, so the interval has to be opened before the width can be
-    /// assigned through it.
-    ///
-    /// Raising `minWidth` past the current width does move `width` with it, but `NSTableView` keeps
-    /// its cumulative column geometry at the old value and posts no `columnDidResizeNotification`,
-    /// and the assignment that follows then has nothing left to change, so `rect(ofColumn:)` never
-    /// catches up. Measured on macOS 27: pinning 40 to 60 reported `width == 60` while the
-    /// row-number rect stayed 47pt wide and the next column's origin stayed at 57, and neither
-    /// `tile()` nor a display pass repaired it. Assigning the width while it genuinely moves is what
-    /// makes AppKit adopt the geometry and announce it.
-    static func sizeRowNumberColumn(_ column: NSTableColumn, forMaxRowNumber maxNumber: Int) {
-        let display = "\(max(maxNumber, 1))"
-        let font = ThemeEngine.shared.dataGridFonts.rowNumber
-        let textWidth = (display as NSString).size(withAttributes: [.font: font]).width
-        let measured = ceil(textWidth)
-            + 2 * DataGridMetrics.cellHorizontalInset
-            + DataGridMetrics.rowNumberHeaderPadding
-        let columnWidth = max(DataGridMetrics.rowNumberColumnMinWidth, measured)
-        guard column.width != columnWidth
-            || column.minWidth != columnWidth
-            || column.maxWidth != columnWidth else { return }
-        column.minWidth = min(column.minWidth, columnWidth)
-        column.maxWidth = max(column.maxWidth, columnWidth)
-        column.width = columnWidth
-        column.minWidth = columnWidth
-        column.maxWidth = columnWidth
-    }
-
-    /// The row-number strip that holds the viewport's leading edge. See `DataGridRowGutterView` for why
-    /// this is the mechanism and why the `__rowNumber__` column stays attached underneath it.
-    ///
-    /// Its heading is not a view of its own: `SortableHeaderView` draws it, because nothing but the
-    /// header view's own drawing can match the headings beside it.
-    static func installRowGutter(
-        scrollView: NSScrollView,
-        tableView: KeyHandlingTableView,
-        coordinator: TableViewCoordinator
-    ) {
-        /// The strip is document-tall, and nothing between it and the window frame clips it on its
-        /// own: measured on macOS 27, AppKit reparents a floating subview into a
-        /// `_NSScrollViewFloatingSubviewsContainerView` whose `clipsToBounds` is false, and
-        /// `NSScrollView`'s is false too, which is `NSView`'s documented default for the macOS 14
-        /// SDK. So the strip painted its row numbers and its column separator over whatever the
-        /// window stacked above the grid, every one of which is an earlier sibling and therefore
-        /// underneath it: the find bar, the filter panel, the key-pattern search bar, the result tab
-        /// bar and the banners. The scroll view is the view this code owns, so it is where the clip
-        /// belongs; clipping the container instead would reach into a view AppKit owns and would
-        /// stop working the day AppKit reparents somewhere else.
-        scrollView.clipsToBounds = true
-
-        let gutter = DataGridRowGutterView(frame: .zero)
-        gutter.coordinator = coordinator
-        tableView.addSubview(gutter)
-        scrollView.addFloatingSubview(gutter, for: .horizontal)
-
-        coordinator.rowGutter = gutter
-        gutter.observeTableGeometry()
-        coordinator.synchronizeRowGutter()
-    }
-
-    private func installSelectionOverlay(tableView: KeyHandlingTableView, coordinator: TableViewCoordinator) {
-        let overlay = GridSelectionOverlay(frame: tableView.bounds)
-        overlay.tableView = tableView
-        overlay.coordinator = coordinator
-        tableView.addSubview(overlay)
-        coordinator.selectionController.tableView = tableView
-        coordinator.selectionController.overlay = overlay
-        coordinator.selectionController.coordinator = coordinator
-        tableView.selectionOverlay = overlay
-    }
-
-    static func dataColumnIndex(
-        for tableColumnIndex: Int,
-        in tableView: NSTableView,
-        schema: ColumnIdentitySchema
-    ) -> Int? {
-        guard tableColumnIndex >= 0, tableColumnIndex < tableView.tableColumns.count else { return nil }
-        let identifier = tableView.tableColumns[tableColumnIndex].identifier
-        return schema.dataIndex(from: identifier)
-    }
-
-    static func dismantleNSView(_ nsView: NSScrollView, coordinator: TableViewCoordinator) {
-        coordinator.overlayEditor?.dismiss(commit: true)
-        /// The detached editor commits through this coordinator, and a mount is built fresh per tab
-        /// switch and per results-mode toggle, so a window left open past one writes nothing.
-        coordinator.dismissPoppedOutCellEditor()
-        coordinator.recordScrollAnchor()
-        coordinator.captureSelectionForTeardown()
-        coordinator.selectionSummaryTracker.cancel()
-        coordinator.selectionSummaryTracker.attach(nil)
-        coordinator.flushPendingColumnLayoutPersistence()
-        /// The mount's own registrations, taken off with it. `NotificationCenter` retains a block
-        /// observer's closure and a coordinator is built fresh per mount, so anything left here is
-        /// never fired again and never reclaimed: three scroll observers and the accessibility
-        /// activation observer per tab switch and per result-mode toggle, for the life of the
-        /// process. `releaseData()` already did this, but it only runs on session teardown.
-        coordinator.detachScrollObservers()
-        coordinator.detachAccessibilityActivationObserver()
-        coordinator.rowGutter?.detachTableGeometryObserver()
-        coordinator.settingsCancellable = nil
-        coordinator.themeCancellable = nil
-    }
-
-    func makeCoordinator() -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: changeManager,
-            isEditable: isEditable,
-            selectedRowIndices: $selectedRowIndices,
-            delegate: delegate,
-            layoutPersister: layoutPersister ?? FileColumnLayoutPersister.shared,
-            themeScope: themeScope
-        )
-        /// The cell selection's half of the row selection. Every mutator funnels through
-        /// `GridSelectionController.update(_:)`, so this is the one hook that sees a drag widen.
-        coordinator.selectionController.onSelectionChange = { [weak coordinator] _ in
-            coordinator?.publishRowSelection()
-            coordinator?.selectionSummaryTracker.selectionDidChange()
-        }
-        coordinator.selectionSummaryTracker.attach(selectionSummary)
-        coordinator.onSelectionTeardown = onSelectionTeardown
-        let columnLayoutBinding = $columnLayout
-        coordinator.onColumnLayoutDidChange = { layout in
-            if columnLayoutBinding.wrappedValue != layout {
-                columnLayoutBinding.wrappedValue = layout
-            }
-        }
-        return coordinator
-    }
-}
-
-
-// MARK: - Preview
-
-private let previewTableRowsForDataGrid = TableRows.from(
-    queryRows: [
-        ["1", "John", "john@example.com"],
-        ["2", "Jane", nil],
-        ["3", "Bob", "bob@example.com"],
-    ],
-    columns: ["id", "name", "email"],
-    columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: 3)
-)
-
-#Preview {
-    DataGridView(
-        tableRowsProvider: { previewTableRowsForDataGrid },
-        changeManager: AnyChangeManager(DataChangeManager()),
-        isEditable: true,
-        selectedRowIndices: .constant([]),
-        sortState: .constant(SortState()),
-        columnLayout: .constant(ColumnLayoutState())
-    )
-    .frame(width: 600, height: 400)
-}
diff --git a/apple/TablePro/Views/Results/DataGridViewDelegate.swift b/apple/TablePro/Views/Results/DataGridViewDelegate.swift
deleted file mode 100644
index dfbf365dba..0000000000
--- a/apple/TablePro/Views/Results/DataGridViewDelegate.swift
+++ /dev/null
@@ -1,128 +0,0 @@
-//
-//  DataGridViewDelegate.swift
-//  TablePro
-//
-//  Delegate protocol for DataGridView, replacing closure-based callbacks.
-//
-
-import AppKit
-
-@MainActor
-protocol DataGridViewDelegate: AnyObject {
-    func dataGridDidEditCell(row: Int, column: Int, newValue: String?)
-    func dataGridDeleteRows(_ indices: Set<Int>)
-    func dataGridCopyRows(_ indices: Set<Int>)
-    func dataGridPasteRows()
-    func dataGridCanPasteRows() -> Bool
-    func dataGridUndo()
-    func dataGridRedo()
-    func dataGridAddRow()
-    func dataGridMoveRow(from source: Int, to destination: Int)
-    func dataGridSortStateChanged(_ state: SortState)
-    func dataGridConfirmDisplayOrderChange(then apply: @escaping () -> Void)
-    func dataGridFilterColumn(_ columnName: String)
-    func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo, intent: ReferenceOpenIntent)
-    func dataGridShowRowAsJSON()
-    func dataGridDuplicateRow()
-    func dataGridExportResults()
-    func dataGridClearResults()
-    func dataGridCanClearResults() -> Bool
-    func dataGridHideColumn(_ columnName: String)
-    func dataGridShowAllColumns()
-    func dataGridColumnStructureMenuItems(forColumn dataColumnIndex: Int) -> [NSMenuItem]
-    func dataGridRowStructureMenuItems(forRow displayRow: Int) -> [NSMenuItem]
-    func dataGridDocumentMenuItems(forRow displayRow: Int) -> [NSMenuItem]
-    func dataGridHighlightMenuItem(forRow displayRow: Int, dataColumn: Int) -> NSMenuItem?
-    func dataGridFilterMenuItem(forRow displayRow: Int, dataColumn: Int) -> NSMenuItem?
-    func dataGridHighlightValuesMenuItem(forColumn dataColumnIndex: Int) -> NSMenuItem?
-    func dataGridVisualState(forRow row: Int) -> RowVisualState?
-    func dataGridRowView(for tableView: NSTableView, row: Int, coordinator: TableViewCoordinator) -> NSTableRowView?
-    func dataGridEmptySpaceMenu() -> NSMenu?
-    func dataGridDidInsertRows(at indices: IndexSet)
-    func dataGridDidRemoveRows(at indices: IndexSet)
-    func dataGridDidReplaceAllRows()
-    func dataGridAttach(tableViewCoordinator: TableViewCoordinator)
-    func dataGridDisplayOrderChanged()
-    func dataGridDisplayFormatChanged()
-    /// A cell editor or viewer closed. Told on the turn after, so an editor that closed with a
-    /// commit has recorded its edit, which it does after it removes itself.
-    func dataGridDidCloseCellOverlay()
-    /// The menu this particular cell should offer, when the list depends on the row rather than
-    /// only on the column.
-    ///
-    /// `DataGridConfiguration.customDropdownOptions` is keyed by column alone, which cannot express
-    /// a foreign key's Ref Columns: the list is the columns of whatever table that row's Ref Table
-    /// names. Returning nil falls back to that dictionary.
-    func dataGridMenuOptions(forRow row: Int, columnIndex: Int) -> [GridMenuOption]?
-    /// A checkbox cell's state, or nil when that row offers no checkbox.
-    func dataGridCheckboxState(row: Int, column: Int) -> Bool?
-    func dataGridSetCheckbox(_ isOn: Bool, rows: IndexSet, column: Int)
-    /// What an assistive client reads for a cell in place of its drawn text, or nil to read the text.
-    func dataGridAccessibilityText(row displayRow: Int, column: Int) -> String?
-    /// A status hue for a value cell's text, or nil for the grid text. A selection or find match still
-    /// draws its own text color over it.
-    func dataGridTextTone(row displayRow: Int, column: Int) -> NSColor?
-    /// Nil lets the grid derive the rules from its column types and display formats.
-    func dataGridSummaryColumnPolicy() -> SelectionSummaryColumnPolicy?
-    /// True when the window ran its own Set Cells to Value over these cells, so the grid's items and the window's do
-    /// the same thing.
-    func dataGridSetCellsToValue(_ targets: [SetValueTarget]) -> Bool
-    /// Runs the cell edits of one command, so an owner that writes each edit through can write them once.
-    func dataGridBatchEdits(actionName: String, _ edits: () -> Void)
-    /// Loads the values a page left on the server. The completion is true once every one arrived.
-    func dataGridLoadUnloadedValues(rowIDs: [RowID], columns: IndexSet?, completion: @escaping @MainActor (Bool) -> Void)
-}
-
-extension DataGridViewDelegate {
-    func dataGridDisplayOrderChanged() {}
-    func dataGridDisplayFormatChanged() {}
-    func dataGridDidCloseCellOverlay() {}
-    func dataGridMenuOptions(forRow row: Int, columnIndex: Int) -> [GridMenuOption]? { nil }
-    func dataGridCheckboxState(row: Int, column: Int) -> Bool? { nil }
-    func dataGridSetCheckbox(_ isOn: Bool, rows: IndexSet, column: Int) {}
-    func dataGridAccessibilityText(row displayRow: Int, column: Int) -> String? { nil }
-    func dataGridTextTone(row displayRow: Int, column: Int) -> NSColor? { nil }
-    func dataGridSummaryColumnPolicy() -> SelectionSummaryColumnPolicy? { nil }
-    func dataGridSetCellsToValue(_ targets: [SetValueTarget]) -> Bool { false }
-    func dataGridBatchEdits(actionName: String, _ edits: () -> Void) { edits() }
-    func dataGridLoadUnloadedValues(
-        rowIDs: [RowID],
-        columns: IndexSet?,
-        completion: @escaping @MainActor (Bool) -> Void
-    ) {
-        completion(false)
-    }
-    func dataGridDidEditCell(row: Int, column: Int, newValue: String?) {}
-    func dataGridDeleteRows(_ indices: Set<Int>) {}
-    func dataGridCopyRows(_ indices: Set<Int>) {}
-    func dataGridPasteRows() {}
-    func dataGridCanPasteRows() -> Bool { false }
-    func dataGridUndo() {}
-    func dataGridRedo() {}
-    func dataGridAddRow() {}
-    func dataGridMoveRow(from source: Int, to destination: Int) {}
-    func dataGridSortStateChanged(_ state: SortState) {}
-    func dataGridConfirmDisplayOrderChange(then apply: @escaping () -> Void) { apply() }
-    func dataGridFilterColumn(_ columnName: String) {}
-    func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo, intent: ReferenceOpenIntent) {}
-    func dataGridShowRowAsJSON() {}
-    func dataGridDuplicateRow() {}
-    func dataGridExportResults() {}
-    func dataGridClearResults() {}
-    func dataGridCanClearResults() -> Bool { false }
-    func dataGridHideColumn(_ columnName: String) {}
-    func dataGridShowAllColumns() {}
-    func dataGridColumnStructureMenuItems(forColumn dataColumnIndex: Int) -> [NSMenuItem] { [] }
-    func dataGridRowStructureMenuItems(forRow displayRow: Int) -> [NSMenuItem] { [] }
-    func dataGridDocumentMenuItems(forRow displayRow: Int) -> [NSMenuItem] { [] }
-    func dataGridHighlightMenuItem(forRow displayRow: Int, dataColumn: Int) -> NSMenuItem? { nil }
-    func dataGridFilterMenuItem(forRow displayRow: Int, dataColumn: Int) -> NSMenuItem? { nil }
-    func dataGridHighlightValuesMenuItem(forColumn dataColumnIndex: Int) -> NSMenuItem? { nil }
-    func dataGridVisualState(forRow row: Int) -> RowVisualState? { nil }
-    func dataGridRowView(for tableView: NSTableView, row: Int, coordinator: TableViewCoordinator) -> NSTableRowView? { nil }
-    func dataGridEmptySpaceMenu() -> NSMenu? { nil }
-    func dataGridDidInsertRows(at indices: IndexSet) {}
-    func dataGridDidRemoveRows(at indices: IndexSet) {}
-    func dataGridDidReplaceAllRows() {}
-    func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {}
-}
diff --git a/apple/TablePro/Views/Results/DisplayRowMapping.swift b/apple/TablePro/Views/Results/DisplayRowMapping.swift
deleted file mode 100644
index 1001717462..0000000000
--- a/apple/TablePro/Views/Results/DisplayRowMapping.swift
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-//  DisplayRowMapping.swift
-//  TablePro
-//
-
-import Foundation
-
-enum DisplayRowMapping {
-    static func rowIndex(forDisplay displayIndex: Int, displayIDs: [RowID]?, in tableRows: TableRows) -> Int? {
-        guard let displayIDs else {
-            guard displayIndex >= 0, displayIndex < tableRows.count else { return nil }
-            return displayIndex
-        }
-        guard displayIndex >= 0, displayIndex < displayIDs.count else { return nil }
-        return tableRows.index(of: displayIDs[displayIndex])
-    }
-
-    static func row(forDisplay displayIndex: Int, displayIDs: [RowID]?, in tableRows: TableRows) -> Row? {
-        guard let index = rowIndex(forDisplay: displayIndex, displayIDs: displayIDs, in: tableRows) else { return nil }
-        return tableRows.rows[index]
-    }
-
-    /// Where a row sits on screen. Nil when a value filter is hiding it.
-    static func displayIndex(forRowID id: RowID, displayIDs: [RowID]?, in tableRows: TableRows) -> Int? {
-        guard let displayIDs else { return tableRows.index(of: id) }
-        return displayIDs.firstIndex(of: id)
-    }
-}
diff --git a/apple/TablePro/Views/Results/EnumMenuPicker.swift b/apple/TablePro/Views/Results/EnumMenuPicker.swift
index 5cb0d2cf42..f1ff899c77 100644
--- a/apple/TablePro/Views/Results/EnumMenuPicker.swift
+++ b/apple/TablePro/Views/Results/EnumMenuPicker.swift
@@ -75,6 +75,17 @@ enum EnumMenuPicker {
         currentCsv: String?,
         onCommit: @escaping (String) -> Void
     ) {
+        let menu = makeSetMenu(allowedValues: allowedValues, currentCsv: currentCsv, onCommit: onCommit)
+        let anchor = NSPoint(x: rect.minX, y: rect.maxY)
+        menu.popUp(positioning: nil, at: anchor, in: view)
+    }
+
+    // menuDidClose runs before the chosen item's action (interaction 1), so each pick commits from its own action.
+    static func makeSetMenu(
+        allowedValues: [String],
+        currentCsv: String?,
+        onCommit: @escaping (String) -> Void
+    ) -> NSMenu {
         let selected = Set(
             (currentCsv ?? "")
                 .split(separator: ",")
@@ -84,39 +95,28 @@ enum EnumMenuPicker {
 
         let menu = NSMenu()
         menu.autoenablesItems = false
-
-        let coordinator = SetSelectionCoordinator(
-            allowedValues: allowedValues,
-            initialSelection: selected,
-            onCommit: onCommit
-        )
+        let selection = SetSelection(allowedValues: allowedValues, selected: selected, onCommit: onCommit)
 
         for value in allowedValues {
-            let item = NSMenuItem(title: value, action: nil, keyEquivalent: "")
-            item.target = coordinator
-            item.action = #selector(SetSelectionCoordinator.toggle(_:))
-            item.representedObject = value
+            let item = NSMenuItem(title: value, action: #selector(ItemTarget.toggle(_:)), keyEquivalent: "")
+            item.target = ItemTarget.shared
+            item.representedObject = SetItemPayload(value: value, selection: selection)
             item.state = selected.contains(value) ? .on : .off
             menu.addItem(item)
         }
 
-        for current in selected where !allowedValues.contains(current) {
+        for current in selected.sorted() where !allowedValues.contains(current) {
             menu.addItem(.separator())
-            let driftItem = NSMenuItem(title: current, action: nil, keyEquivalent: "")
-            driftItem.target = coordinator
-            driftItem.action = #selector(SetSelectionCoordinator.toggle(_:))
-            driftItem.representedObject = current
+            let driftItem = NSMenuItem(title: current, action: #selector(ItemTarget.toggle(_:)), keyEquivalent: "")
+            driftItem.target = ItemTarget.shared
+            driftItem.representedObject = SetItemPayload(value: current, selection: selection)
             driftItem.state = .on
             driftItem.setInformativeImage(NSImage(systemSymbolName: "exclamationmark.triangle.fill",
                                                   accessibilityDescription: nil))
             driftItem.toolTip = String(localized: "Value is not in the declared set.")
             menu.addItem(driftItem)
         }
-
-        menu.delegate = coordinator
-
-        let anchor = NSPoint(x: rect.minX, y: rect.maxY)
-        menu.popUp(positioning: nil, at: anchor, in: view)
+        return menu
     }
 }
 
@@ -133,38 +133,39 @@ private final class ItemTarget: NSObject {
         guard let payload = sender.representedObject as? ItemPayload else { return }
         payload.onCommit(payload.value)
     }
+
+    @objc func toggle(_ sender: NSMenuItem) {
+        guard let payload = sender.representedObject as? SetItemPayload else { return }
+        payload.selection.toggle(payload.value)
+    }
+}
+
+private struct SetItemPayload {
+    let value: String
+    let selection: SetSelection
 }
 
+// The declared order first, then any value outside the declaration, so the stored list reads the same each time.
 @MainActor
-private final class SetSelectionCoordinator: NSObject, NSMenuDelegate {
+private final class SetSelection {
     private let allowedValues: [String]
-    private var selection: Set<String>
-    private let initialSelection: Set<String>
+    private let initial: Set<String>
     private let onCommit: (String) -> Void
-    private var committed = false
 
-    init(allowedValues: [String], initialSelection: Set<String>, onCommit: @escaping (String) -> Void) {
+    init(allowedValues: [String], selected: Set<String>, onCommit: @escaping (String) -> Void) {
         self.allowedValues = allowedValues
-        self.selection = initialSelection
-        self.initialSelection = initialSelection
+        self.initial = selected
         self.onCommit = onCommit
     }
 
-    @objc func toggle(_ sender: NSMenuItem) {
-        guard let value = sender.representedObject as? String else { return }
+    func toggle(_ value: String) {
+        var selection = initial
         if selection.contains(value) {
             selection.remove(value)
-            sender.state = .off
         } else {
             selection.insert(value)
-            sender.state = .on
         }
-        committed = true
-    }
-
-    func menuDidClose(_ menu: NSMenu) {
-        guard committed, selection != initialSelection else { return }
-        let ordered = allowedValues.filter(selection.contains)
+        let ordered = allowedValues.filter { selection.contains($0) }
             + selection.filter { !allowedValues.contains($0) }.sorted()
         onCommit(ordered.joined(separator: ","))
     }
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+CellCommit.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+CellCommit.swift
deleted file mode 100644
index 07ced0d4bb..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+CellCommit.swift
+++ /dev/null
@@ -1,227 +0,0 @@
-//
-//  DataGridView+CellCommit.swift
-//  TablePro
-//
-
-import AppKit
-import os
-import TableProPluginKit
-
-private let cellCommitLogger = Logger(subsystem: "com.TablePro", category: "DataGrid")
-
-extension TableViewCoordinator {
-    /// Every caller hands over text a person entered, so it is read for the column it lands in:
-    /// an emptied date, number or boolean is NULL, an emptied text cell is `''`. A NOT NULL column
-    /// that can hold neither keeps its value, and the beep says the edit was refused.
-    func commitCellEdit(row: Int, columnIndex: Int, newValue: String?) {
-        if !commitEnteredText(newValue, row: row, columnIndex: columnIndex) {
-            NSSound.beep()
-        }
-    }
-
-    /// False when the column holds neither the text nor NULL in its place, and nothing was staged.
-    @discardableResult
-    func commitEnteredText(_ text: String?, row: Int, columnIndex: Int) -> Bool {
-        guard let entry = enteredCell(text, columnIndex: columnIndex) else { return false }
-        commitTypedCellEdit(row: row, columnIndex: columnIndex, newValue: entry.value, isExpression: entry.isExpression)
-        return true
-    }
-
-    /// A function the engine runs on this kind of column stages as SQL; anything else is read for the column as
-    /// `TableRows.enteredValue` reads it.
-    func enteredCell(_ text: String?, columnIndex: Int) -> (value: PluginCellValue, isExpression: Bool)? {
-        let tableRows = tableRowsProvider()
-        if let text, let databaseType,
-           let expression = CellEntry.typed(
-               text,
-               columnType: tableRows.editingColumnType(at: columnIndex),
-               databaseType: databaseType,
-               writer: changeManager.cellWriterSupport
-           ) {
-            return expression
-        }
-        return tableRows.enteredValue(text, forColumn: columnIndex).map { (value: $0, isExpression: false) }
-    }
-
-    func commitTypedCellEdit(
-        row: Int,
-        columnIndex: Int,
-        newValue typedNewValue: PluginCellValue,
-        isExpression: Bool = false
-    ) {
-        guard recordCellEdit(
-            row: row, columnIndex: columnIndex, newValue: typedNewValue, isExpression: isExpression
-        ) != nil else { return }
-        repaintEditedCell(row: row, columnIndex: columnIndex)
-    }
-
-    /// Takes the field out of the row, for an engine that tells a missing field from NULL.
-    func removeField(row: Int, columnIndex: Int) {
-        guard supportsFieldRemoval,
-              recordCellEdit(row: row, columnIndex: columnIndex, newValue: .null, removesField: true) != nil
-        else { return }
-        repaintEditedCell(row: row, columnIndex: columnIndex)
-    }
-
-    func repaintEditedCell(row: Int, columnIndex: Int) {
-        invalidateDisplayCache()
-        updateVisualIndex(forDisplayRow: row)
-
-        invalidateRowDecoration(displayRow: row)
-        guard let tableColumnIndex = tableColumnIndex(for: columnIndex) else { return }
-        redrawCells(rows: IndexSet(integer: row), tableColumnIndexes: IndexSet(integer: tableColumnIndex))
-    }
-
-    /// Commits into the record an editor was opened for rather than into whatever now sits at the
-    /// display position it was opened from.
-    ///
-    /// A detached editor outlives a sort, a value filter and a display-format change, none of which
-    /// close it, and a display row names a different record after any of them.
-    func commitCellEdit(rowID: RowID, columnIndex: Int, newValue: String?) {
-        guard let entry = enteredCell(newValue, columnIndex: columnIndex) else {
-            NSSound.beep()
-            return
-        }
-        commitTypedCellEdit(
-            rowID: rowID, columnIndex: columnIndex, newValue: entry.value, isExpression: entry.isExpression
-        )
-    }
-
-    func commitTypedCellEdit(
-        rowID: RowID,
-        columnIndex: Int,
-        newValue typedNewValue: PluginCellValue,
-        isExpression: Bool = false
-    ) {
-        guard recordCellEdit(
-            rowID: rowID, columnIndex: columnIndex, newValue: typedNewValue, isExpression: isExpression
-        ) != nil else { return }
-
-        invalidateDisplayCache()
-        /// A record the value filter is hiding is written and not repainted, because it has no row
-        /// on screen to repaint.
-        guard let displayRow = DisplayRowMapping.displayIndex(
-            forRowID: rowID,
-            displayIDs: displayIDs,
-            in: tableRowsProvider()
-        ) else { return }
-        updateVisualIndex(forDisplayRow: displayRow)
-        invalidateRowDecoration(displayRow: displayRow)
-        guard let tableColumnIndex = tableColumnIndex(for: columnIndex) else { return }
-        redrawCells(rows: IndexSet(integer: displayRow), tableColumnIndexes: IndexSet(integer: tableColumnIndex))
-    }
-
-    @discardableResult
-    func recordCellEdit(
-        rowID: RowID,
-        columnIndex: Int,
-        newValue typedNewValue: PluginCellValue,
-        isExpression: Bool = false
-    ) -> Delta? {
-        let tableRows = tableRowsProvider()
-        guard let storageRow = tableRows.index(of: rowID), storageRow < tableRows.rows.count else { return nil }
-        return recordCellEdit(
-            in: tableRows.rows[storageRow],
-            columnIndex: columnIndex,
-            newValue: typedNewValue,
-            removesField: false,
-            isExpression: isExpression,
-            displayRow: DisplayRowMapping.displayIndex(forRowID: rowID, displayIDs: displayIDs, in: tableRows)
-        )
-    }
-
-    @discardableResult
-    func recordCellEdit(
-        row: Int,
-        columnIndex: Int,
-        newValue typedNewValue: PluginCellValue,
-        removesField: Bool = false,
-        isExpression: Bool = false
-    ) -> Delta? {
-        cellCommitLogger.debug("recordCellEdit(row: \(row, privacy: .public), columnIndex: \(columnIndex, privacy: .public)) isCommitting=\(self.isCommittingCellEdit, privacy: .public) delegate=\(self.delegate == nil ? "nil" : "present", privacy: .public)")
-        guard !isCommittingCellEdit else { return nil }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0 && columnIndex < tableRows.columns.count else { return nil }
-        /// Before the rows are touched, not after. The change manager refuses a server-owned column
-        /// on its own, and editing here first would paint a value into the grid that no statement
-        /// will ever carry.
-        guard isColumnWritable(tableRows.columns[columnIndex]) else { return nil }
-        guard let displayRowValues = displayRow(at: row) else { return nil }
-        return recordCellEdit(
-            in: displayRowValues,
-            columnIndex: columnIndex,
-            newValue: typedNewValue,
-            removesField: removesField,
-            isExpression: isExpression,
-            displayRow: row
-        )
-    }
-
-    /// The one place a cell edit becomes a pending change and a new value in the shared row buffer.
-    /// `displayRow` is only what the delegate is told; the record and the write are by identity.
-    ///
-    /// A value written into a missing field brings the field back, and `removesField` takes it out,
-    /// so NULL over a missing field is an edit even though both read `.null`. An expression over text that
-    /// reads the same is an edit too, and so is the text over the expression.
-    @discardableResult
-    private func recordCellEdit(
-        in row: Row,
-        columnIndex: Int,
-        newValue typedNewValue: PluginCellValue,
-        removesField: Bool,
-        isExpression: Bool,
-        displayRow: Int?
-    ) -> Delta? {
-        guard !isCommittingCellEdit else { return nil }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return nil }
-        guard isColumnWritable(tableRows.columns[columnIndex]) else { return nil }
-        guard columnIndex < row.values.count else { return nil }
-        // Its `.null` stands for a value still on the server, which no edit may replace unread.
-        guard row.unloadedByteCount(columnIndex) == nil else {
-            NSSound.beep()
-            return nil
-        }
-        let oldValue = row.values[columnIndex]
-        let absence = FieldAbsence(
-            wasAbsent: row.isAbsent(columnIndex),
-            isAbsent: removesField,
-            originalRow: row.absentColumns
-        )
-        let wasExpression = changeManager.isExpression(rowID: row.id, columnIndex: columnIndex)
-        guard oldValue != typedNewValue || absence.wasAbsent != absence.isAbsent || wasExpression != isExpression
-        else {
-            cellCommitLogger.debug("recordCellEdit - value unchanged, guard returned")
-            return nil
-        }
-
-        isCommittingCellEdit = true
-        defer { isCommittingCellEdit = false }
-
-        let rowID = row.id
-        changeManager.recordCellChange(
-            rowID: rowID,
-            columnIndex: columnIndex,
-            columnName: tableRows.columns[columnIndex],
-            oldValue: oldValue,
-            newValue: typedNewValue,
-            originalRow: Array(row.values),
-            absence: absence,
-            isExpression: isExpression
-        )
-
-        var delta: Delta = .none
-        if let storageRow = tableRows.index(of: rowID) {
-            delta = tableRowsMutator { tableRows in
-                tableRows.edit(row: storageRow, column: columnIndex, value: typedNewValue, isAbsent: removesField)
-            }
-        }
-        selectionSummaryTracker.dataDidChange()
-        /// A record the display order is hiding has no row to report, and every delegate reads that
-        /// argument as a display position.
-        if let displayRow {
-            delegate?.dataGridDidEditCell(row: displayRow, column: columnIndex, newValue: typedNewValue.asText)
-        }
-        return delta
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+CellFilterMenu.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+CellFilterMenu.swift
deleted file mode 100644
index 5bab8e1e1b..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+CellFilterMenu.swift
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-//  DataGridView+CellFilterMenu.swift
-//  TablePro
-//
-
-import AppKit
-
-internal extension TableViewCoordinator {
-    func cellFilterMenuItem(
-        forRow displayIndex: Int,
-        dataColumn: Int,
-        apply: @escaping (TableFilter) -> Void
-    ) -> NSMenuItem? {
-        let tableRows = tableRowsProvider()
-        guard let row = displayRow(at: displayIndex, in: tableRows) else { return nil }
-        let rowState = visualState(for: displayIndex)
-        guard !rowState.isInserted, !rowState.isModified(columnIndex: dataColumn) else { return nil }
-        let columns = tableRows.columns
-        guard columns.indices.contains(dataColumn), dataColumn < row.values.count else { return nil }
-
-        return CellFilterMenuBuilder.menuItem(
-            columnName: columns[dataColumn],
-            columnType: filterMenuColumnType(forDataColumn: dataColumn, in: tableRows),
-            value: row.values[dataColumn],
-            family: databaseType.map(SQLTypeFamily.of),
-            apply: apply
-        )
-    }
-
-    func filterMenuColumnType(forDataColumn dataColumn: Int, in tableRows: TableRows) -> ColumnType? {
-        let columnTypes = filterMenuColumnTypes ?? tableRows.columnTypes
-        guard columnTypes.indices.contains(dataColumn) else { return nil }
-        return columnTypes[dataColumn]
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+CellPaste.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+CellPaste.swift
deleted file mode 100644
index 4003e0b5a4..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+CellPaste.swift
+++ /dev/null
@@ -1,224 +0,0 @@
-//
-//  DataGridView+CellPaste.swift
-//  TablePro
-//
-
-import AppKit
-import TableProPluginKit
-
-extension TableViewCoordinator {
-    /// Splitting the clipboard into a cell block costs a pass over the whole string, and menu
-    /// validation asks for it on every Command+V and every time the Edit menu opens. A SQL dump can
-    /// be millions of characters on one line, so anything past this is not treated as a cell block
-    /// and goes to row paste instead. The cap applies to the check and to the paste alike, so the
-    /// menu item never promises something the handler will refuse.
-    static let maxCellPasteLength = 1_000_000
-
-    /// Whether a paste would land in the focused cell rather than append rows. Answered without
-    /// mutating anything so menu validation can ask it.
-    func canPasteCellsFromClipboard(anchorRow: Int, anchorColumn: Int) -> Bool {
-        cellPasteBlock(anchorRow: anchorRow, anchorColumn: anchorColumn) != nil
-    }
-
-    /// Fills cells rightwards from the anchor, in the order they appear on screen.
-    ///
-    /// The walk is over display positions, not data indices. Adding to the anchor's data index
-    /// walked the result's own column order, so after a column reorder the second value landed in
-    /// whichever column happens to hold the next slot rather than the one beside it on screen, and a
-    /// hidden column could swallow a value with nothing shown for it.
-    func pasteCellsFromClipboard(anchorRow: Int, anchorColumn: Int) -> Bool {
-        guard let block = cellPasteBlock(anchorRow: anchorRow, anchorColumn: anchorColumn),
-              let anchorPosition = displayPosition(ofDataColumnIndex: anchorColumn) else {
-            return false
-        }
-
-        let maxRow = min(anchorRow + block.lines.count, cachedRowCount)
-        let maxCol = min(anchorPosition + block.width, presentedColumnCount)
-        guard anchorRow < maxRow, anchorPosition < maxCol else { return false }
-        let pastedColumns = IndexSet((anchorPosition..<maxCol).compactMap { dataColumnIndex(atDisplayPosition: $0) })
-        guard unloadedValuesAreLoaded(displayRows: anchorRow..<maxRow, columns: pastedColumns, retry: { [weak self] in
-            _ = self?.pasteCellsFromClipboard(anchorRow: anchorRow, anchorColumn: anchorColumn)
-        }) else { return true }
-
-        let undoManager = tableView?.window?.undoManager
-        undoManager?.beginUndoGrouping()
-
-        var refusedCell = false
-        batchEdits(actionName: String(localized: "Paste Cells")) {
-            for (gridRow, fields) in block.lines.enumerated() {
-                let targetRow = anchorRow + gridRow
-                guard targetRow < maxRow else { break }
-                guard !isRowDeleted(displayRow: targetRow) else { continue }
-
-                for (gridCol, field) in fields.enumerated() {
-                    let targetPosition = anchorPosition + gridCol
-                    guard targetPosition < maxCol else { break }
-                    guard let targetCol = dataColumnIndex(atDisplayPosition: targetPosition) else { continue }
-                    guard let entry = pastedEntry(
-                        field,
-                        of: block,
-                        isExpression: block.isExpression(line: gridRow, field: gridCol),
-                        columnIndex: targetCol
-                    ) else {
-                        refusedCell = true
-                        continue
-                    }
-                    commitTypedCellEdit(
-                        row: targetRow, columnIndex: targetCol, newValue: entry.value, isExpression: entry.isExpression
-                    )
-                }
-            }
-        }
-
-        // After the loop: each cell's own step names the open group "Edit Cell".
-        undoManager?.setActionName(String(localized: "Paste Cells"))
-        undoManager?.endUndoGrouping()
-        if refusedCell {
-            NSSound.beep()
-        }
-
-        tableView?.reloadData()
-        return true
-    }
-
-    /// A clipboard read as cells: the fields the grid's own copy carries, or the clipboard's text
-    /// split into lines and fields. Only the grid's copy can hold a NULL.
-    struct CellPasteBlock {
-        let lines: [[String?]]
-        let isGridCopy: Bool
-        /// Line index to the fields the grid's copy marked as staged SQL.
-        var expressionFields: [Int: Set<Int>] = [:]
-
-        /// The widest line, since an empty line holds one field and may come first.
-        var width: Int { lines.map(\.count).max() ?? 0 }
-
-        func isExpression(line: Int, field: Int) -> Bool {
-            expressionFields[line]?.contains(field) == true
-        }
-    }
-
-    /// Answered without mutating anything so menu validation can ask it.
-    func canPasteValueIntoSelectedCells() -> Bool {
-        selectionFill() != nil
-    }
-
-    /// One value on the clipboard goes into every cell of a multi-cell selection, the way a spreadsheet pastes it.
-    /// False for anything else, which keeps the anchor paste: a block, one selected cell, or no cell selection.
-    func pasteValueIntoSelectedCells() -> Bool {
-        guard let fill = selectionFill() else { return false }
-        guard unloadedValuesAreLoaded(targets: fill.targets, retry: { [weak self] in
-            _ = self?.pasteValueIntoSelectedCells()
-        }) else { return true }
-        let isExpression = fill.block.isExpression(line: 0, field: 0)
-        stageEntry(into: fill.targets, actionName: String(localized: "Paste Cells")) { columnIndex in
-            pastedEntry(fill.field, of: fill.block, isExpression: isExpression, columnIndex: columnIndex)
-        }
-        return true
-    }
-
-    private func selectionFill() -> (block: CellPasteBlock, field: String?, targets: [SetValueTarget])? {
-        guard !selectionController.selection.isEmpty,
-              let block = clipboardCellBlock(),
-              block.lines.count == 1,
-              let line = block.lines.first,
-              line.count == 1 else { return nil }
-        let targets = setValueTargets(clicked: nil)
-        guard targets.count > 1 else { return nil }
-        return (block: block, field: line[0], targets: targets)
-    }
-
-    /// The clipboard as a cell block, or nil when it belongs to the row-paste path instead.
-    ///
-    /// A clipboard holding one value fills the focused cell, which is what copying a cell and
-    /// pasting it into another cell has to mean. It used to be rejected here and fell through to
-    /// row paste, which appended a row and left the focused cell untouched. A block as wide as the
-    /// table is still whole rows and stays with row paste, and so is anything TablePro's own row
-    /// copy wrote, which carries its own pasteboard type.
-    private func cellPasteBlock(anchorRow: Int, anchorColumn: Int) -> CellPasteBlock? {
-        guard let block = clipboardCellBlock(), let firstLine = block.lines.first else { return nil }
-
-        /// Whole rows are routed away by the result's own column count, not the presented one.
-        /// `TSVRowParser` fills from data index 0 and knows nothing about which columns are on
-        /// screen, so handing it a block as wide as the *visible* run writes the fields into hidden
-        /// or wrong columns. A block that matches the visible width but not the result's stays on
-        /// the cell path, where every field is placed by display position. Row paste skips empty
-        /// lines, so they do not decide the shape.
-        let isSingleValue = block.lines.count == 1 && firstLine.count == 1
-        let dataColumnCount = tableRowsProvider().columns.count
-        let rowLines = block.lines.filter { $0 != [""] }
-        if !isSingleValue, dataColumnCount > 0, !rowLines.isEmpty,
-           rowLines.allSatisfy({ $0.count == dataColumnCount }) {
-            return nil
-        }
-
-        guard let anchorPosition = displayPosition(ofDataColumnIndex: anchorColumn) else { return nil }
-        let maxRow = min(anchorRow + block.lines.count, cachedRowCount)
-        let maxCol = min(anchorPosition + block.width, presentedColumnCount)
-        guard anchorRow < maxRow, anchorPosition < maxCol else { return nil }
-
-        return block
-    }
-
-    /// The clipboard's fields, before anything decides where they land.
-    private func clipboardCellBlock() -> CellPasteBlock? {
-        guard isEditable else { return nil }
-        if ClipboardService.shared.hasGridRows { return nil }
-        guard let text = ClipboardService.shared.readText(), !text.isEmpty else { return nil }
-        guard (text as NSString).length <= Self.maxCellPasteLength else { return nil }
-        return Self.gridCopiedBlock(matching: text)
-            ?? CellPasteBlock(lines: Self.pastedLines(text).map { $0.components(separatedBy: "\t") }, isGridCopy: false)
-    }
-
-    /// The fields of the grid's own copy, while the clipboard still holds the text it wrote. They are
-    /// taken as they are rather than split from the text, where a value with a tab or a line break
-    /// in it would become several fields and a NULL would read as the text `NULL`.
-    private static func gridCopiedBlock(matching text: String) -> CellPasteBlock? {
-        guard let copied = ClipboardService.shared.readGridCells(), copied.text == text else { return nil }
-        return CellPasteBlock(lines: copied.fields, isGridCopy: true, expressionFields: copied.expressionFields ?? [:])
-    }
-
-    /// What a pasted field stages in a column, or nil when the column holds neither it nor NULL in its place.
-    ///
-    /// The grid's copy says which fields were SQL, so a field it marked stages as SQL for the save to check against
-    /// this engine, and any other field is text however it reads: a stored `CURRENT_TIMESTAMP` is not promoted. Text
-    /// from another app is read the way a typed cell is.
-    private func pastedEntry(
-        _ field: String?,
-        of block: CellPasteBlock,
-        isExpression: Bool,
-        columnIndex: Int
-    ) -> StagedCellEntry? {
-        let tableRows = tableRowsProvider()
-        guard block.isGridCopy else {
-            let text = field.flatMap { Self.pastedText($0, columnType: tableRows.editingColumnType(at: columnIndex)) }
-            return enteredCell(text, columnIndex: columnIndex)
-        }
-        if isExpression, let field {
-            return (value: .text(field), isExpression: true)
-        }
-        return tableRows.enteredValue(field, forColumn: columnIndex).map { (value: $0, isExpression: false) }
-    }
-
-    /// Text from another app has no NULL of its own. A date, number or boolean cannot hold the
-    /// four letters `NULL`, so there they paste as NULL rather than the server's zero date or an
-    /// error; a text column keeps them.
-    static func pastedText(_ field: String, columnType: ColumnType?) -> String? {
-        guard field == "NULL", let columnType, !columnType.hasEmptyValue,
-              columnType.enumValues?.contains(field) != true else { return field }
-        return nil
-    }
-
-    /// An empty line inside the block is an empty value and keeps the rows below it in place.
-    /// Dropping it moved every later value up a row. Empty lines at the end are the line breaks a
-    /// spreadsheet ends its copy with, not rows.
-    ///
-    /// A `\r\n` copy is folded to `\n` first. Split as it is, every row kept a `\r` on its last field,
-    /// and split on both characters it read as an empty line between every two rows.
-    static func pastedLines(_ text: String) -> [String] {
-        var lines = text.replacingOccurrences(of: "\r\n", with: "\n").components(separatedBy: .newlines)
-        while lines.count > 1, lines.last?.isEmpty == true {
-            lines.removeLast()
-        }
-        return lines
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Checkbox.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Checkbox.swift
deleted file mode 100644
index 6a91eb8b07..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Checkbox.swift
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-//  DataGridView+Checkbox.swift
-//  TablePro
-//
-
-import AppKit
-
-extension TableViewCoordinator {
-    func presentsCheckboxCell(columnIndex: Int) -> Bool {
-        checkboxColumns.contains(columnIndex)
-    }
-
-    func checkboxMark(row: Int, columnIndex: Int) -> DataGridCheckboxMark? {
-        guard presentsCheckboxCell(columnIndex: columnIndex),
-              let isOn = delegate?.dataGridCheckboxState(row: row, column: columnIndex) else { return nil }
-        return isOn ? .checked : .unchecked
-    }
-
-    @discardableResult
-    func toggleCheckbox(row: Int, columnIndex: Int) -> Bool {
-        guard let mark = checkboxMark(row: row, columnIndex: columnIndex) else { return false }
-        delegate?.dataGridSetCheckbox(mark == .unchecked, rows: IndexSet(integer: row), column: columnIndex)
-        invalidateRowDecoration(displayRow: row)
-        return true
-    }
-
-    /// Space over a selection sets every selected checkbox the same way, the way a list of mail
-    /// messages marks them: on unless every one is already on.
-    func toggleCheckboxesForSelection() -> Bool {
-        guard let column = checkboxColumns.min(), let tableView else { return false }
-        /// A rectangular cell selection keeps the table view pinned to its anchor row, so the rows
-        /// the grid is showing as selected come from the cell selection when there is one.
-        let cellRows = selectionController.selection.affectedRows
-        let selected = cellRows.isEmpty ? IndexSet(tableView.selectedRowIndexes) : cellRows
-        let rows = selected.filter { checkboxMark(row: $0, columnIndex: column) != nil }
-        guard !rows.isEmpty else { return false }
-        let everyRowChecked = rows.allSatisfy { checkboxMark(row: $0, columnIndex: column) == .checked }
-        delegate?.dataGridSetCheckbox(!everyRowChecked, rows: IndexSet(rows), column: column)
-        for row in rows {
-            invalidateRowDecoration(displayRow: row)
-        }
-        return true
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Click.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Click.swift
deleted file mode 100644
index de9709c235..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Click.swift
+++ /dev/null
@@ -1,260 +0,0 @@
-//
-//  DataGridView+Click.swift
-//  TablePro
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-
-extension TableViewCoordinator {
-    // MARK: - Cell Interaction
-
-    /// Whether a cell is on screen for something to anchor to.
-    ///
-    /// A data cell is drawn rather than mounted, so the row being on screen is what answers this;
-    /// `view(atColumn:row:makeIfNecessary:)` is always nil now and every guard that still asked it
-    /// closed the editor or popover it was guarding (#2381).
-    func presentsCell(row: Int, tableColumnIndex: Int) -> Bool {
-        guard let tableView, row >= 0, row < tableView.numberOfRows else { return false }
-        guard presentsColumn(atTableColumnIndex: tableColumnIndex) else { return false }
-        return tableView.rowView(atRow: row, makeIfNecessary: false) != nil
-    }
-
-    func handleCellInteraction(row: Int, tableColumn: Int, columnIndex: Int, tableView: NSTableView) {
-        let retry: @MainActor () -> Void = { [weak self, weak tableView] in
-            guard let self, let tableView else { return }
-            self.handleCellInteraction(row: row, tableColumn: tableColumn, columnIndex: columnIndex, tableView: tableView)
-        }
-        guard unloadedValuesAreLoaded(displayRows: [row], columns: IndexSet(integer: columnIndex), retry: retry)
-        else { return }
-        guard let context = makeCellContext(row: row, columnIndex: columnIndex) else { return }
-        guard presentsCell(row: row, tableColumnIndex: tableColumn) else { return }
-
-        let mode = CellInteractionResolver().resolve(context)
-        switch mode {
-        case .blocked:
-            return
-        case .viewInline(let value):
-            showOverlayViewer(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex, value: value)
-        case .viewJson:
-            showJSONViewerPopover(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex)
-        case .viewBlob:
-            showBlobViewerPopover(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex)
-        case .viewPhpSerialized:
-            showPhpViewerPopover(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex)
-        case .viewBinaryValue(let format):
-            showBinaryValueViewerPopover(
-                tableView: tableView,
-                row: row,
-                column: tableColumn,
-                columnIndex: columnIndex,
-                format: format
-            )
-        case .viewVector, .editVector:
-            showVectorPopover(
-                tableView: tableView,
-                row: row,
-                column: tableColumn,
-                columnIndex: columnIndex,
-                isEditable: mode == .editVector && canStartInlineEdit(row: row, columnIndex: columnIndex)
-            )
-        case .viewSvg, .editSvg:
-            showSvgViewerPopover(
-                tableView: tableView,
-                row: row,
-                column: tableColumn,
-                columnIndex: columnIndex,
-                isEditable: mode == .editSvg
-            )
-        case .editInline:
-            beginCellEdit(row: row, tableColumnIndex: tableColumn)
-        case .editOverlay(let value):
-            showOverlayEditor(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex, value: value)
-        case .editForeignKey:
-            showForeignKeyPicker(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex)
-        case .editJson:
-            showJSONEditorPopover(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex)
-        case .editBlob:
-            showBlobEditorPopover(tableView: tableView, row: row, column: tableColumn, columnIndex: columnIndex)
-        }
-    }
-
-    private func makeCellContext(row: Int, columnIndex: Int) -> CellContext? {
-        let tableRows = tableRowsProvider()
-        guard row >= 0, columnIndex >= 0, columnIndex < tableRows.columns.count else { return nil }
-
-        let columnName = tableRows.columns[columnIndex]
-        let columnType = columnIndex < tableRows.columnTypes.count ? tableRows.columnTypes[columnIndex] : nil
-        let immutable = databaseType.map { PluginManager.shared.immutableColumns(for: $0) } ?? []
-        let override = columnIndex < columnDisplayFormats.count
-            ? columnDisplayFormats[columnIndex]
-            : nil
-
-        let typedValue = cellTypedValue(at: row, column: columnIndex)
-
-        return CellContext(
-            columnType: columnType,
-            value: cellValue(at: row, column: columnIndex),
-            isTableEditable: isEditable,
-            isRowDeleted: isRowDeleted(displayRow: row),
-            isImmutableColumn: immutable.contains(columnName),
-            isBinaryValue: typedValue.asBytes != nil,
-            isForeignKey: tableRows.columnForeignKeys[columnName] != nil,
-            displayFormatOverride: override,
-            detectedContent: CellValueContentDetector.detect(typedValue)
-        )
-    }
-
-    // MARK: - Chevron Click
-
-    func handleChevronAction(row: Int, columnIndex: Int) {
-        guard isEditable else { return }
-        guard row >= 0, columnIndex >= 0 else { return }
-        guard !isRowDeleted(displayRow: row) else { return }
-        guard let tableView else { return }
-        guard let column = tableColumnIndex(for: columnIndex) else { return }
-        guard unloadedValuesAreLoaded(displayRows: [row], columns: IndexSet(integer: columnIndex), retry: { [weak self] in
-            self?.handleChevronAction(row: row, columnIndex: columnIndex)
-        }) else { return }
-
-        if let dropdownCols = dropdownColumns, dropdownCols.contains(columnIndex) {
-            showDropdownMenu(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-            return
-        }
-        if let typePickerCols = typePickerColumns, typePickerCols.contains(columnIndex) {
-            showTypePickerPopover(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-            return
-        }
-
-        let tableRows = tableRowsProvider()
-        guard columnIndex < tableRows.columnTypes.count,
-              columnIndex < tableRows.columns.count else { return }
-
-        let columnType = tableRows.columnTypes[columnIndex]
-        let columnName = tableRows.columns[columnIndex]
-
-        if columnType.isBooleanType {
-            showDropdownMenu(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-        } else if columnType.supportsElementEditing {
-            showArrayEditorPopover(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-        } else if columnType.isVectorType {
-            showVectorPopover(
-                tableView: tableView,
-                row: row,
-                column: column,
-                columnIndex: columnIndex,
-                isEditable: canStartInlineEdit(row: row, columnIndex: columnIndex)
-            )
-        } else if let values = tableRows.columnEnumValues[columnName], !values.isEmpty {
-            if columnType.isSetType {
-                showSetPopover(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-            } else {
-                showEnumPopover(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-            }
-        } else if columnType.isJsonType {
-            showJSONEditorPopover(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-        } else if columnType.isBlobType {
-            showBlobEditorPopover(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-        } else if columnType.isDateType {
-            if opensDatePicker(row: row, columnIndex: columnIndex) {
-                showDateTimePickerPopover(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-            } else {
-                beginEditing(displayRow: row, column: columnIndex)
-            }
-        } else if columnType.isEnumOrSetType {
-            beginEditing(displayRow: row, column: columnIndex)
-        }
-    }
-
-    // MARK: - FK Navigation
-
-    func handleFKArrowAction(row: Int, columnIndex: Int, intent: ReferenceOpenIntent) {
-        let tableRows = tableRowsProvider()
-        guard row >= 0 && row < cachedRowCount,
-              columnIndex >= 0 && columnIndex < tableRows.columns.count else { return }
-
-        let columnName = tableRows.columns[columnIndex]
-        guard let fkInfo = tableRows.columnForeignKeys[columnName] else { return }
-
-        let value = cellValue(at: row, column: columnIndex)
-        guard let value = value, !value.isEmpty else { return }
-
-        delegate?.dataGridNavigateFK(value: value, fkInfo: fkInfo, intent: intent)
-    }
-
-    // MARK: - Type Picker Popover
-
-    func showTypePickerPopover(
-        tableView: NSTableView,
-        row: Int,
-        column: Int,
-        columnIndex: Int
-    ) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let currentValue = cellValue(at: row, column: columnIndex) ?? ""
-        let dbType = databaseType ?? .mysql
-        let scope = userDefinedTypeScope
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView
-        ) { [weak self] dismiss in
-            UserDefinedTypeAwarePicker(scope: scope) { userDefinedTypes in
-                TypePickerContentView(
-                    databaseType: dbType,
-                    currentValue: currentValue,
-                    userDefinedTypes: userDefinedTypes,
-                    onCommit: { newValue in
-                        guard let self else { return }
-                        self.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-                    },
-                    onDismiss: dismiss
-                )
-            }
-        }
-    }
-
-    /// The editor behind a chevron menu's `Custom…` item, anchored on the cell the menu came from.
-    ///
-    /// The escaping comes from the connected driver rather than the shared helper, because the two
-    /// disagree: MySQL doubles a backslash as well as a quote, so a value escaped the shared way
-    /// closes its own literal on MySQL and not on PostgreSQL.
-    func showCustomValuePopover(row: Int, columnIndex: Int) {
-        guard let tableView else { return }
-        guard let column = tableColumnIndex(for: columnIndex) else { return }
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let currentValue = cellValue(at: row, column: columnIndex) ?? ""
-        let escape = resolveDriver()?.escapeStringLiteral ?? SQLEscaping.escapeStringLiteral
-        let literalPrefix = SQLStringLiteralPrefix.forDatabaseType(databaseType)
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView
-        ) { [weak self] dismiss in
-            CustomValueContentView(
-                initialValue: currentValue,
-                escapeStringLiteral: escape,
-                stringLiteralPrefix: literalPrefix,
-                onCommit: { newValue in
-                    guard let self else { return }
-                    self.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-                },
-                onDismiss: dismiss
-            )
-        }
-    }
-
-    /// The table the structure grid edits, as the scope a type lookup runs against. Nil where the
-    /// grid has no connection behind it, which is every grid that is not a structure grid.
-    private var userDefinedTypeScope: DatabaseScope? {
-        guard let connectionId, tabType == .table || tabType == .createTable else { return nil }
-        return DatabaseScope(connectionId: connectionId, database: databaseName ?? "", schema: schemaName)
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnDisplayOrder.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnDisplayOrder.swift
deleted file mode 100644
index 8fb9b2e335..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnDisplayOrder.swift
+++ /dev/null
@@ -1,93 +0,0 @@
-//
-//  DataGridView+ColumnDisplayOrder.swift
-//  TablePro
-//
-
-import AppKit
-
-/// The translation between the two column spaces the grid keeps, and the only place either one is
-/// converted into the other.
-///
-/// A **data index** is a schema slot: `ColumnIdentitySchema` numbers the result's columns
-/// `dataColumn-0…n` in the order the result produced them, and that numbering never moves. It is
-/// what indexes `TableRows.columns` and `Row.values`, so every read and write of a value speaks it.
-///
-/// A **display position** is where a column sits on screen: an index into the presented run, in
-/// `tableColumns` order, skipping the row-number column, the pool's surplus slots and anything the
-/// user hid. Reordering a column changes this and leaves the data index alone.
-///
-/// `GridCoord.displayColumn` is the second of these. It has to be: a `GridRect` is a rectangle, so
-/// its column axis is a `ClosedRange`, and a range over slots cannot name the block a drag actually
-/// swept once the two orders differ. Building the rect in slot space made a sweep across two
-/// on-screen columns select and copy a third the pointer never touched.
-extension TableViewCoordinator {
-    /// Display position to data index. The array's index is the position, its element the slot.
-    ///
-    /// With no table view there is no display order, so the two spaces coincide over the result's
-    /// own columns. The count comes from the result rather than from `identitySchema`, which is
-    /// empty until `rebuildColumnMetadataCache` has run and would otherwise report a grid with no
-    /// columns at all.
-    var presentedDataColumns: [Int] {
-        if let cached = cachedPresentedDataColumns { return cached }
-        /// The fallback is deliberately not cached: nothing invalidates on a table view being
-        /// attached, so a map derived before there was one would outlive the state that produced it.
-        guard let resolved = visibleColumnDataIndices() else {
-            return Array(0..<tableRowsProvider().columns.count)
-        }
-        cachedPresentedDataColumns = resolved
-        return resolved
-    }
-
-    var presentedColumnCount: Int { presentedDataColumns.count }
-
-    func dataColumnIndex(atDisplayPosition position: Int) -> Int? {
-        let columns = presentedDataColumns
-        guard position >= 0, position < columns.count else { return nil }
-        return columns[position]
-    }
-
-    /// Cached rather than scanned. `SortableHeaderView.updateColumnSelectionIndicators` asks this
-    /// once per attached column on every drag update, so a linear scan makes selection movement
-    /// O(columns squared) on exactly the 500 to 1,000-column results the grid is built for (#2381).
-    func displayPosition(ofDataColumnIndex dataIndex: Int) -> Int? {
-        if let cached = cachedDisplayPositionByDataColumn { return cached[dataIndex] }
-        var map: [Int: Int] = [:]
-        let columns = presentedDataColumns
-        map.reserveCapacity(columns.count)
-        for (position, slot) in columns.enumerated() {
-            map[slot] = position
-        }
-        cachedDisplayPositionByDataColumn = map
-        return map[dataIndex]
-    }
-
-    /// The data indices a selection covers, in display order. This is the slot-space answer every
-    /// consumer that reads or writes a value wants.
-    func dataColumnIndices(in columns: IndexSet) -> [Int] {
-        columns.compactMap { dataColumnIndex(atDisplayPosition: $0) }
-    }
-
-    /// Where a display position sits in `tableColumns`, which is what the cell cursor and every
-    /// `rect(ofColumn:)` are expressed in.
-    func tableColumnIndex(forDisplayPosition position: Int) -> Int? {
-        guard let dataIndex = dataColumnIndex(atDisplayPosition: position) else { return nil }
-        return tableColumnIndex(for: dataIndex)
-    }
-
-    /// Drops the cached mapping, and the cell selection with it when the mapping actually moved.
-    ///
-    /// A `GridSelection` holds display positions, so hiding the selected column, or hiding or moving
-    /// one before it, silently retargets it: the outline lands on a different column and Copy takes
-    /// values the user never selected. Nothing can remap it faithfully, because a hidden column's
-    /// position no longer exists, so the selection is dropped rather than left pointing somewhere
-    /// plausible. An unchanged run leaves the selection alone, which is what keeps an ordinary
-    /// reload from clearing it.
-    func invalidatePresentedColumnCache() {
-        let previous = cachedPresentedDataColumns
-        cachedPresentedDataColumns = nil
-        cachedDisplayPositionByDataColumn = nil
-        guard let previous, !selectionController.isEmpty else { return }
-        guard previous != presentedDataColumns else { return }
-        selectionController.clear()
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnGeometry.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnGeometry.swift
deleted file mode 100644
index a775a9a933..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnGeometry.swift
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-//  DataGridView+ColumnGeometry.swift
-//  TablePro
-//
-
-import AppKit
-
-extension TableViewCoordinator {
-    /// The one place a column width, order or visibility change reaches the drawn body.
-    ///
-    /// `NSTableView` pushes column geometry into a table body by relaying its cell views out and
-    /// redrawing them. This grid mounts no view for a data column and draws every cell itself
-    /// (#2381), so that channel is empty, and `NSTableRowView` has no geometry callback of its own.
-    /// AppKit resizes a row view only when the table's total width moves, which it does not while
-    /// the columns still fit inside the viewport, so nothing is marked dirty and the body keeps the
-    /// layout it last drew until an unrelated event invalidates a row (#2449).
-    ///
-    /// The column notifications arrive once a gesture ends, so a divider or reorder drag also comes
-    /// here from `SortableHeaderView.viewWillDraw()` on every step.
-    ///
-    /// Everything that paints from live `rect(ofColumn:)` is invalidated here: each row, the table
-    /// view's own background past the last row, and the cell selection outline. A row is reached
-    /// through its drawn cells, which is enough for the whole row: `canDrawSubviewsIntoLayer` makes
-    /// the row's layer the one backing store for the row and its cells, so dirtying the cells marks
-    /// the row itself dirty and its separators and cell-range selection wash repaint with them.
-    func columnGeometryDidChange() {
-        guard let tableView else { return }
-        redrawVisibleCells()
-        tableView.setNeedsDisplay(tableView.visibleRect)
-        selectionController.overlay?.needsDisplay = true
-        synchronizeRowGutter()
-        repaintRowGutter()
-    }
-
-    /// Keeps the row-number column at the head of the run.
-    ///
-    /// `DataGridColumnPool` places every data column relative to it and reads its position off
-    /// `tableColumns.first`, so a row-number column dragged into the run leaves the pool ordering
-    /// from index 0 and walking it one place further right on every reconcile until it reaches the
-    /// far end, permanently. No fixed position may name a data column (#2381), and this is the
-    /// other half of that: the origin those positions are measured from has to hold still.
-    ///
-    /// A drag opens with `newColumnIndex` at -1, which asks whether the column may be reordered at
-    /// all rather than proposing a destination. Answering no there stops the drag before it starts,
-    /// so that probe is refused only for the row-number column itself.
-    func tableView(
-        _ tableView: NSTableView,
-        shouldReorderColumn columnIndex: Int,
-        toColumn newColumnIndex: Int
-    ) -> Bool {
-        guard tableView.tableColumns.indices.contains(columnIndex) else { return false }
-        guard let rowNumberIndex = tableView.tableColumns.firstIndex(where: {
-            $0.identifier == ColumnIdentitySchema.rowNumberIdentifier
-        }) else { return true }
-        guard columnIndex != rowNumberIndex else { return false }
-        return newColumnIndex < 0 || newColumnIndex > rowNumberIndex
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnJump.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnJump.swift
deleted file mode 100644
index 3d7840707d..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnJump.swift
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-//  DataGridView+ColumnJump.swift
-//  TablePro
-//
-
-import AppKit
-
-/// A jump the grid could not perform yet because the column was hidden.
-///
-/// It carries the data index when the entry had one, because a name alone resolves to the last
-/// of two same-named columns; a column a table tab never fetched has no index until it lands, so
-/// the name is the fallback. `tableKey` is the table the request was made against, so a preview
-/// tab retargeted to another table with a column of the same name does not jump there. A table
-/// tab refetches to show a column, so its jump waits for that result to be installed rather than
-/// landing on the interim update that unhides an already-fetched key or sort column, which the
-/// refetch would then undo; a query tab shows a column without fetching, so it does not wait.
-struct PendingColumnJump: Equatable {
-    let name: String
-    let dataIndex: Int?
-    let tableKey: ColumnLayoutTableKey?
-    let awaitsResultReplacement: Bool
-}
-
-extension TableViewCoordinator {
-    /// The data index under the cell cursor, or nil while the cursor sits on chrome or nowhere.
-    var focusedDataColumnIndex: Int? {
-        guard let tableView = tableView as? KeyHandlingTableView,
-              presentsColumn(atTableColumnIndex: tableView.focusedColumn) else { return nil }
-        return dataColumnIndex(from: tableView.tableColumns[tableView.focusedColumn].identifier)
-    }
-
-    /// Scrolls a presented column into view and puts the cell cursor in it, on the selected row or
-    /// else the first row in the viewport. It goes through `focusCell`, the one way a keystroke
-    /// moves the cursor, so the selection, the repaint and the accessibility notice all follow.
-    /// A jump that lands supersedes any jump still parked, so an older request cannot take the
-    /// cursor back when its column finally arrives.
-    @discardableResult
-    func jumpToColumn(dataIndex: Int) -> Bool {
-        guard let tableView = tableView as? KeyHandlingTableView,
-              let tableColumnIndex = tableColumnIndex(for: dataIndex),
-              presentsColumn(atTableColumnIndex: tableColumnIndex) else { return false }
-        pendingColumnJump = nil
-        overlayEditor?.dismiss(commit: true)
-        dismissFKPreviewOnColumnChange()
-        let row = jumpRow(in: tableView)
-        if row >= 0 {
-            tableView.focusCell(row: row, column: tableColumnIndex)
-        } else {
-            scrollColumnToVisible(tableColumnIndex: tableColumnIndex)
-        }
-        _ = focusGrid()
-        return true
-    }
-
-    /// Runs the parked jump once the grid's update pass has put the column on screen. Deferred off
-    /// the pass itself, because the jump selects a row and that write reaches SwiftUI state.
-    func schedulePendingColumnJump(contentReplaced: Bool) {
-        guard pendingColumnJump != nil else { return }
-        Task { @MainActor [weak self] in
-            self?.consumePendingColumnJump(contentReplaced: contentReplaced)
-        }
-    }
-
-    /// - Parameter contentReplaced: whether this update installed a new result. A request that
-    ///   waits for its refetch lands only on one, and a request whose column a new result no
-    ///   longer carries is dropped rather than left armed for a result that may never come.
-    func consumePendingColumnJump(contentReplaced: Bool) {
-        guard let pending = pendingColumnJump else { return }
-        guard pending.tableKey == columnLayoutKey else {
-            pendingColumnJump = nil
-            return
-        }
-        guard contentReplaced || !pending.awaitsResultReplacement else { return }
-        if let dataIndex = resolvedDataIndex(for: pending), jumpToColumn(dataIndex: dataIndex) {
-            return
-        }
-        if contentReplaced {
-            pendingColumnJump = nil
-        }
-    }
-
-    private func resolvedDataIndex(for pending: PendingColumnJump) -> Int? {
-        if let dataIndex = pending.dataIndex, identitySchema.columnName(for: dataIndex) == pending.name {
-            return dataIndex
-        }
-        return identitySchema.dataIndex(forColumnName: pending.name)
-    }
-
-    private func jumpRow(in tableView: NSTableView) -> Int {
-        if tableView.selectedRow >= 0 {
-            return tableView.selectedRow
-        }
-        guard tableView.numberOfRows > 0 else { return -1 }
-        return max(0, tableView.rows(in: tableView.visibleRect).location)
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnWidths.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnWidths.swift
deleted file mode 100644
index 262bc5b302..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+ColumnWidths.swift
+++ /dev/null
@@ -1,105 +0,0 @@
-//
-//  DataGridView+ColumnWidths.swift
-//  TablePro
-//
-
-import AppKit
-
-extension TableViewCoordinator {
-    func automaticColumnWidth(for columnName: String, columnIndex: Int, tableRows: TableRows) -> CGFloat {
-        cellFactory.calculateOptimalColumnWidth(
-            for: columnName,
-            columnIndex: columnIndex,
-            tableRows: tableRows,
-            accessory: columnPresentation(for: columnIndex, in: tableRows).accessory,
-            displayFormat: columnIndex < columnDisplayFormats.count ? columnDisplayFormats[columnIndex] : nil,
-            databaseType: databaseType,
-            isLargeDataset: isLargeDataset,
-            nullDisplayString: cellRegistry.nullDisplayString,
-            revealsInvisibleCharacters: cellRegistry.showsInvisibleCharacters
-        )
-    }
-
-    func fitToContentColumnWidth(
-        for columnName: String,
-        columnIndex: Int,
-        tableRows: TableRows,
-        availableWidth: CGFloat,
-        fittedColumnCount: Int = 1
-    ) -> CGFloat {
-        cellFactory.calculateFitToContentWidth(
-            for: columnName,
-            columnIndex: columnIndex,
-            tableRows: tableRows,
-            availableWidth: availableWidth,
-            accessory: columnPresentation(for: columnIndex, in: tableRows).accessory,
-            displayFormat: columnIndex < columnDisplayFormats.count ? columnDisplayFormats[columnIndex] : nil,
-            databaseType: databaseType,
-            isLargeDataset: isLargeDataset,
-            nullDisplayString: cellRegistry.nullDisplayString,
-            revealsInvisibleCharacters: cellRegistry.showsInvisibleCharacters,
-            fittedColumnCount: fittedColumnCount
-        )
-    }
-
-    /// A layout that carries widths but no content widths was written before the app recorded which
-    /// widths the user chose, and it measured every column as if none of them drew an in-cell action
-    /// button. Its width for a column that does draw one is short by that button's footprint, so
-    /// that width is dropped and the column is measured again. A column with no button was measured
-    /// with the same padding then as now, so its width is kept, and so is a width the user has taken
-    /// ownership of in this session.
-    func layoutDiscardingUnownedWidths(
-        _ layout: ColumnLayoutState?,
-        tableRows: TableRows
-    ) -> ColumnLayoutState? {
-        guard var layout,
-              layout.columnContentWidths?.isEmpty != false,
-              !layout.columnWidths.isEmpty
-        else {
-            unownedRestoredColumnNames = []
-            return layout
-        }
-
-        for (columnIndex, columnName) in tableRows.columns.enumerated() {
-            guard !userSizedColumnNames.contains(columnName),
-                  columnPresentation(for: columnIndex, in: tableRows).accessory != .none
-            else { continue }
-            layout.columnWidths.removeValue(forKey: columnName)
-        }
-        unownedRestoredColumnNames = Set(layout.columnWidths.keys).subtracting(userSizedColumnNames)
-        return layout
-    }
-
-    /// Metadata that reveals an action button arrives after the rows on several drivers, and the
-    /// column was measured without room for it. Widening is scoped to columns the user has not
-    /// sized and never shrinks one, so a width the user is reading only ever grows to fit what the
-    /// cell now draws.
-    func applyAccessoryWidthChanges(
-        _ changes: DataGridColumnPresentationChanges,
-        tableRows: TableRows
-    ) {
-        guard let tableView, !changes.isEmpty else { return }
-
-        let wasRebuildingColumns = isRebuildingColumns
-        isRebuildingColumns = true
-        defer { isRebuildingColumns = wasRebuildingColumns }
-
-        for dataIndex in changes.indices {
-            guard dataIndex < tableRows.columns.count else { continue }
-            let columnName = tableRows.columns[dataIndex]
-            let isOwned = userSizedColumnNames.contains(columnName)
-                && !unownedRestoredColumnNames.contains(columnName)
-            guard !isOwned,
-                  let identifier = identitySchema.identifier(for: dataIndex)
-            else { continue }
-
-            let tableColumnIndex = tableView.column(withIdentifier: identifier)
-            guard tableColumnIndex >= 0, tableColumnIndex < tableView.tableColumns.count else { continue }
-
-            let column = tableView.tableColumns[tableColumnIndex]
-            let width = automaticColumnWidth(for: columnName, columnIndex: dataIndex, tableRows: tableRows)
-            guard width > column.width else { continue }
-            column.width = width
-        }
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Columns.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Columns.swift
deleted file mode 100644
index 20a00e8c5c..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Columns.swift
+++ /dev/null
@@ -1,179 +0,0 @@
-//
-//  DataGridView+Columns.swift
-//  TablePro
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-
-extension TableViewCoordinator {
-    func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
-        autoreleasepool { viewForCell(in: tableView, column: tableColumn, row: row) }
-    }
-
-    /// Only the row-number column mounts a view, until something reads the grid through
-    /// accessibility.
-    ///
-    /// A data cell is drawn by its row instead. `NSTableView` builds one cell view per column per
-    /// prepared row whatever the viewport shows, so a 500-column result carried 12,500 views and
-    /// 837MB of them; returning nil here leaves 26 views in the whole table and 3.9MB (#2381).
-    ///
-    /// A table view's `AXCell` tree comes from cell views alone, so a session with an assistive
-    /// client attached pays that cost back and gets a cell it can read. See
-    /// `DataGridCellAccessibilityView`.
-    private func viewForCell(in tableView: NSTableView, column tableColumn: NSTableColumn?, row: Int) -> NSView? {
-        guard let column = tableColumn else { return nil }
-        guard column.identifier != ColumnIdentitySchema.rowNumberIdentifier else {
-            let tableRows = tableRowsProvider()
-            let cell = cellRegistry.makeRowNumberCell(
-                in: tableView,
-                row: row,
-                pageOffset: paginationOffsetProvider(),
-                cachedRowCount: displayIDs?.count ?? tableRows.count,
-                visualState: visualState(for: row)
-            )
-            /// The row number is the handle a reorder drag starts from, so it is where the reason
-            /// the drag is withheld belongs. Reused cells carry the last value, so clear it.
-            cell.toolTip = rowReorder.unavailableReason
-            return cell
-        }
-
-        guard DataGridAccessibility.isActive,
-              presentsColumn(column),
-              mountsAccessibilityCell(forRow: row),
-              let dataColumn = dataColumnIndex(from: column.identifier) else { return nil }
-        let cell = (tableView.makeView(withIdentifier: DataGridCellAccessibilityView.reuseIdentifier, owner: nil)
-            as? DataGridCellAccessibilityView) ?? DataGridCellAccessibilityView()
-        cell.identifier = DataGridCellAccessibilityView.reuseIdentifier
-        cell.configure(coordinator: self, row: row, dataColumn: dataColumn)
-        return cell
-    }
-
-    /// What one data cell looks like, for the row that draws it.
-    ///
-    /// - Parameters:
-    ///   - onEmphasizedSelection: whether the row is drawn as selected, which changes the text
-    ///     colour and stands the modified tint down.
-    func cellAppearance(
-        row: Int,
-        columnIndex: Int,
-        onEmphasizedSelection: Bool
-    ) -> DataGridCellAppearance? {
-        let tableRows = tableRowsProvider()
-        let displayCount = displayIDs?.count ?? tableRows.count
-        guard row >= 0, row < displayCount,
-              columnIndex >= 0, columnIndex < cachedColumnCount,
-              let displayRow = displayRow(at: row, in: tableRows),
-              columnIndex < displayRow.values.count else { return nil }
-
-        let rawValue = displayRow.values[columnIndex]
-        let columnType = columnIndex < tableRows.columnTypes.count ? tableRows.columnTypes[columnIndex] : nil
-        let formattedValue = displayValue(
-            forID: displayRow.id,
-            column: columnIndex,
-            rawValue: rawValue,
-            columnType: columnType
-        )
-
-        let isFocused: Bool = {
-            guard let keyTableView = tableView as? KeyHandlingTableView,
-                  keyTableView.focusedRow == row,
-                  let position = tableColumnIndex(for: columnIndex),
-                  keyTableView.focusedColumn == position else { return false }
-            return true
-        }()
-
-        return DataGridCellAppearance.resolve(
-            kind: columnPresentation(for: columnIndex, in: tableRows).kind,
-            content: DataGridCellContent(
-                displayText: formattedValue ?? "",
-                rawValue: rawValue.asText,
-                placeholder: DataGridCellContent.placeholder(
-                    for: rawValue,
-                    isAbsent: displayRow.isAbsent(columnIndex),
-                    unloadedByteCount: displayRow.unloadedByteCount(columnIndex)
-                )
-            ),
-            state: DataGridCellState(
-                visualState: visualState(of: displayRow, atDisplayRow: row),
-                isFocused: isFocused,
-                isEditable: isEditable,
-                isLargeDataset: isLargeDataset,
-                isCurrentFindMatch: currentFindMatch == FindMatch(displayRow: row, columnIndex: columnIndex),
-                row: row,
-                columnIndex: columnIndex
-            ),
-            palette: cellRegistry.palette,
-            nullDisplayString: cellRegistry.nullDisplayString,
-            onEmphasizedSelection: onEmphasizedSelection,
-            hasOverlay: overlayCell == CellPosition(row: row, column: columnIndex),
-            checkboxMark: checkboxMark(row: row, columnIndex: columnIndex),
-            textTone: delegate?.dataGridTextTone(row: row, column: columnIndex),
-            revealsInvisibleCharacters: cellRegistry.showsInvisibleCharacters
-        )
-    }
-
-    /// What VoiceOver reads for one cell. A placeholder announces itself by name rather than as the
-    /// empty string a sighted reader sees as an italic marker.
-    func accessibilityText(row: Int, columnIndex: Int) -> String? {
-        let tableRows = tableRowsProvider()
-        guard let displayRow = displayRow(at: row, in: tableRows),
-              columnIndex < displayRow.values.count else { return nil }
-        if let spoken = delegate?.dataGridAccessibilityText(row: row, column: columnIndex) {
-            return spoken
-        }
-        let rawValue = displayRow.values[columnIndex]
-        let columnType = columnIndex < tableRows.columnTypes.count ? tableRows.columnTypes[columnIndex] : nil
-        let text = displayValue(
-            forID: displayRow.id,
-            column: columnIndex,
-            rawValue: rawValue,
-            columnType: columnType
-        ) ?? ""
-        guard text.isEmpty else { return spokenText(of: text) }
-
-        switch DataGridCellContent.placeholder(
-            for: rawValue,
-            isAbsent: displayRow.isAbsent(columnIndex),
-            unloadedByteCount: displayRow.unloadedByteCount(columnIndex)
-        ) {
-        case .null: return String(localized: "NULL")
-        case .empty: return String(localized: "Empty")
-        case .defaultMarker: return String(localized: "DEFAULT")
-        case .absent: return DataGridCellContent.absentFieldText
-        case .unloaded(let byteCount): return DataGridCellContent.unloadedSpokenText(byteCount: byteCount)
-        case .none: return text
-        }
-    }
-
-    // A mark drawn in the cell is read by its name, or VoiceOver says nothing for it.
-    private func spokenText(of text: String) -> String {
-        guard cellRegistry.showsInvisibleCharacters else { return text }
-        let revealed = RevealedText(text, marksLineBreaks: true)
-        return revealed.revealsAnyCharacter ? revealed.spokenText : text
-    }
-
-    func tableView(_ tableView: NSTableView, typeSelectStringFor tableColumn: NSTableColumn?, row: Int) -> String? {
-        guard let tableColumn else { return nil }
-        guard tableColumn.identifier != ColumnIdentitySchema.rowNumberIdentifier else { return nil }
-        guard let columnIndex = dataColumnIndex(from: tableColumn.identifier) else { return nil }
-        guard let displayRow = displayRow(at: row) else { return nil }
-        guard columnIndex < displayRow.values.count else { return nil }
-        return displayRow.values[columnIndex].asText
-    }
-
-    func tableView(_ tableView: NSTableView, rowViewForRow row: Int) -> NSTableRowView? {
-        if let delegateRowView = delegate?.dataGridRowView(for: tableView, row: row, coordinator: self) {
-            (delegateRowView as? DataGridRowView)?.invalidateVisualState()
-            return delegateRowView
-        }
-        let rowView = (tableView.makeView(withIdentifier: Self.rowViewIdentifier, owner: nil) as? DataGridRowView)
-            ?? DataGridRowView()
-        rowView.identifier = Self.rowViewIdentifier
-        rowView.coordinator = self
-        rowView.rowIndex = row
-        rowView.invalidateVisualState()
-        return rowView
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+DisplayInvalidation.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+DisplayInvalidation.swift
deleted file mode 100644
index 788aab7d10..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+DisplayInvalidation.swift
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-//  DataGridView+DisplayInvalidation.swift
-//  TablePro
-//
-//  Throwing away the grid's formatted text when something it was derived from moves.
-//
-
-import AppKit
-import Combine
-import Foundation
-
-extension TableViewCoordinator {
-    /// Throws away every formatted string and derives them again. The settings path takes it when
-    /// the date format, the NULL text or smart detection moves; the system time zone takes it
-    /// because a Unix-timestamp column renders an instant in the reader's own zone.
-    func reformatDisplayedText() {
-        guard let tableView else { return }
-        invalidateDisplayCache()
-        let visibleRange = tableView.rows(in: tableView.visibleRect)
-        if visibleRange.length > 0 {
-            repaintRows(IndexSet(integersIn: visibleRange.location ..< (visibleRange.location + visibleRange.length)))
-        }
-        startBackgroundPrewarm()
-    }
-
-    /// The mounted grid draws again on a zone change. An unmounted tab is covered instead by
-    /// `DataGridDisplayIdentity`, which carries the generation, so its cache is replaced rather
-    /// than repaired the next time the tab is shown.
-    func observeSystemTimeZoneChanges() {
-        systemTimeZoneCancellable = AppEvents.shared.systemTimeZoneChanged
-            .receive(on: RunLoop.main)
-            .sink { [weak self] _ in
-                self?.reformatDisplayedText()
-            }
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Editing.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Editing.swift
deleted file mode 100644
index 5f41206464..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Editing.swift
+++ /dev/null
@@ -1,222 +0,0 @@
-//
-//  DataGridView+Editing.swift
-//  TablePro
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-
-extension TableViewCoordinator {
-    enum EditEligibility {
-        case editable(value: String)
-        case blocked
-    }
-
-    func editEligibility(row: Int, columnIndex: Int) -> EditEligibility {
-        guard isEditable else { return .blocked }
-        let tableRows = tableRowsProvider()
-        guard row >= 0, columnIndex >= 0, columnIndex < tableRows.columns.count else { return .blocked }
-        guard !isRowDeleted(displayRow: row) else { return .blocked }
-
-        guard isColumnWritable(tableRows.columns[columnIndex]) else { return .blocked }
-        guard !isUnloaded(row: row, columnIndex: columnIndex) else { return .blocked }
-
-        if columnIndex < tableRows.columnTypes.count {
-            let ct = tableRows.columnTypes[columnIndex]
-            if ct.isBlobType {
-                return .blocked
-            }
-        }
-
-        guard cellTypedValue(at: row, column: columnIndex).asBytes == nil else { return .blocked }
-
-        let value: String
-        if let displayRow = displayRow(at: row),
-           columnIndex < displayRow.values.count,
-           let raw = displayRow.values[columnIndex].asText {
-            value = raw
-        } else {
-            value = ""
-        }
-        return .editable(value: value)
-    }
-
-    /// Whether the app is allowed to send a value for this column at all, which is a narrower
-    /// question than whether the cell takes the inline editor: a BLOB cell refuses the editor and
-    /// still accepts NULL from the Set Value menu. The menu offered its items on a column no
-    /// statement can carry, so Set NULL on a MongoDB `_id`, a generated column or a
-    /// `GENERATED ALWAYS AS IDENTITY` column marked the row edited and then wrote nothing.
-    func isColumnWritable(_ columnName: String) -> Bool {
-        guard !lockedColumns.contains(columnName) else { return false }
-        guard !changeManager.generatedColumns.contains(columnName) else { return false }
-        let immutable = databaseType.map { PluginManager.shared.immutableColumns(for: $0) } ?? []
-        return !immutable.contains(columnName)
-    }
-
-    /// Whether a row here can lack a field, apart from holding NULL, which is what offers Remove
-    /// Field. Only a data grid's rows can; a structure grid edits definitions.
-    var supportsFieldRemoval: Bool {
-        changeManager.supportsFieldRemoval
-    }
-
-    func canStartInlineEdit(row: Int, columnIndex: Int) -> Bool {
-        if case .editable = editEligibility(row: row, columnIndex: columnIndex) {
-            return true
-        }
-        return false
-    }
-
-    func tableView(_ tableView: NSTableView, shouldEdit tableColumn: NSTableColumn?, row: Int) -> Bool {
-        false
-    }
-
-    /// A grid that will not take a keystroke and says nothing reads as broken. When the refusal has
-    /// a reason the pointer already carries it as the grid's tooltip, and the beep is AppKit's own
-    /// way of saying the attempt was heard and declined.
-    ///
-    /// A locked column beeps too. The rest of its grid is editable, so there is no grid-wide tooltip
-    /// to carry the reason, and a cell that swallowed the keystroke in silence would read as a dead
-    /// grid rather than a refusal. The explanation is on the dimmed pair under the list. (#2726)
-    func refuseEditIfExplained(columnIndex: Int? = nil) {
-        if let columnIndex, isLockedColumn(at: columnIndex) {
-            NSSound.beep()
-            return
-        }
-        guard !isEditable, editRefusalMessage != nil else { return }
-        NSSound.beep()
-    }
-
-    private func isLockedColumn(at columnIndex: Int) -> Bool {
-        guard !lockedColumns.isEmpty else { return false }
-        let columns = tableRowsProvider().columns
-        guard columnIndex >= 0, columnIndex < columns.count else { return false }
-        return lockedColumns.contains(columns[columnIndex])
-    }
-
-    func beginCellEdit(row: Int, tableColumnIndex: Int) {
-        guard let tableView else { return }
-        guard tableColumnIndex >= 0, tableColumnIndex < tableView.numberOfColumns else { return }
-        let column = tableView.tableColumns[tableColumnIndex]
-        guard column.identifier != ColumnIdentitySchema.rowNumberIdentifier else { return }
-        guard let columnIndex = dataColumnIndex(from: column.identifier) else { return }
-        guard case .editable(let value) = editEligibility(row: row, columnIndex: columnIndex) else {
-            refuseEditIfExplained(columnIndex: columnIndex)
-            return
-        }
-        showOverlayEditor(
-            tableView: tableView,
-            row: row,
-            column: tableColumnIndex,
-            columnIndex: columnIndex,
-            value: value
-        )
-    }
-
-    // MARK: - Overlay Editor
-
-    func showOverlayEditor(tableView: NSTableView, row: Int, column: Int, columnIndex: Int, value: String) {
-        if overlayEditor == nil {
-            overlayEditor = CellOverlayEditor()
-        }
-        guard let editor = overlayEditor else { return }
-
-        observeRemoval(of: editor)
-        editor.onCommit = { [weak self] row, columnIndex, newValue in
-            self?.commitCellEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-        }
-        editor.onMovement = { [weak self] row, column, movement in
-            self?.handleOverlayMovement(row: row, column: column, movement: movement)
-        }
-        overlayViewer?.dismiss()
-        // A cell partly under the pinned band comes clear of it first, as Return already does.
-        scrollColumnToVisible(tableColumnIndex: column)
-        editor.show(in: tableView, row: row, column: column, columnIndex: columnIndex, value: value)
-    }
-
-    func showOverlayViewer(tableView: NSTableView, row: Int, column: Int, columnIndex: Int, value: String) {
-        if overlayViewer == nil {
-            overlayViewer = CellOverlayViewer()
-        }
-        guard let viewer = overlayViewer else { return }
-        observeRemoval(of: viewer)
-        overlayEditor?.dismiss(commit: false)
-        scrollColumnToVisible(tableColumnIndex: column)
-        viewer.show(in: tableView, row: row, column: column, columnIndex: columnIndex, value: value)
-    }
-
-    /// Cell presentation work and a reload put off while the overlay was open both wait for it to
-    /// close.
-    func observeRemoval(of overlay: CellOverlayBase) {
-        overlay.onRemove = { [weak self] in
-            self?.flushPendingCellPresentationRefresh()
-            Task { @MainActor [weak self] in
-                self?.delegate?.dataGridDidCloseCellOverlay()
-            }
-        }
-    }
-
-    /// The cell cursor moves with the editor, through the same `focusCell` the grid's own Tab uses.
-    /// Selecting the row alone left the cursor on the column the editor came from, so closing the
-    /// editor put it back where the editing was not, and it never scrolled the target row into
-    /// view, so a wrap onto the row below the last visible one opened the editor off screen.
-    func handleOverlayMovement(row: Int, column: Int, movement: CellEditorMovement) {
-        guard let tableView = tableView as? KeyHandlingTableView,
-              let target = movementTarget(from: (row, column), movement: movement, in: tableView)
-        else { return }
-
-        tableView.focusCell(row: target.row, column: target.column)
-
-        guard let targetColumnIndex = DataGridView.dataColumnIndex(
-                for: target.column,
-                in: tableView,
-                schema: identitySchema
-              ),
-              targetColumnIndex >= 0,
-              case .editable(let value) = editEligibility(row: target.row, columnIndex: targetColumnIndex)
-        else { return }
-
-        showOverlayEditor(
-            tableView: tableView,
-            row: target.row,
-            column: target.column,
-            columnIndex: targetColumnIndex,
-            value: value
-        )
-    }
-
-    /// Tab walks the presented columns and wraps onto the next row's first, Shift+Tab onto the
-    /// previous row's last. Both ends are resolved rather than assumed: the window's spacers and
-    /// the pool's surplus slots are attached columns too, so neither end of `tableColumns` holds a
-    /// data column and a fixed position lands on a spacer that swallows the keystroke.
-    ///
-    /// Up and Down hold the column and step one row, and neither wraps: a column is a column of one
-    /// kind of value, so carrying the editor from the last row round to the first is a jump the
-    /// user did not ask for.
-    func movementTarget(
-        from cell: (row: Int, column: Int),
-        movement: CellEditorMovement,
-        in tableView: NSTableView
-    ) -> (row: Int, column: Int)? {
-        switch movement {
-        case .tab:
-            if let next = nextPresentedColumnIndex(after: cell.column) {
-                return (cell.row, next)
-            }
-            guard cell.row + 1 < tableView.numberOfRows, let first = firstPresentedColumnIndex() else { return nil }
-            return (cell.row + 1, first)
-        case .backtab:
-            if let previous = previousPresentedColumnIndex(before: cell.column) {
-                return (cell.row, previous)
-            }
-            guard cell.row > 0, let last = lastPresentedColumnIndex() else { return nil }
-            return (cell.row - 1, last)
-        case .up:
-            guard cell.row > 0 else { return nil }
-            return (cell.row - 1, cell.column)
-        case .down:
-            guard cell.row + 1 < tableView.numberOfRows else { return nil }
-            return (cell.row + 1, cell.column)
-        }
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+FillColumn.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+FillColumn.swift
deleted file mode 100644
index 37de1e3ac3..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+FillColumn.swift
+++ /dev/null
@@ -1,231 +0,0 @@
-//
-//  DataGridView+FillColumn.swift
-//  TablePro
-//
-
-import AppKit
-import TableProPluginKit
-
-enum FillColumnChoice: Equatable {
-    case value
-    case null
-    case uuid(UUIDVersion)
-}
-
-/// A UUID is drawn for each row.
-enum FillColumnContent: Equatable {
-    case value(PluginCellValue, isExpression: Bool = false)
-    case uuid(UUIDVersion, UUIDCellForm)
-}
-
-extension TableViewCoordinator {
-    @objc func fillColumn(_ sender: NSMenuItem) {
-        guard let columnIndex = sender.representedObject as? Int else { return }
-        presentFillColumnDialog(columnIndex: columnIndex)
-    }
-
-    func presentFillColumnDialog(columnIndex: Int) {
-        guard isEditable, let window = tableView?.window else { return }
-
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-
-        let rowCount = fillTargetRows().count
-        guard rowCount > 0 else { return }
-
-        let columnName = tableRows.columns[columnIndex]
-        let accessory = FillColumnAccessoryView(choices: fillColumnChoices(columnIndex: columnIndex))
-
-        let alert = NSAlert()
-        alert.messageText = String(format: String(localized: "Fill column \"%@\""), columnName)
-        alert.informativeText = Self.fillImpactDescription(rowCount: rowCount)
-        alert.accessoryView = accessory
-        alert.addButton(withTitle: String(localized: "Fill"))
-        alert.addButton(withTitle: String(localized: "Cancel"))
-
-        alert.window.initialFirstResponder = accessory.firstResponderView
-
-        alert.beginSheetModal(for: window) { [weak self] response in
-            guard response == .alertFirstButtonReturn, let self else { return }
-            guard let content = self.fillColumnContent(
-                choice: accessory.choice, text: accessory.enteredText, columnIndex: columnIndex
-            ) else {
-                NSSound.beep()
-                return
-            }
-            self.applyFillColumn(columnIndex: columnIndex, content: content)
-        }
-    }
-
-    func fillColumnChoices(columnIndex: Int) -> [FillColumnChoice] {
-        let tableRows = tableRowsProvider()
-        guard tableRows.columns.indices.contains(columnIndex) else { return [.value] }
-        var choices: [FillColumnChoice] = [.value]
-        if tableRows.columnNullable[tableRows.columns[columnIndex]] ?? true {
-            choices.append(.null)
-        }
-        if fillUUIDForm(columnIndex: columnIndex, in: tableRows) != nil {
-            choices += [.uuid(.v4), .uuid(.v7)]
-        }
-        return choices
-    }
-
-    func applyFillColumn(columnIndex: Int, content: FillColumnContent) {
-        let targetRows = fillTargetRows()
-        guard !targetRows.isEmpty else { return }
-        let retry: @MainActor () -> Void = { [weak self] in
-            self?.applyFillColumn(columnIndex: columnIndex, content: content)
-        }
-        guard unloadedValuesAreLoaded(displayRows: targetRows, columns: IndexSet(integer: columnIndex), retry: retry)
-        else { return }
-
-        let undoManager = tableView?.window?.undoManager
-        undoManager?.beginUndoGrouping()
-
-        var didEdit = false
-        for row in targetRows {
-            let staged = Self.fillValue(content)
-            if recordCellEdit(
-                row: row, columnIndex: columnIndex, newValue: staged.value, isExpression: staged.isExpression
-            ) != nil {
-                didEdit = true
-            }
-        }
-
-        // After the loop: each cell's own step names the open group "Edit Cell".
-        undoManager?.setActionName(String(localized: "Fill Column"))
-        undoManager?.endUndoGrouping()
-
-        guard didEdit else { return }
-        invalidateAllDisplayCaches()
-        tableView?.reloadData()
-    }
-
-    private static func fillValue(_ content: FillColumnContent) -> (value: PluginCellValue, isExpression: Bool) {
-        switch content {
-        case .value(let value, let isExpression):
-            return (value: value, isExpression: isExpression)
-        case .uuid(let version, let form):
-            return (value: form.value(for: UUIDValueGenerator.shared.make(version)), isExpression: false)
-        }
-    }
-
-    private func fillTargetRows() -> [Int] {
-        let tableRows = tableRowsProvider()
-        return Self.fillTargetRows(rowCount: cachedRowCount, isEditable: isEditable) { displayIndex in
-            guard let storageIndex = DisplayRowMapping.rowIndex(
-                forDisplay: displayIndex, displayIDs: displayIDs, in: tableRows
-            ) else { return false }
-            return changeManager.isRowDeleted(tableRows.rows[storageIndex].id)
-        }
-    }
-
-    static func fillTargetRows(rowCount: Int, isEditable: Bool, isRowDeleted: (Int) -> Bool) -> [Int] {
-        guard isEditable, rowCount > 0 else { return [] }
-        return (0..<rowCount).filter { !isRowDeleted($0) }
-    }
-
-    /// The value is read the way a typed cell is: an empty date is NULL, a function the engine runs there is SQL. Nil
-    /// when the column holds neither the text nor NULL in its place.
-    func fillColumnContent(choice: FillColumnChoice, text: String, columnIndex: Int) -> FillColumnContent? {
-        switch choice {
-        case .value:
-            return enteredCell(text, columnIndex: columnIndex).map {
-                FillColumnContent.value($0.value, isExpression: $0.isExpression)
-            }
-        case .null:
-            return .value(.null)
-        case .uuid(let version):
-            return fillUUIDForm(columnIndex: columnIndex, in: tableRowsProvider()).map {
-                FillColumnContent.uuid(version, $0)
-            }
-        }
-    }
-
-    private func fillUUIDForm(columnIndex: Int, in tableRows: TableRows) -> UUIDCellForm? {
-        setValueContext(forColumn: columnIndex, rowIsInserted: false, in: tableRows)
-            .flatMap { SetValueOptions.uuidForm(for: $0) }
-    }
-
-    static func fillImpactDescription(rowCount: Int) -> String {
-        if rowCount == 1 {
-            return String(localized: "This sets 1 loaded row. Review and Save to apply.")
-        }
-        return String(
-            format: String(localized: "This sets %lld loaded rows. Review and Save to apply."),
-            Int64(rowCount)
-        )
-    }
-}
-
-/// Value, NULL and the UUIDs are radio buttons with one superview and one action, which AppKit groups by itself.
-@MainActor
-private final class FillColumnAccessoryView: NSView {
-    private static let width: CGFloat = 260
-    private static let valueRowHeight: CGFloat = 24
-    private static let choiceRowHeight: CGFloat = 22
-
-    private let valueField = NSTextField(frame: .zero)
-    private var radios: [(choice: FillColumnChoice, button: NSButton)] = []
-
-    init(choices: [FillColumnChoice]) {
-        let others = choices.filter { $0 != .value }
-        let height = Self.valueRowHeight + CGFloat(others.count) * Self.choiceRowHeight
-        super.init(frame: NSRect(x: 0, y: 0, width: Self.width, height: height))
-
-        valueField.usesSingleLineMode = true
-        valueField.placeholderString = String(localized: "Value")
-        addSubview(valueField)
-
-        let valueRowY = height - Self.valueRowHeight
-        guard !others.isEmpty else {
-            valueField.frame = NSRect(x: 0, y: valueRowY, width: Self.width, height: Self.valueRowHeight)
-            return
-        }
-
-        let valueRadio = addRadio(.value, at: valueRowY, rowHeight: Self.valueRowHeight)
-        valueRadio.state = .on
-        let fieldX = valueRadio.frame.maxX + 6
-        valueField.frame = NSRect(
-            x: fieldX, y: valueRowY, width: Self.width - fieldX, height: Self.valueRowHeight
-        )
-        for (index, choice) in others.enumerated() {
-            addRadio(choice, at: valueRowY - CGFloat(index + 1) * Self.choiceRowHeight, rowHeight: Self.choiceRowHeight)
-        }
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-    }
-
-    var enteredText: String { valueField.stringValue }
-
-    var choice: FillColumnChoice {
-        radios.first { $0.button.state == .on }?.choice ?? .value
-    }
-
-    var firstResponderView: NSView { valueField }
-
-    @discardableResult
-    private func addRadio(_ choice: FillColumnChoice, at rowY: CGFloat, rowHeight: CGFloat) -> NSButton {
-        let button = NSButton(radioButtonWithTitle: Self.title(for: choice), target: self, action: #selector(choiceChanged))
-        button.sizeToFit()
-        button.frame.origin = NSPoint(x: 0, y: rowY + (rowHeight - button.frame.height) / 2)
-        addSubview(button)
-        radios.append((choice, button))
-        return button
-    }
-
-    private static func title(for choice: FillColumnChoice) -> String {
-        switch choice {
-        case .value: String(localized: "Value")
-        case .null: String(localized: "NULL")
-        case .uuid(.v4): String(localized: "New UUID")
-        case .uuid(.v7): String(localized: "New UUIDv7")
-        }
-    }
-
-    @objc private func choiceChanged() {
-        valueField.isEnabled = choice == .value
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+FrozenColumns.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+FrozenColumns.swift
deleted file mode 100644
index 0ba457e190..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+FrozenColumns.swift
+++ /dev/null
@@ -1,105 +0,0 @@
-//
-//  DataGridView+FrozenColumns.swift
-//  TablePro
-//
-
-import AppKit
-
-extension TableViewCoordinator {
-    func pinnedBand() -> DataGridPinnedBand {
-        guard let tableView, let clipView = tableView.enclosingScrollView?.contentView else { return .none }
-        let gutterWidth = DataGridRowGutterView.width(of: tableView)
-        let offset = clipView.bounds.minX
-        // Rows leave frozen cells to the band, so without a band view nothing is frozen.
-        let frozen = rowGutter == nil ? IndexSet() : frozenTableColumnIndexes()
-        guard let last = frozen.last else {
-            return DataGridPinnedBand(gutterWidth: gutterWidth, width: gutterWidth, frozenColumns: [], offset: offset)
-        }
-        return DataGridPinnedBand.resolve(
-            gutterWidth: gutterWidth,
-            frozenColumns: frozen,
-            frozenTrailingEdge: tableView.rect(ofColumn: last).maxX,
-            viewportWidth: clipView.bounds.width,
-            offset: offset
-        )
-    }
-
-    // The band only while it freezes something, so a grid with nothing frozen pays one comparison.
-    func freezingBand() -> DataGridPinnedBand? {
-        guard frozenColumnCount > 0 else { return nil }
-        let band = pinnedBand()
-        return band.isFreezing ? band : nil
-    }
-
-    private func frozenTableColumnIndexes() -> IndexSet {
-        let count = min(frozenColumnCount, presentedColumnCount)
-        guard count > 0 else { return [] }
-        var indexes = IndexSet()
-        for position in 0..<count {
-            guard let index = tableColumnIndex(forDisplayPosition: position) else { continue }
-            indexes.insert(index)
-        }
-        return indexes
-    }
-
-    func displayedRect(ofColumn tableColumnIndex: Int) -> NSRect {
-        guard let tableView else { return .zero }
-        let rect = tableView.rect(ofColumn: tableColumnIndex)
-        return freezingBand()?.displayed(rect, ofColumn: tableColumnIndex) ?? rect
-    }
-
-    func cellRect(row: Int, tableColumnIndex: Int) -> NSRect {
-        guard let tableView else { return .zero }
-        return tableView.rect(ofRow: row).intersection(displayedRect(ofColumn: tableColumnIndex))
-    }
-
-    func canFreezeColumns(throughDisplayPosition position: Int) -> Bool {
-        guard let tableView,
-              let clipView = tableView.enclosingScrollView?.contentView,
-              let index = tableColumnIndex(forDisplayPosition: position) else { return false }
-        return DataGridPinnedBand.fits(width: tableView.rect(ofColumn: index).maxX, viewportWidth: clipView.bounds.width)
-    }
-
-    func freezeColumns(throughDisplayPosition position: Int) {
-        guard position >= 0 else { return }
-        setFrozenColumnCount(position + 1)
-    }
-
-    func unfreezeColumns() {
-        setFrozenColumnCount(0)
-    }
-
-    private func setFrozenColumnCount(_ count: Int) {
-        guard count != frozenColumnCount else { return }
-        frozenColumnCount = count
-        hasUnpersistedColumnLayoutChanges = true
-        persistColumnLayoutToStorage()
-    }
-
-    func frozenColumnsDidChange() {
-        columnGeometryDidChange()
-        tableView?.headerView?.needsDisplay = true
-    }
-
-    // A clip resize can move the band across the fit limit with no column change at all.
-    func pinnedBandLayoutDidChange() {
-        redrawVisibleCells()
-        tableView?.headerView?.needsDisplay = true
-        selectionController.overlay?.needsDisplay = true
-    }
-
-    // Rows draw no frozen cell while the band holds them, so a row repaint has to reach the band.
-    func pinnedBandNeedsDisplay(rowRect rect: NSRect, row: Int) {
-        guard let tableView, frozenColumnCount > 0, row >= 0, row < tableView.numberOfRows else { return }
-        pinnedBandNeedsDisplay(tableRect: rect.offsetBy(dx: 0, dy: tableView.rect(ofRow: row).minY))
-    }
-
-    func pinnedBandNeedsDisplay(tableRect rect: NSRect) {
-        guard let tableView, let rowGutter, let band = freezingBand() else { return }
-        let minX = max(rect.minX, 0)
-        let maxX = min(rect.maxX, band.width)
-        guard maxX > minX else { return }
-        let inBand = rowGutter.convert(NSRect(x: 0, y: rect.minY, width: 1, height: rect.height), from: tableView)
-        rowGutter.setNeedsDisplay(NSRect(x: minX, y: inBand.minY, width: maxX - minX, height: inBand.height))
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+MountState.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+MountState.swift
deleted file mode 100644
index c70a09e454..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+MountState.swift
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-//  DataGridView+MountState.swift
-//  TablePro
-//
-//  The viewport and selection a grid hands to an owner that outlives it, and takes back on the
-//  next mount.
-//
-//  SwiftUI destroys `TableViewCoordinator` whenever the grid leaves the view tree, and the editor
-//  mounts the grid as `.id(tab.id)`, so a tab switch and a result-mode switch both rebuild it from
-//  nothing. Anything here that is not handed over first is gone.
-//
-
-import AppKit
-import Foundation
-
-extension TableViewCoordinator {
-    var scrollAnchorRow: Int { pendingScrollAnchorRow ?? 0 }
-
-    /// Records where the user was looking, so returning to this tab does not start at the first row.
-    func recordScrollAnchor() {
-        guard let tableView else { return }
-        let visible = tableView.rows(in: tableView.visibleRect)
-        displayState.firstVisibleRow = max(0, visible.location)
-    }
-
-    /// `scrollRowToVisible` only guarantees visibility, so from a grid scrolled to the top it puts
-    /// the anchor at the bottom of the viewport rather than back where the user left it.
-    func restoreScrollAnchor() {
-        guard let tableView, let row = pendingScrollAnchorRow else { return }
-        pendingScrollAnchorRow = nil
-        guard row > 0, row < tableView.numberOfRows else { return }
-        let origin = tableView.rect(ofRow: row).origin
-        let x = tableView.enclosingScrollView?.contentView.bounds.origin.x ?? 0
-        tableView.scroll(NSPoint(x: x, y: origin.y))
-    }
-
-    /// Hands this grid's selection to an owner that outlives it, on the way out.
-    ///
-    /// Read from this grid's own table view rather than from the shared `GridSelectionState`, which
-    /// by teardown time can already describe the tab being switched to. That also makes an owner
-    /// check unnecessary: a data grid's table view only ever holds data-grid positions.
-    ///
-    /// The rows are passed alongside the cell rectangle rather than derived from it, because a cell
-    /// drag pins `selectedRowIndexes` to its anchor row and only the rectangle knows the rest.
-    func captureSelectionForTeardown() {
-        guard let onSelectionTeardown else { return }
-        let rows = tableView.map { Set($0.selectedRowIndexes) } ?? []
-        onSelectionTeardown(rows, selectionController.selection)
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Popovers.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Popovers.swift
deleted file mode 100644
index 7883b8f00d..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Popovers.swift
+++ /dev/null
@@ -1,793 +0,0 @@
-//
-//  DataGridView+Popovers.swift
-//  TablePro
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-
-// MARK: - Popover Editors
-
-extension TableViewCoordinator {
-    func cellValue(at row: Int, column columnIndex: Int) -> String? {
-        guard let displayRow = displayRow(at: row), columnIndex >= 0, columnIndex < displayRow.values.count else {
-            return nil
-        }
-        return displayRow.values[columnIndex].asText
-    }
-
-    func cellTypedValue(at row: Int, column columnIndex: Int) -> PluginCellValue {
-        guard let displayRow = displayRow(at: row), columnIndex >= 0, columnIndex < displayRow.values.count else {
-            return .null
-        }
-        return displayRow.values[columnIndex]
-    }
-
-    func toggleForeignKeyPreview(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        if let popover = activeFKPreviewPopover, popover.isShown {
-            popover.close()
-            clearFKPreviewState()
-            return
-        }
-        showForeignKeyPreview(tableView: tableView, row: row, column: column, columnIndex: columnIndex)
-    }
-
-    /// The grid's own scope, which every foreign key affordance on it has to start from.
-    ///
-    /// The picker and the preview are two reads of one cell, so they resolve their target from one
-    /// expression rather than two: built separately they drift, and a preview that resolves its
-    /// target differently from the picker beside it reads one table while offering another's rows.
-    /// The tab's own database comes first, because a tab stays where it opened while the sidebar
-    /// moves; the browse cursor is the fallback for a grid that never carried one.
-    var gridOriginScope: DatabaseScope? {
-        guard let connectionId else { return nil }
-        return DatabaseScope(
-            connectionId: connectionId,
-            database: databaseName ?? DatabaseManager.shared.browseScope(for: connectionId)?.database ?? "",
-            schema: schemaName
-        )
-    }
-
-    func showForeignKeyPreview(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-        guard let fkInfo = tableRows.columnForeignKeys[columnName] else { return }
-        let cellValue = cellValue(at: row, column: columnIndex)
-        guard let databaseType, connectionId != nil else { return }
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        guard let scope = gridOriginScope else { return }
-
-        let model = FKPreviewModel(cellValue: cellValue, fkInfo: fkInfo)
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        let popover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: NSSize(width: 380, height: 400)
-        ) { [weak self] dismiss in
-            ForeignKeyPreviewView(
-                model: model,
-                scope: scope,
-                databaseType: databaseType,
-                onNavigate: { [weak self, model] in
-                    dismiss()
-                    guard let value = model.cellValue else { return }
-                    self?.delegate?.dataGridNavigateFK(value: value, fkInfo: model.fkInfo, intent: .follow)
-                },
-                onDismiss: dismiss
-            )
-        }
-        activeFKPreviewPopover = popover
-        activeFKPreviewModel = model
-        activeFKPreviewColumnIndex = columnIndex
-    }
-
-    func clearFKPreviewState() {
-        activeFKPreviewPopover = nil
-        activeFKPreviewModel = nil
-        activeFKPreviewColumnIndex = nil
-    }
-
-    func refreshFKPreviewForRowChange() {
-        guard let popover = activeFKPreviewPopover, popover.isShown,
-              let model = activeFKPreviewModel,
-              let columnIndex = activeFKPreviewColumnIndex,
-              let tableView else {
-            return
-        }
-        let focusedRow = (tableView as? KeyHandlingTableView)?.focusedRow ?? -1
-        let newRow = focusedRow >= 0 ? focusedRow : (tableView.selectedRowIndexes.max() ?? -1)
-        guard newRow >= 0,
-              let tableColumnIndex = tableColumnIndex(for: columnIndex) else {
-            popover.close()
-            clearFKPreviewState()
-            return
-        }
-        let tableRows = tableRowsProvider()
-        guard columnIndex < tableRows.columns.count,
-              let fkInfo = tableRows.columnForeignKeys[tableRows.columns[columnIndex]] else {
-            popover.close()
-            clearFKPreviewState()
-            return
-        }
-        let newValue = cellValue(at: newRow, column: columnIndex)
-        let newRect = self.cellRect(row: newRow, tableColumnIndex: tableColumnIndex)
-        guard !newRect.isEmpty else {
-            popover.close()
-            clearFKPreviewState()
-            return
-        }
-        model.cellValue = newValue
-        model.fkInfo = fkInfo
-        popover.positioningRect = newRect
-    }
-
-    func dismissFKPreviewOnColumnChange() {
-        guard let popover = activeFKPreviewPopover, popover.isShown else { return }
-        popover.close()
-        clearFKPreviewState()
-    }
-
-    func showJSONEditorPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        let currentValue = cellValue(at: row, column: columnIndex)
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        /// The editor is bound to the record, not to the position it was opened from: a sort, a
-        /// value filter or a page change moves another record under that position, and the detached
-        /// window outlives all three.
-        let rowID = displayRow(at: row)?.id
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: NSSize(width: 560, height: 420)
-        ) { [weak self] dismiss in
-            JSONEditorContentView(
-                initialValue: currentValue,
-                columnName: columnName,
-                onCommit: { newValue in
-                    self?.commitCellEdit(rowID: rowID, fallbackDisplayRow: row, columnIndex: columnIndex, newValue: newValue)
-                },
-                onDismiss: dismiss,
-                onPopOut: { currentText in
-                    dismiss()
-                    self?.dismissPoppedOutCellEditor()
-                    /// The popover's text can hold an edit its own Save never wrote, so the window
-                    /// compares against the cell rather than against the text it opens on.
-                    self?.activePoppedOutEditor = JSONViewerWindowController.open(
-                        text: currentText,
-                        baseline: currentValue,
-                        columnName: columnName,
-                        isEditable: true,
-                        onCommit: { newValue in
-                            self?.commitCellEdit(rowID: rowID, fallbackDisplayRow: row, columnIndex: columnIndex, newValue: newValue)
-                        }
-                    )
-                }
-            )
-        }
-    }
-
-    /// A grid with no row identity to offer falls back to the display row it was opened from, which
-    /// is what every editor did before.
-    func commitCellEdit(rowID: RowID?, fallbackDisplayRow: Int, columnIndex: Int, newValue: String?) {
-        guard let rowID else {
-            commitCellEdit(row: fallbackDisplayRow, columnIndex: columnIndex, newValue: newValue)
-            return
-        }
-        commitCellEdit(rowID: rowID, columnIndex: columnIndex, newValue: newValue)
-    }
-
-    func showBlobEditorPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        let currentValue = blobStringValue(at: row, columnIndex: columnIndex)
-        let columnName = columnName(at: columnIndex)
-        let image = blobImage(at: row, columnIndex: columnIndex)
-
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: nil
-        ) { [weak self] dismiss in
-            BlobPopoverContentView(
-                initialValue: currentValue,
-                image: image,
-                columnName: columnName,
-                isEditable: true,
-                onCommit: { newValue in
-                    self?.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-                },
-                onCommitBytes: { data in
-                    self?.commitBinaryEdit(row: row, columnIndex: columnIndex, data: data)
-                },
-                onDismiss: dismiss
-            )
-        }
-    }
-
-    /// A date control has no vocabulary for "I could not read this": `NSDatePicker.dateValue` and
-    /// every SwiftUI `DatePicker` binding are a non-optional `Date`, so a cell the parser rejects
-    /// gets seeded with today and an unchanged confirm writes today over the stored value in a
-    /// spelling the column never used. Such a cell goes to the text editor instead, where the value
-    /// stays visible and the user can repair it. An empty cell has nothing to misrepresent and keeps
-    /// the picker.
-    func opensDatePicker(row: Int, columnIndex: Int) -> Bool {
-        guard let value = cellValue(at: row, column: columnIndex),
-              !value.trimmingCharacters(in: .whitespaces).isEmpty
-        else { return true }
-        return DatabaseDateParser.parse(value) != nil
-    }
-
-    func showDateTimePickerPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columnTypes.count else { return }
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let columnType = tableRows.columnTypes[columnIndex]
-        let parsed = DatabaseDateParser.parse(cellValue(at: row, column: columnIndex))
-        /// The whole second, not the instant: a fraction near one second rounds the `Double` up, so
-        /// the picker would open a second, and sometimes a day, past the value the cell shows.
-        let initialDate = parsed?.wholeSecond ?? Date()
-        let timeZone = parsed?.timeZone ?? DateEditingService.defaultTimeZone
-        let components = DateEditingService.components(for: columnType)
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView
-        ) { [weak self] dismiss in
-            DateTimePickerContentView(
-                initialDate: initialDate,
-                components: components,
-                timeZone: timeZone,
-                carriesItsOwnZone: parsed?.carriesItsOwnZone ?? false,
-                onCommit: { picked in
-                    guard picked != initialDate else { return }
-                    let newValue = parsed
-                        .map { DateEditingService.string(from: picked, like: $0, offered: components) }
-                        ?? DateEditingService.defaultString(from: picked, columnType: columnType)
-                    self?.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-                },
-                onDismiss: dismiss
-            )
-        }
-    }
-
-    func showEnumPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-        guard let allowedValues = tableRows.columnEnumValues[columnName] else { return }
-
-        let currentValue = cellValue(at: row, column: columnIndex)
-        let isNullable = tableRows.columnNullable[columnName] ?? true
-        // The picker matches against the enum's own unquoted tokens, so the column default crosses
-        // out of SQL here. It arrives as the exact SQL after DEFAULT, which for a string default is
-        // quoted, and a quoted value matched no entry so the default badge was never drawn.
-        let storedDefault = tableRows.columnDefaults[columnName] ?? nil
-        let defaultValue = storedDefault.flatMap(SQLStringLiteral.unquoted) ?? storedDefault
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        EnumMenuPicker.presentEnum(
-            relativeTo: cellRect,
-            in: tableView,
-            allowedValues: allowedValues,
-            currentValue: currentValue,
-            isNullable: isNullable,
-            defaultValue: defaultValue
-        ) { [weak self] newValue in
-            self?.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-        }
-    }
-
-    /// The value picker a writable foreign key cell opens in place of the plain text editor.
-    ///
-    /// Falls back to that editor whenever the picker cannot be built, the way the array editor falls
-    /// back on a literal it cannot parse: an engine with no SQL dialect has nothing to search the
-    /// referenced table with, a column of a composite key cannot be picked on its own, and a cell
-    /// that opens nothing at all reads as a broken grid.
-    ///
-    /// `canStartInlineEdit` is asked again here because `CellInteractionResolver` knows only the
-    /// columns the plugin declares immutable. A generated column carrying foreign key metadata,
-    /// which SQLite allows, would otherwise open the picker and have its commit dropped by
-    /// `recordCellEdit`, closing the popover over a cell that never changed.
-    func showForeignKeyPicker(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-
-        guard connectionId != nil,
-              let databaseType,
-              let fkInfo = tableRows.columnForeignKeys[columnName],
-              canStartInlineEdit(row: row, columnIndex: columnIndex),
-              PluginManager.shared.sqlDialect(for: databaseType) != nil,
-              !ForeignKeyConstraintSpan.isMultiColumn(fkInfo, among: tableRows.columnForeignKeys)
-        else {
-            beginCellEdit(row: row, tableColumnIndex: column)
-            return
-        }
-
-        guard let scope = gridOriginScope else {
-            beginCellEdit(row: row, tableColumnIndex: column)
-            return
-        }
-
-        let currentValue = cellValue(at: row, column: columnIndex)
-        let isNullable = tableRows.columnNullable[columnName] ?? true
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView
-        ) { [weak self] dismiss in
-            ForeignKeyPickerView(
-                scope: scope,
-                databaseType: databaseType,
-                fkInfo: fkInfo,
-                currentValue: currentValue,
-                isNullable: isNullable,
-                onCommit: { newValue in
-                    self?.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-                },
-                onDismiss: dismiss
-            )
-        }
-    }
-
-    func showSetPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-        guard let allowedValues = tableRows.columnEnumValues[columnName] else { return }
-
-        let currentValue = cellValue(at: row, column: columnIndex)
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        EnumMenuPicker.presentSet(
-            relativeTo: cellRect,
-            in: tableView,
-            allowedValues: allowedValues,
-            currentCsv: currentValue
-        ) { [weak self] newValue in
-            self?.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-        }
-    }
-
-    func showArrayEditorPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0,
-              columnIndex < tableRows.columns.count,
-              columnIndex < tableRows.columnTypes.count
-        else { return }
-        let columnName = tableRows.columns[columnIndex]
-
-        let columnType = tableRows.columnTypes[columnIndex]
-        let delimiter = PostgresArrayDelimiter.forColumn(columnType)
-        let typedValue = cellTypedValue(at: row, column: columnIndex)
-        let literal: String?
-        if typedValue.isNull {
-            literal = nil
-        } else {
-            let stored = typedValue.asText ?? ""
-            guard PostgresArrayLiteralCodec.parse(stored, delimiter: delimiter) != nil else {
-                beginCellEdit(row: row, tableColumnIndex: column)
-                return
-            }
-            literal = stored
-        }
-
-        let allowedValues = tableRows.columnEnumValues[columnName] ?? []
-        let isNullable = tableRows.columnNullable[columnName] ?? true
-        let elementEditor = columnType.arrayElementEditor ?? .scalar
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            behavior: .applicationDefined
-        ) { [weak self] dismiss in
-            ArrayValueEditorView(
-                literal: literal,
-                allowedValues: allowedValues,
-                isNullable: isNullable,
-                delimiter: delimiter,
-                elementEditor: elementEditor,
-                onCommit: { newValue in
-                    self?.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-                },
-                onDismiss: dismiss
-            )
-        }
-    }
-
-    func showVectorPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int, isEditable: Bool) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columnTypes.count else { return }
-        guard let literal = cellTypedValue(at: row, column: columnIndex).asText,
-              VectorLiteral.isVectorText(literal) else {
-            if isEditable { beginCellEdit(row: row, tableColumnIndex: column) }
-            return
-        }
-
-        // Bound to the record, as the JSON editor is: a sort or a filter can move another row under this position.
-        let rowID = displayRow(at: row)?.id
-        let expectedDimensions = tableRows.columnTypes[columnIndex].vectorDimensions
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            behavior: isEditable ? .applicationDefined : .semitransient
-        ) { [weak self] dismiss in
-            VectorValueView(
-                literal: literal,
-                expectedDimensions: expectedDimensions,
-                isEditable: isEditable,
-                onCommit: { newValue in
-                    self?.commitCellEdit(rowID: rowID, fallbackDisplayRow: row, columnIndex: columnIndex, newValue: newValue)
-                },
-                onDismiss: dismiss
-            )
-        }
-    }
-
-    /// Only one cell editor popover is open at a time, and the outgoing one is closed before the
-    /// next is presented rather than after. An `.applicationDefined` popover such as the array
-    /// editor stays on screen until something closes it, so forgetting it would strand an editor
-    /// nothing can dismiss, and closing it once the replacement is already up takes first responder
-    /// back off the editor that just opened.
-    func dismissActiveCellEditorPopover() {
-        guard let popover = activeCellEditorPopover else { return }
-        activeCellEditorPopover = nil
-        popover.close()
-    }
-
-    /// The popped-out JSON editor is a window rather than a popover, so it survives everything that
-    /// closes a popover. It commits by row identity, so a sort or a value filter leaves it writing
-    /// the record it was opened for; a replaced row set retires those ids, which is what invalidates
-    /// it.
-    func dismissPoppedOutCellEditor() {
-        guard let editor = activePoppedOutEditor else { return }
-        activePoppedOutEditor = nil
-        editor.close()
-    }
-
-    /// A column the owner listed as a dropdown but supplied no fixed vocabulary for. Its list comes
-    /// from the delegate per row, so a nil answer means "nothing to offer here", not "fall back".
-    private func declaresRowDependentMenu(columnIndex: Int) -> Bool {
-        dropdownColumns?.contains(columnIndex) == true && customDropdownOptions?[columnIndex] == nil
-    }
-
-    func showDropdownMenu(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-
-        let currentValue = cellValue(at: row, column: columnIndex)
-        /// The delegate is asked first, because a list that depends on the row cannot be held in a
-        /// dictionary keyed by column. Either answer counts as custom, so a curated vocabulary never
-        /// gains a `Set NULL` the schema grids have no use for.
-        let custom = delegate?.dataGridMenuOptions(forRow: row, columnIndex: columnIndex)
-            ?? customDropdownOptions?[columnIndex]
-
-        /// The boolean pair is the fallback for a cell whose column is a boolean, not for a column
-        /// that declared a chevron and then had no list to show. A schema grid does the latter
-        /// whenever its delegate declines the row, and offering `1` and `0` there writes a digit
-        /// into a name.
-        let options: [GridMenuOption]
-        if let custom {
-            options = custom
-        } else if declaresRowDependentMenu(columnIndex: columnIndex) {
-            return
-        } else if let dbType = databaseType, PluginManager.shared.usesTrueFalseBooleans(for: dbType) {
-            options = GridMenuOption.values(["true", "false"])
-        } else {
-            options = GridMenuOption.values(["1", "0"])
-        }
-
-        let menu = NSMenu()
-        for option in options {
-            menu.addItem(menuItem(for: option, row: row, columnIndex: columnIndex, currentValue: currentValue))
-        }
-
-        let columnName = tableRows.columns[columnIndex]
-        let isNullable = tableRows.columnNullable[columnName] ?? true
-        if isNullable && custom == nil {
-            menu.addItem(.separator())
-            let nullItem = NSMenuItem(
-                title: String(localized: "Set NULL"),
-                action: #selector(dropdownMenuNullSelected(_:)),
-                keyEquivalent: ""
-            )
-            nullItem.target = self
-            nullItem.representedObject = DropdownMenuContext(row: row, columnIndex: columnIndex)
-            if currentValue == nil {
-                nullItem.state = .on
-            }
-            menu.addItem(nullItem)
-        }
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        menu.popUp(positioning: nil, at: NSPoint(x: cellRect.minX, y: cellRect.maxY), in: tableView)
-    }
-
-    /// A section header is a menu item AppKit draws itself, not a separator with a label, so the
-    /// grouping reads to VoiceOver as a group rather than as an unselectable entry.
-    private func menuItem(
-        for option: GridMenuOption,
-        row: Int,
-        columnIndex: Int,
-        currentValue: String?
-    ) -> NSMenuItem {
-        switch option {
-        case .sectionHeader(let title):
-            return NSMenuItem.sectionHeaderCompat(title: title)
-        case .value(let title, let sql):
-            let item = NSMenuItem(title: title, action: #selector(dropdownMenuItemSelected(_:)), keyEquivalent: "")
-            item.target = self
-            item.representedObject = DropdownMenuContext(row: row, columnIndex: columnIndex, sql: sql)
-            if sql == currentValue {
-                item.state = .on
-            }
-            return item
-        case .clear(let title):
-            let item = NSMenuItem(title: title, action: #selector(dropdownMenuNullSelected(_:)), keyEquivalent: "")
-            item.target = self
-            item.representedObject = DropdownMenuContext(row: row, columnIndex: columnIndex)
-            if currentValue == nil {
-                item.state = .on
-            }
-            return item
-        case .custom(let title):
-            let item = NSMenuItem(title: title, action: #selector(dropdownMenuCustomSelected(_:)), keyEquivalent: "")
-            item.target = self
-            item.representedObject = DropdownMenuContext(row: row, columnIndex: columnIndex)
-            return item
-        }
-    }
-
-    @objc func dropdownMenuItemSelected(_ sender: NSMenuItem) {
-        guard let context = sender.representedObject as? DropdownMenuContext else { return }
-        commitPopoverEdit(row: context.row, columnIndex: context.columnIndex, newValue: context.sql ?? sender.title)
-    }
-
-    @objc func dropdownMenuCustomSelected(_ sender: NSMenuItem) {
-        guard let context = sender.representedObject as? DropdownMenuContext else { return }
-        showCustomValuePopover(row: context.row, columnIndex: context.columnIndex)
-    }
-
-    @objc func dropdownMenuNullSelected(_ sender: NSMenuItem) {
-        guard let context = sender.representedObject as? DropdownMenuContext else { return }
-        commitPopoverEdit(row: context.row, columnIndex: context.columnIndex, newValue: nil)
-    }
-
-    func commitPopoverEdit(row: Int, columnIndex: Int, newValue: String?) {
-        commitCellEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-    }
-
-    func commitBinaryEdit(row: Int, columnIndex: Int, data: Data) {
-        commitTypedCellEdit(row: row, columnIndex: columnIndex, newValue: .bytes(data))
-    }
-
-    func showJSONViewerPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        let currentValue = cellValue(at: row, column: columnIndex)
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: NSSize(width: 560, height: 360)
-        ) { dismiss in
-            JSONViewerContentView(
-                initialValue: currentValue,
-                columnName: columnName,
-                onDismiss: dismiss,
-                onPopOut: { currentText in
-                    dismiss()
-                    JSONViewerWindowController.open(
-                        text: currentText,
-                        columnName: columnName,
-                        isEditable: false,
-                        onCommit: nil
-                    )
-                }
-            )
-        }
-    }
-
-    func showPhpViewerPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        let currentValue = cellValue(at: row, column: columnIndex)
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return }
-        let columnName = tableRows.columns[columnIndex]
-
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: NSSize(width: 560, height: 360)
-        ) { dismiss in
-            PhpViewerContentView(
-                initialValue: currentValue,
-                columnName: columnName,
-                onDismiss: dismiss,
-                onPopOut: { currentText in
-                    dismiss()
-                    PhpViewerWindowController.open(text: currentText, columnName: columnName)
-                }
-            )
-        }
-    }
-
-    func showBinaryValueViewerPopover(
-        tableView: NSTableView,
-        row: Int,
-        column: Int,
-        columnIndex: Int,
-        format: BinaryValueFormat
-    ) {
-        let data: Data
-        switch cellTypedValue(at: row, column: columnIndex) {
-        case .null: return
-        case .bytes(let bytes): data = bytes
-        case .text(let text): data = text.storedBytes
-        }
-        let columnName = columnName(at: columnIndex)
-
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let cellRect = tableView.rect(ofRow: row).intersection(tableView.rect(ofColumn: column))
-        PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: NSSize(width: 560, height: 360)
-        ) { dismiss in
-            BinaryValueViewerView(
-                data: data,
-                format: format,
-                onPopOut: {
-                    dismiss()
-                    BinaryValueViewerWindowController.open(data: data, format: format, columnName: columnName)
-                }
-            )
-            .frame(width: 560)
-            .frame(minHeight: 200, maxHeight: 480)
-        }
-    }
-
-    func showBlobViewerPopover(tableView: NSTableView, row: Int, column: Int, columnIndex: Int) {
-        let currentValue = blobStringValue(at: row, columnIndex: columnIndex)
-        let columnName = columnName(at: columnIndex)
-        let image = blobImage(at: row, columnIndex: columnIndex)
-
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: nil
-        ) { dismiss in
-            BlobPopoverContentView(
-                initialValue: currentValue,
-                image: image,
-                columnName: columnName,
-                isEditable: false,
-                onDismiss: dismiss
-            )
-        }
-    }
-
-    func showSvgViewerPopover(
-        tableView: NSTableView,
-        row: Int,
-        column: Int,
-        columnIndex: Int,
-        isEditable: Bool
-    ) {
-        guard presentsCell(row: row, tableColumnIndex: column) else { return }
-        let columnName = columnName(at: columnIndex)
-        let value = cellValue(at: row, column: columnIndex) ?? ""
-
-        let cellRect = self.cellRect(row: row, tableColumnIndex: column)
-        dismissActiveCellEditorPopover()
-        activeCellEditorPopover = PopoverPresenter.show(
-            relativeTo: cellRect,
-            of: tableView,
-            contentSize: nil
-        ) { [weak self] dismiss in
-            SvgViewerContentView(
-                initialValue: value,
-                isEditable: isEditable,
-                onDismiss: dismiss,
-                onCommit: isEditable ? { newValue in
-                    self?.commitPopoverEdit(row: row, columnIndex: columnIndex, newValue: newValue)
-                } : nil,
-                onPopOut: { currentText in
-                    dismiss()
-                    CellImageWindowController.open(
-                        data: Data(currentText.utf8),
-                        format: .svg,
-                        sourceKind: .markup,
-                        columnName: columnName
-                    )
-                }
-            )
-        }
-    }
-
-    private func displayFormatOverride(at columnIndex: Int) -> ValueDisplayFormat? {
-        guard columnIndex >= 0, columnIndex < columnDisplayFormats.count else { return nil }
-        return columnDisplayFormats[columnIndex]
-    }
-
-    private func columnName(at columnIndex: Int) -> String? {
-        let tableRows = tableRowsProvider()
-        guard columnIndex >= 0, columnIndex < tableRows.columns.count else { return nil }
-        return tableRows.columns[columnIndex]
-    }
-
-    /// The cell's stored bytes paired with what they turned out to be, or nil when they are not an
-    /// image or the column asked for its value raw.
-    private func blobImage(at row: Int, columnIndex: Int) -> CellImageValue? {
-        guard displayFormatOverride(at: columnIndex) != .raw else { return nil }
-        let value = cellTypedValue(at: row, column: columnIndex)
-        switch value {
-        case .null:
-            return nil
-        case .bytes(let bytes):
-            guard let format = CellImageSniffer.format(of: bytes) else { return nil }
-            return CellImageValue(data: bytes, format: format)
-        case .text(let text):
-            guard let format = CellImageSniffer.format(ofText: text) else { return nil }
-            return CellImageValue(data: text.storedBytes, format: format)
-        }
-    }
-
-    private func blobStringValue(at row: Int, columnIndex: Int) -> String? {
-        switch cellTypedValue(at: row, column: columnIndex) {
-        case .null: return nil
-        case .text(let text): return text
-        case .bytes(let data): return String(data: data, encoding: .isoLatin1)
-        }
-    }
-}
-
-private final class DropdownMenuContext {
-    let row: Int
-    let columnIndex: Int
-    /// What the item sets the cell to. It is not the item's title wherever the value is not its own
-    /// best label, which is every entry a `GridMenuOption.value` gives a separate title.
-    let sql: String?
-
-    init(row: Int, columnIndex: Int, sql: String? = nil) {
-        self.row = row
-        self.columnIndex = columnIndex
-        self.sql = sql
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Prewarm.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Prewarm.swift
deleted file mode 100644
index e6f488e5ab..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Prewarm.swift
+++ /dev/null
@@ -1,141 +0,0 @@
-//
-//  DataGridView+Prewarm.swift
-//  TablePro
-//
-//  Filling the grid's formatted-text cache ahead of the viewport, and following the viewport as it
-//  moves.
-//
-
-import AppKit
-import Foundation
-
-extension TableViewCoordinator {
-    func preWarmDisplayCache(rowCount: Int, from startIndex: Int = 0) {
-        let tableRows = tableRowsProvider()
-        let displayCount = displayIDs?.count ?? tableRows.count
-        let lower = max(0, min(startIndex, displayCount))
-        let upper = min(displayCount, lower + max(0, rowCount))
-        guard lower < upper else { return }
-        for displayIndex in lower..<upper {
-            cacheDisplayRow(at: displayIndex, in: tableRows)
-        }
-    }
-
-    /// The rows the background prewarm is allowed to format, anchored on the viewport.
-    ///
-    /// A grid mounts on every tab switch, and an unanchored prewarm formatted every loaded row of
-    /// every column each time, so arriving at an already-loaded tab cost more the more rows it
-    /// held. A miss outside the window is filled by `displayValue(forID:column:rawValue:columnType:)`
-    /// while the row draws, so the window bounds the work without bounding what the grid can show.
-    func currentPrewarmWindow(displayCount: Int) -> Range<Int> {
-        guard let tableView else {
-            return DataGridPrewarmWindow.rows(around: 0..<0, displayCount: displayCount)
-        }
-        let visible = tableView.rows(in: tableView.visibleRect)
-        let lower = max(0, visible.location)
-        let upper = max(lower, visible.location + visible.length)
-        return DataGridPrewarmWindow.rows(around: lower..<upper, displayCount: displayCount)
-    }
-
-    /// Fills displayCache off the scroll hot path so viewFor:row: stays a cache hit.
-    func startBackgroundPrewarm() {
-        prewarmResumeTask?.cancel()
-        prewarmResumeTask = nil
-        prewarmTask?.cancel()
-        prewarmTask = Task { @MainActor [weak self] in
-            await self?.runBackgroundPrewarm()
-        }
-    }
-
-    /// Pauses prewarm during live scroll; resumes after a debounce so rapid scrolls do not restart it repeatedly.
-    func attachScrollObservers(scrollView: NSScrollView) {
-        detachScrollObservers()
-        let start = NotificationCenter.default.addObserver(
-            forName: NSScrollView.willStartLiveScrollNotification,
-            object: scrollView,
-            queue: .main
-        ) { [weak self] _ in
-            MainActor.assumeIsolated {
-                self?.pausePrewarmForScroll()
-            }
-        }
-        let end = NotificationCenter.default.addObserver(
-            forName: NSScrollView.didEndLiveScrollNotification,
-            object: scrollView,
-            queue: .main
-        ) { [weak self] _ in
-            MainActor.assumeIsolated {
-                self?.schedulePrewarmResume()
-            }
-        }
-        /// The clip view rather than the scroll view's live-scroll pair, because it is the only one
-        /// that also reports a programmatic scroll: `scrollRowToVisible`, which is how VoiceOver
-        /// reaches a row that is not on screen, and how Find Next and paging move the viewport. The
-        /// prewarm window is anchored on the viewport, so those have to re-anchor it too.
-        scrollView.contentView.postsBoundsChangedNotifications = true
-        let bounds = NotificationCenter.default.addObserver(
-            forName: NSView.boundsDidChangeNotification,
-            object: scrollView.contentView,
-            queue: .main
-        ) { [weak self, weak clipView = scrollView.contentView] _ in
-            MainActor.assumeIsolated {
-                let visible = clipView?.bounds
-                self?.remountAccessibilityCells()
-                /// The pinned gutter is repositioned by AppKit rather than redrawn, so a scroll that
-                /// exposes rows it has never drawn has to ask for them. A viewport of row numbers is
-                /// a fraction of what the rows themselves repaint on the same notification.
-                if let visible {
-                    self?.rowGutter?.viewportDidMove(to: visible)
-                } else {
-                    self?.repaintRowGutter()
-                }
-                self?.schedulePrewarmResume()
-            }
-        }
-        scrollObservers = [start, end, bounds]
-    }
-
-    func detachScrollObservers() {
-        for observer in scrollObservers {
-            NotificationCenter.default.removeObserver(observer)
-        }
-        scrollObservers.removeAll()
-    }
-
-    func pausePrewarmForScroll() {
-        prewarmResumeTask?.cancel()
-        prewarmResumeTask = nil
-        prewarmTask?.cancel()
-        prewarmTask = nil
-    }
-
-    func schedulePrewarmResume() {
-        prewarmResumeTask?.cancel()
-        prewarmResumeTask = Task { @MainActor [weak self] in
-            try? await Task.sleep(for: Self.prewarmResumeDelay)
-            guard !Task.isCancelled, let self else { return }
-            self.startBackgroundPrewarm()
-        }
-    }
-
-    func runBackgroundPrewarm() async {
-        var nextIndex: Int?
-        while !Task.isCancelled {
-            let tableRows = tableRowsProvider()
-            let displayCount = displayIDs?.count ?? tableRows.count
-            let window = currentPrewarmWindow(displayCount: displayCount)
-            var index = max(nextIndex ?? window.lowerBound, window.lowerBound)
-            guard index < window.upperBound else { return }
-
-            let deadline = ContinuousClock.now.advanced(by: Self.prewarmFrameBudget)
-            while index < window.upperBound {
-                if Task.isCancelled { return }
-                cacheDisplayRow(at: index, in: tableRows)
-                index += 1
-                if ContinuousClock.now >= deadline { break }
-            }
-            nextIndex = index
-            await Task.yield()
-        }
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+RowDecoration.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+RowDecoration.swift
deleted file mode 100644
index 5f3e5a6fab..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+RowDecoration.swift
+++ /dev/null
@@ -1,81 +0,0 @@
-//
-//  DataGridView+RowDecoration.swift
-//  TablePro
-//
-
-import AppKit
-
-extension TableViewCoordinator {
-    func refreshVisibleRowVisualStates() {
-        guard let tableView else { return }
-        tableView.enumerateAvailableRowViews { rowView, _ in
-            (rowView as? DataGridRowView)?.invalidateVisualState()
-        }
-    }
-
-    func refreshRowVisualState(at row: Int) {
-        guard let tableView,
-              let dataRowView = tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView
-        else { return }
-        dataRowView.invalidateVisualState()
-    }
-
-    @discardableResult
-    func syncHighlightRules(_ rules: [HighlightRule], tableRows: TableRows) -> Bool {
-        let key = HighlightRuleSet.Key(rules: rules, columns: tableRows.columns, columnTypes: tableRows.columnTypes)
-        let compiledChanged = highlightRuleSet.key != key
-        if compiledChanged {
-            highlightRuleSet = HighlightRuleSet(
-                rules: rules,
-                columns: tableRows.columns,
-                columnTypes: tableRows.columnTypes
-            )
-        }
-        guard displayState.highlightRuleSetKey != key else { return compiledChanged }
-        displayState.highlightRuleSetKey = key
-        displayCache.clearHighlights()
-        return true
-    }
-
-    func highlight(for row: Row) -> RowHighlight {
-        guard !highlightRuleSet.isEmpty else { return .none }
-        if let cached = displayCache.highlight(forID: row.id) { return cached }
-        let resolved = highlightRuleSet.highlight(for: row.values)
-        displayCache.setHighlight(resolved, forID: row.id)
-        return resolved
-    }
-
-    func pendingChangeDescription(row: Int, columnIndex: Int) -> String? {
-        DataGridCellTextMark.accessibilityDescription(state: visualState(for: row), columnIndex: columnIndex)
-    }
-
-    func highlightDescription(row: Int, columnIndex: Int) -> String? {
-        guard let rule = visualState(for: row).drawnHighlightRule(forColumn: columnIndex) else { return nil }
-        return HighlightRuleDescription.condition(of: rule, valueLimit: HighlightRuleDescription.menuValueLimit)
-    }
-
-    func invalidateRowDecoration(displayRow row: Int) {
-        guard let tableView, row >= 0, row < tableView.numberOfRows else { return }
-        if let rowView = tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView {
-            rowView.invalidateVisualState()
-            rowView.redrawCells()
-        }
-        repaintRowGutter(forRow: row)
-    }
-
-    func repaintVisibleRowDecorations() {
-        guard let tableView else { return }
-        tableView.enumerateAvailableRowViews { rowView, _ in
-            guard let dataRowView = rowView as? DataGridRowView else { return }
-            dataRowView.invalidateVisualState()
-            dataRowView.redrawCells()
-        }
-        repaintRowGutter()
-    }
-
-    private func repaintRowGutter(forRow row: Int) {
-        guard let rowGutter, let tableView else { return }
-        let band = rowGutter.convert(tableView.rect(ofRow: row), from: tableView)
-        rowGutter.setNeedsDisplay(NSRect(x: 0, y: band.minY, width: rowGutter.bounds.width, height: band.height))
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+RowGutter.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+RowGutter.swift
deleted file mode 100644
index 3b6f5fa123..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+RowGutter.swift
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-//  DataGridView+RowGutter.swift
-//  TablePro
-//
-
-import AppKit
-
-extension TableViewCoordinator {
-    /// The single way to reach a column, for Find, cell navigation and the inline editor alike.
-    ///
-    /// AppKit aligns a column left of the viewport flush with the clip view's leading edge, which is
-    /// where the pinned band (row gutter and frozen columns) sits, so the column it just scrolled to
-    /// would arrive underneath it. The correction is one-sided: a column already clear of the band
-    /// must produce no scroll at all, or every arrow keypress fights AppKit and the viewport drifts.
-    ///
-    /// The correction scrolls through `scroll(_:)`, which moves the header with the rows. Scrolling
-    /// the clip view and reflecting it leaves the header clip where it was, measured on macOS 27, so
-    /// every heading sat as far off its column as the correction had moved.
-    ///
-    /// The last column gets the same treatment on its trailing side. AppKit stops with that
-    /// column's divider on the viewport edge, which leaves the trailing space off screen and the
-    /// divider where the window's edge resize takes the press.
-    func scrollColumnToVisible(tableColumnIndex index: Int) {
-        guard let tableView, index >= 0, index < tableView.numberOfColumns else { return }
-        let band = pinnedBand()
-        // A frozen column is on screen at every offset; AppKit would scroll back to its home.
-        guard !band.pins(index) else { return }
-        tableView.scrollColumnToVisible(index)
-        guard let clipView = tableView.enclosingScrollView?.contentView else { return }
-        let columnRect = tableView.rect(ofColumn: index)
-        guard columnRect.width > 0 else { return }
-        let visible = clipView.bounds
-        let pinnedWidth = band.width
-        let hidden = visible.minX + pinnedWidth - columnRect.minX
-        if pinnedWidth > 0, hidden > 0 {
-            tableView.scroll(NSPoint(x: visible.minX - hidden, y: visible.minY))
-            return
-        }
-        guard index == lastPresentedColumnIndex() else { return }
-        let trailingEdge = min(columnRect.maxX + DataGridMetrics.trailingSpace, tableView.bounds.maxX)
-        let shortfall = trailingEdge - visible.maxX
-        guard shortfall > 0,
-              columnRect.maxX <= visible.maxX,
-              columnRect.minX - pinnedWidth >= visible.minX + shortfall else { return }
-        tableView.scroll(NSPoint(x: visible.minX + shortfall, y: visible.minY))
-    }
-
-    /// Re-reads the pinned gutter's geometry from the column it mirrors. The width moves when the
-    /// row count crosses a digit boundary, when the page offset grows and when the Data Grid Font
-    /// changes; the height moves with the row count.
-    func synchronizeRowGutter() {
-        rowGutter?.synchronizeGeometry()
-    }
-
-    func repaintRowGutter() {
-        rowGutter?.needsDisplay = true
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+RowIdentity.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+RowIdentity.swift
deleted file mode 100644
index 3319dc39ab..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+RowIdentity.swift
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-//  DataGridView+RowIdentity.swift
-//  TablePro
-//
-
-import Foundation
-
-extension TableViewCoordinator {
-    func rowID(forDisplayRow displayIndex: Int) -> RowID? {
-        displayRow(at: displayIndex)?.id
-    }
-
-    func isRowDeleted(displayRow displayIndex: Int) -> Bool {
-        guard let rowID = rowID(forDisplayRow: displayIndex) else { return false }
-        return changeManager.isRowDeleted(rowID)
-    }
-
-    func updateVisualIndex(forDisplayRow displayIndex: Int) {
-        guard let rowID = rowID(forDisplayRow: displayIndex) else { return }
-        visualIndex.updateRow(rowID, from: changeManager)
-    }
-
-    /// The row's marks for a caller that has already resolved it, which every drawn cell has:
-    /// resolving it again costs a `TableRows` copy per cell.
-    func visualState(of displayed: Row, atDisplayRow row: Int) -> RowVisualState {
-        if let delegateState = delegate?.dataGridVisualState(forRow: row) {
-            return delegateState
-        }
-        guard !visualIndex.isEmpty || !highlightRuleSet.isEmpty else { return .empty }
-        return visualIndex.visualState(for: displayed.id).highlighted(highlight(for: displayed))
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Selection.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Selection.swift
deleted file mode 100644
index 5a333bba95..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Selection.swift
+++ /dev/null
@@ -1,154 +0,0 @@
-//
-//  DataGridView+Selection.swift
-//  TablePro
-//
-
-import AppKit
-import SwiftUI
-
-extension TableViewCoordinator {
-    /// The repaint runs ahead of both guards below on purpose. `isRebuildingColumns` and
-    /// `markColumnWidthUserSized` decide whether the new width is the user's to keep, which is a
-    /// question about persistence; the body has to be redrawn either way, and the second guard is
-    /// false for the row-number column and for every unused pool slot.
-    ///
-    /// A divider drag posts this once, at mouse-up, so it is where the width is kept; the steps
-    /// before it repaint through `SortableHeaderView.viewWillDraw()`.
-    func tableViewColumnDidResize(_ notification: Notification) {
-        columnGeometryDidChange()
-        guard !isRebuildingColumns else { return }
-        guard let column = notification.userInfo?["NSTableColumn"] as? NSTableColumn else { return }
-        guard markColumnWidthUserSized(column) else { return }
-        scheduleLayoutPersist()
-    }
-
-    func tableViewColumnDidMove(_ notification: Notification) {
-        columnGeometryDidChange()
-        guard !isRebuildingColumns else { return }
-        invalidateColumnIndexCache()
-        hasUnpersistedColumnLayoutChanges = true
-        layoutPersistTask?.cancel()
-        persistColumnLayoutToStorage()
-    }
-
-    func scheduleLayoutPersist() {
-        layoutPersistTask?.cancel()
-        let pending = makePendingColumnLayoutPersistence()
-        pendingColumnLayoutPersistence = nil
-        guard let pending else { return }
-        pendingColumnLayoutPersistence = pending
-        let generation = columnLayoutPersistenceGeneration
-        layoutPersistTask = Task { @MainActor [weak self] in
-            try? await Task.sleep(for: .milliseconds(500))
-            guard !Task.isCancelled else { return }
-            guard self?.columnLayoutPersistenceGeneration == generation else { return }
-            self?.flushPendingColumnLayoutPersistence()
-        }
-    }
-
-    /// Throws the pending layout away instead of writing it, for a table that is gone.
-    ///
-    /// A drop clears the table's saved layout and then closes its tab, and the teardown runs on a
-    /// later run-loop turn, so a flush there would write the layout back over the clear and mark it
-    /// dirty for sync again, waiting for a table recreated with the same name.
-    func discardPendingColumnLayoutPersistence() {
-        layoutPersistTask?.cancel()
-        layoutPersistTask = nil
-        pendingColumnLayoutPersistence = nil
-    }
-
-    func flushPendingColumnLayoutPersistence() {
-        layoutPersistTask?.cancel()
-        layoutPersistTask = nil
-        guard let pending = pendingColumnLayoutPersistence else { return }
-        pendingColumnLayoutPersistence = nil
-        persistColumnLayout(pending)
-    }
-
-    func currentRowSelection(fallbackRow: Int? = nil) -> Set<Int> {
-        if !selectionController.isEmpty {
-            return Set(selectionController.selection.affectedRows)
-        }
-        if !selectedRowIndices.isEmpty {
-            return selectedRowIndices
-        }
-        if let fallbackRow, fallbackRow >= 0 {
-            return [fallbackRow]
-        }
-        return []
-    }
-
-    func tableViewSelectionDidChange(_ notification: Notification) {
-        guard let tableView = notification.object as? NSTableView else { return }
-
-        /// The table view's own previous selection, not the binding's. The binding now carries
-        /// `currentRowSelection()`, which spans a cell drag's rows, and `resolvedFocus` reads the
-        /// difference between two row selections to find the row the gesture just added.
-        let previousSelection = lastTableViewRowSelection
-        let newSelection = Set(tableView.selectedRowIndexes.map { $0 })
-        lastTableViewRowSelection = newSelection
-
-        guard let keyTableView = tableView as? KeyHandlingTableView else {
-            publishRowSelection(rowSelection: newSelection)
-            return
-        }
-
-        if !isApplyingProgrammaticRowSelection, !newSelection.isEmpty, !selectionController.isEmpty {
-            selectionController.clear()
-        }
-        publishRowSelection(rowSelection: newSelection)
-        repaintRowGutter()
-
-        let newFocus = resolvedFocus(
-            previous: previousSelection,
-            current: newSelection,
-            existingFocusedRow: keyTableView.focusedRow,
-            existingFocusedColumn: keyTableView.focusedColumn,
-            tableView: tableView
-        )
-
-        if keyTableView.focusedRow != newFocus.row {
-            keyTableView.focusedRow = newFocus.row
-        }
-        if keyTableView.focusedColumn != newFocus.column {
-            keyTableView.focusedColumn = newFocus.column
-        }
-
-        refreshFKPreviewForRowChange()
-    }
-
-    private func resolvedFocus(
-        previous: Set<Int>,
-        current: Set<Int>,
-        existingFocusedRow: Int,
-        existingFocusedColumn: Int,
-        tableView: NSTableView
-    ) -> (row: Int, column: Int) {
-        if current.isEmpty {
-            return (-1, -1)
-        }
-
-        let column = presentsColumn(atTableColumnIndex: existingFocusedColumn)
-            ? existingFocusedColumn
-            : (firstPresentedColumnIndex() ?? -1)
-        let added = current.subtracting(previous)
-
-        if let tip = added.max() {
-            return (tip, column)
-        }
-
-        let removed = previous.subtracting(current)
-        if let lostTip = removed.max(),
-           let currentMax = current.max(),
-           let currentMin = current.min() {
-            let row = lostTip > currentMax ? currentMax : currentMin
-            return (row, column)
-        }
-
-        if existingFocusedRow >= 0, current.contains(existingFocusedRow) {
-            return (existingFocusedRow, column)
-        }
-
-        return (current.min() ?? -1, column)
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+SetCellsToValue.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+SetCellsToValue.swift
deleted file mode 100644
index 1a4a67ae34..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+SetCellsToValue.swift
+++ /dev/null
@@ -1,167 +0,0 @@
-//
-//  DataGridView+SetCellsToValue.swift
-//  TablePro
-//
-
-import AppKit
-import TableProPluginKit
-
-/// What one cell stages: a value, and whether it is SQL the engine runs.
-typealias StagedCellEntry = (value: PluginCellValue, isExpression: Bool)
-
-/// The records a Set Cells to Value sheet was opened over. A load that lands while the sheet is up can put other
-/// records at the same display positions, so the write finds these records again or is dropped.
-@MainActor
-struct SetCellsToValueRecords {
-    private let cells: [(rowID: RowID, columnIndex: Int)]
-    private let rows: [RowID: Row]
-
-    init(_ targets: [SetValueTarget], in coordinator: TableViewCoordinator) {
-        let tableRows = coordinator.tableRowsProvider()
-        var cells: [(rowID: RowID, columnIndex: Int)] = []
-        var rows: [RowID: Row] = [:]
-        for target in targets {
-            guard let row = coordinator.displayRow(at: target.displayRow, in: tableRows) else { continue }
-            cells.append((rowID: row.id, columnIndex: target.columnIndex))
-            rows[row.id] = row
-        }
-        self.cells = cells
-        self.rows = rows
-    }
-
-    /// Where the records are now, or nil when one of them is gone or no longer holds what it held.
-    func targets(in coordinator: TableViewCoordinator) -> [SetValueTarget]? {
-        let tableRows = coordinator.tableRowsProvider()
-        var filteredPositions: [RowID: Int] = [:]
-        if let displayIDs = coordinator.displayIDs {
-            for (position, id) in displayIDs.enumerated() {
-                filteredPositions[id] = position
-            }
-        }
-        var targets: [SetValueTarget] = []
-        targets.reserveCapacity(cells.count)
-        for cell in cells {
-            guard let row = tableRows.row(withID: cell.rowID), row == rows[cell.rowID] else { return nil }
-            let position = coordinator.displayIDs == nil ? tableRows.index(of: cell.rowID) : filteredPositions[cell.rowID]
-            guard let position else { return nil }
-            targets.append(SetValueTarget(displayRow: position, columnIndex: cell.columnIndex))
-        }
-        return targets
-    }
-}
-
-extension TableViewCoordinator {
-    /// The targets are the ones every Set Value item takes. A window with its own command runs that instead.
-    func setCellsToValue(_ targets: [SetValueTarget]) {
-        if delegate?.dataGridSetCellsToValue(targets) == true { return }
-        let cells = setCellsToValueCells(targets)
-        guard !cells.isEmpty, let window = tableView?.window else { return }
-        let records = SetCellsToValueRecords(cells, in: self)
-        SetCellsToValuePrompt.present(
-            informative: Self.setCellsToValueImpact(cells: cells.count, targets: targets.count),
-            window: window
-        ) { [weak self] text in
-            guard let self, let text else { return }
-            guard let current = records.targets(in: self) else {
-                NSSound.beep()
-                return
-            }
-            self.applyCellsToValue(text, to: self.setCellsToValueCells(current))
-        }
-    }
-
-    func isSetCellsToValueOffered(for targets: [SetValueTarget]) -> Bool {
-        targets.contains { canStartInlineEdit(row: $0.displayRow, columnIndex: $0.columnIndex) }
-    }
-
-    /// The cells typing could edit, so a read-only or server-owned column, a deleted row and a binary value stay out.
-    func setCellsToValueCells(_ targets: [SetValueTarget]) -> [SetValueTarget] {
-        targets.filter { canStartInlineEdit(row: $0.displayRow, columnIndex: $0.columnIndex) }
-    }
-
-    /// The text is read for each column the way a typed cell is: an empty date is NULL, a function the engine runs
-    /// there is SQL.
-    func applyCellsToValue(_ text: String, to cells: [SetValueTarget]) {
-        stageEntry(into: cells, actionName: String(localized: "Set Cells to Value")) { columnIndex in
-            enteredCell(text, columnIndex: columnIndex)
-        }
-    }
-
-    /// One undo step for every cell. The entry is read once per column; a column that holds neither it nor NULL in
-    /// its place keeps its cells, and the beep says the value was refused.
-    @discardableResult
-    func stageEntry(
-        into cells: [SetValueTarget],
-        actionName: String,
-        entry: (Int) -> StagedCellEntry?
-    ) -> Int {
-        guard !cells.isEmpty else { return 0 }
-        let undoManager = tableView?.window?.undoManager
-        undoManager?.beginUndoGrouping()
-
-        var entries: [Int: StagedCellEntry?] = [:]
-        var edited: [SetValueTarget] = []
-        var refused = false
-        batchEdits(actionName: actionName) {
-            for cell in cells where !isRowDeleted(displayRow: cell.displayRow) {
-                let resolved: StagedCellEntry?
-                if let cached = entries[cell.columnIndex] {
-                    resolved = cached
-                } else {
-                    resolved = entry(cell.columnIndex)
-                    entries[cell.columnIndex] = .some(resolved)
-                }
-                guard let resolved else {
-                    refused = true
-                    continue
-                }
-                guard recordCellEdit(
-                    row: cell.displayRow,
-                    columnIndex: cell.columnIndex,
-                    newValue: resolved.value,
-                    isExpression: resolved.isExpression
-                ) != nil else { continue }
-                edited.append(cell)
-            }
-        }
-
-        // After the loop: each cell's own step names the open group "Edit Cell".
-        if !edited.isEmpty {
-            undoManager?.setActionName(actionName)
-        }
-        undoManager?.endUndoGrouping()
-
-        if edited.count == 1, let only = edited.first {
-            repaintEditedCell(row: only.displayRow, columnIndex: only.columnIndex)
-        } else if !edited.isEmpty {
-            invalidateAllDisplayCaches()
-            tableView?.reloadData()
-        }
-        if refused {
-            NSSound.beep()
-        }
-        return edited.count
-    }
-
-    func batchEdits(actionName: String, _ edits: () -> Void) {
-        guard let delegate else {
-            edits()
-            return
-        }
-        delegate.dataGridBatchEdits(actionName: actionName, edits)
-    }
-
-    static func setCellsToValueImpact(cells: Int, targets: Int) -> String {
-        if cells < targets {
-            return String(
-                format: String(localized: "This sets %1$lld of %2$lld cells. The others cannot be edited."),
-                Int64(cells),
-                Int64(targets)
-            )
-        }
-        if cells == 1 {
-            return String(localized: "This sets 1 cell.")
-        }
-        return String(format: String(localized: "This sets %lld cells."), Int64(cells))
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+SetValue.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+SetValue.swift
deleted file mode 100644
index a5a3e6488e..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+SetValue.swift
+++ /dev/null
@@ -1,223 +0,0 @@
-//
-//  DataGridView+SetValue.swift
-//  TablePro
-//
-
-import AppKit
-import TableProPluginKit
-
-/// A display row and a data column.
-struct SetValueTarget: Hashable {
-    let displayRow: Int
-    let columnIndex: Int
-}
-
-extension TableViewCoordinator {
-    /// The cell selection, else the clicked column on every selected row, else the clicked cell. A context menu keeps
-    /// the selection only when the click lands inside it; the menu bar passes nil while a selection exists.
-    func setValueTargets(clicked: SetValueTarget?) -> [SetValueTarget] {
-        let selection = selectionController.selection
-        if !selection.isEmpty, clicked.map({ isTarget($0, inside: selection) }) ?? true {
-            return cells(in: selection)
-        }
-        guard let clicked, clicked.displayRow >= 0, clicked.columnIndex >= 0 else { return [] }
-        let selectedRows = tableView.map { Set($0.selectedRowIndexes) } ?? selectedRowIndices
-        guard selectedRows.count > 1, selectedRows.contains(clicked.displayRow) else { return [clicked] }
-        return selectedRows.sorted().map { SetValueTarget(displayRow: $0, columnIndex: clicked.columnIndex) }
-    }
-
-    /// Any target's commands, so a selection over a date and a UUID column offers both kinds.
-    func setValueCommands(for targets: [SetValueTarget]) -> [SetValueCommand] {
-        var resolver = SetValueResolver(coordinator: self)
-        var seen: Set<SetValueCommand> = []
-        var offered: [SetValueCommand] = []
-        for target in targets {
-            for command in resolver.commands(for: target) ?? [] where seen.insert(command).inserted {
-                offered.append(command)
-            }
-        }
-        return offered.enumerated()
-            .sorted { (Self.menuRank($0.element), $0.offset) < (Self.menuRank($1.element), $1.offset) }
-            .map { $0.element }
-    }
-
-    func isSetValueOffered(_ command: SetValueCommand, for targets: [SetValueTarget]) -> Bool {
-        var resolver = SetValueResolver(coordinator: self)
-        return targets.contains { resolver.commands(for: $0)?.contains(command) == true }
-    }
-
-    /// A target that does not take the command, such as NULL on a NOT NULL column or a deleted row, is skipped.
-    func applySetValue(_ command: SetValueCommand, to targets: [SetValueTarget]) {
-        guard !targets.isEmpty else { return }
-        guard unloadedValuesAreLoaded(targets: targets, retry: { [weak self] in
-            self?.applySetValue(command, to: targets)
-        }) else { return }
-        var resolver = SetValueResolver(coordinator: self)
-        let undoManager = tableView?.window?.undoManager
-        undoManager?.beginUndoGrouping()
-
-        var edited: [SetValueTarget] = []
-        for target in targets {
-            guard let context = resolver.context(for: target),
-                  resolver.commands(for: target)?.contains(command) == true,
-                  let staged = Self.stagedValue(for: command, context: context),
-                  recordCellEdit(
-                      row: target.displayRow,
-                      columnIndex: target.columnIndex,
-                      newValue: staged.value,
-                      isExpression: staged.isExpression
-                  ) != nil else { continue }
-            edited.append(target)
-        }
-
-        // After the loop: each cell's own step names the open group "Edit Cell".
-        if !edited.isEmpty {
-            undoManager?.setActionName(Self.undoActionName(for: command))
-        }
-        undoManager?.endUndoGrouping()
-
-        if edited.count == 1, let only = edited.first {
-            repaintEditedCell(row: only.displayRow, columnIndex: only.columnIndex)
-        } else if !edited.isEmpty {
-            invalidateAllDisplayCaches()
-            tableView?.reloadData()
-        }
-    }
-
-    func setValueContext(forColumn columnIndex: Int, rowIsInserted: Bool, in tableRows: TableRows) -> SetValueContext? {
-        guard tableRows.columns.indices.contains(columnIndex) else { return nil }
-        let name = tableRows.columns[columnIndex]
-        let format = columnDisplayFormats.indices.contains(columnIndex) ? columnDisplayFormats[columnIndex] : nil
-        return SetValueContext(
-            columnType: tableRows.editingColumnType(at: columnIndex),
-            isNullable: tableRows.columnNullable[name] ?? true,
-            serverAssignsValue: tableRows.serverAssignsValue(forColumn: name),
-            isForeignKey: tableRows.columnForeignKeys[name] != nil,
-            isWritable: isEditable && isColumnWritable(name),
-            displayFormat: format,
-            sampleText: format == .uuid ? Self.sampleText(ofColumn: columnIndex, in: tableRows) : nil,
-            declaredType: tableRows.declaredType(at: columnIndex),
-            databaseType: databaseType ?? Self.unknownDatabaseType,
-            rowIsInserted: rowIsInserted,
-            writer: changeManager.cellWriterSupport
-        )
-    }
-
-    /// A grid with no engine named gets nothing the vocabulary keys by engine.
-    private static let unknownDatabaseType = DatabaseType(rawValue: "")
-
-    /// A MySQL `CHAR(32)` result has no length, so its values are the one sign it takes the compact UUID form.
-    private static func sampleText(ofColumn columnIndex: Int, in tableRows: TableRows) -> String? {
-        for row in tableRows.rows where columnIndex < row.values.count {
-            guard let text = row.values[columnIndex].asText,
-                  !text.isEmpty, text != PluginCellValue.defaultMarkerText else { continue }
-            return text
-        }
-        return nil
-    }
-
-    private func isTarget(_ target: SetValueTarget, inside selection: GridSelection) -> Bool {
-        guard let position = displayPosition(ofDataColumnIndex: target.columnIndex) else { return false }
-        return selection.contains(row: target.displayRow, displayColumn: position)
-    }
-
-    /// Overlapping rectangles name a cell once.
-    private func cells(in selection: GridSelection) -> [SetValueTarget] {
-        let rowCount = displayIDs?.count ?? tableRowsProvider().count
-        let presented = presentedDataColumns
-        func dataColumns(_ positions: IndexSet) -> [Int] {
-            positions.compactMap { presented.indices.contains($0) ? presented[$0] : nil }
-        }
-        var cells: [SetValueTarget] = []
-        if selection.rectangles.count == 1, let only = selection.rectangles.first {
-            let columns = dataColumns(IndexSet(integersIn: only.columns.lowerBound...only.columns.upperBound))
-            for row in only.rows where row >= 0 && row < rowCount {
-                cells += columns.map { SetValueTarget(displayRow: row, columnIndex: $0) }
-            }
-            return cells
-        }
-        for row in selection.affectedRows where row < rowCount {
-            cells += dataColumns(selection.columns(in: row)).map { SetValueTarget(displayRow: row, columnIndex: $0) }
-        }
-        return cells
-    }
-
-    private static func stagedValue(
-        for command: SetValueCommand,
-        context: SetValueContext
-    ) -> (value: PluginCellValue, isExpression: Bool)? {
-        let value: PluginCellValue
-        switch command {
-        case .empty:
-            value = .text("")
-        case .null:
-            value = .null
-        case .defaultValue:
-            value = .text(PluginCellValue.defaultMarkerText)
-        case .expression(let expression):
-            return (value: PluginCellValue.text(expression.sql), isExpression: true)
-        case .uuid(let version):
-            guard let form = SetValueOptions.uuidForm(for: context) else { return nil }
-            value = form.value(for: UUIDValueGenerator.shared.make(version))
-        }
-        return (value: value, isExpression: false)
-    }
-
-    private static func undoActionName(for command: SetValueCommand) -> String {
-        guard case .uuid = command else { return String(localized: "Set Value") }
-        return SetValueOptions.title(for: command)
-    }
-
-    private static func menuRank(_ command: SetValueCommand) -> Int {
-        switch command {
-        case .empty: 0
-        case .null: 1
-        case .defaultValue: 2
-        case .expression: 3
-        case .uuid(.v4): 4
-        case .uuid(.v7): 5
-        }
-    }
-}
-
-/// A context depends only on the column and whether the row is new, so a tall selection resolves a few, not one per cell.
-@MainActor
-private struct SetValueResolver {
-    private struct Key: Hashable {
-        let columnIndex: Int
-        let rowIsInserted: Bool
-    }
-
-    private let coordinator: TableViewCoordinator
-    private let tableRows: TableRows
-    private let insertedRowIDs: Set<RowID>
-    private let deletedRowIDs: Set<RowID>
-    private var resolved: [Key: (context: SetValueContext, commands: [SetValueCommand])?] = [:]
-
-    init(coordinator: TableViewCoordinator) {
-        self.coordinator = coordinator
-        tableRows = coordinator.tableRowsProvider()
-        insertedRowIDs = coordinator.changeManager.insertedRowIDs
-        deletedRowIDs = coordinator.changeManager.deletedRowIDs
-    }
-
-    mutating func context(for target: SetValueTarget) -> SetValueContext? {
-        options(for: target)?.context
-    }
-
-    mutating func commands(for target: SetValueTarget) -> [SetValueCommand]? {
-        options(for: target)?.commands
-    }
-
-    private mutating func options(for target: SetValueTarget) -> (context: SetValueContext, commands: [SetValueCommand])? {
-        guard let row = coordinator.displayRow(at: target.displayRow, in: tableRows),
-              !deletedRowIDs.contains(row.id) else { return nil }
-        let key = Key(columnIndex: target.columnIndex, rowIsInserted: insertedRowIDs.contains(row.id))
-        if let cached = resolved[key] { return cached }
-        let options = coordinator
-            .setValueContext(forColumn: key.columnIndex, rowIsInserted: key.rowIsInserted, in: tableRows)
-            .map { (context: $0, commands: SetValueOptions.commands(for: $0)) }
-        resolved[key] = .some(options)
-        return options
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Sort.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Sort.swift
deleted file mode 100644
index c498619a6e..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Sort.swift
+++ /dev/null
@@ -1,538 +0,0 @@
-//
-//  DataGridView+Sort.swift
-//  TablePro
-//
-
-import AppKit
-import SwiftUI
-
-extension TableViewCoordinator {
-    // MARK: - Double-Click Column Divider Auto-Fit
-
-    func tableView(_ tableView: NSTableView, sizeToFitWidthOfColumn columnIndex: Int) -> CGFloat {
-        let column = tableView.tableColumns[columnIndex]
-        guard column.identifier != ColumnIdentitySchema.rowNumberIdentifier else {
-            return column.width
-        }
-        guard let dataColumnIndex = dataColumnIndex(from: column.identifier) else {
-            return column.width
-        }
-
-        markColumnWidthUserSized(column)
-        scheduleLayoutPersist()
-        return fitToContentWidth(for: column, dataColumnIndex: dataColumnIndex, tableRows: tableRowsProvider())
-    }
-
-    private var visibleGridWidth: CGFloat {
-        guard let tableView else { return 0 }
-        return tableView.enclosingScrollView?.contentView.bounds.width ?? tableView.visibleRect.width
-    }
-
-    private func fitToContentWidth(
-        for column: NSTableColumn,
-        dataColumnIndex: Int,
-        tableRows: TableRows,
-        fittedColumnCount: Int = 1
-    ) -> CGFloat {
-        fitToContentColumnWidth(
-            for: dataColumnIndex < tableRows.columns.count ? tableRows.columns[dataColumnIndex] : column.title,
-            columnIndex: dataColumnIndex,
-            tableRows: tableRows,
-            availableWidth: visibleGridWidth,
-            fittedColumnCount: fittedColumnCount
-        )
-    }
-
-    // MARK: - NSMenuDelegate (Header Context Menu)
-
-    func menuNeedsUpdate(_ menu: NSMenu) {
-        menu.removeAllItems()
-
-        guard let tableView = tableView,
-              let headerView = tableView.headerView,
-              let window = tableView.window else { return }
-
-        let mouseLocation = window.mouseLocationOutsideOfEventStream
-        let pointInHeader = headerView.convert(mouseLocation, from: nil)
-        let columnIndex = (headerView as? SortableHeaderView)?.displayedColumn(at: pointInHeader)
-            ?? headerView.column(at: pointInHeader)
-        populateHeaderMenu(menu, forColumnAt: columnIndex)
-    }
-
-    func populateHeaderMenu(_ menu: NSMenu, forColumnAt columnIndex: Int) {
-        guard let tableView, columnIndex >= 0 && columnIndex < tableView.tableColumns.count else { return }
-
-        let column = tableView.tableColumns[columnIndex]
-        if column.identifier == ColumnIdentitySchema.rowNumberIdentifier { return }
-
-        let tableRows = tableRowsProvider()
-        let baseName: String = {
-            if let idx = dataColumnIndex(from: column.identifier),
-               idx < tableRows.columns.count {
-                return tableRows.columns[idx]
-            }
-            return column.title
-        }()
-
-        if supportsColumnSort, let dataColumnIndex = dataColumnIndex(from: column.identifier) {
-            let sortAscItem = NSMenuItem(
-                title: String(localized: "Sort Ascending"),
-                action: #selector(sortAscending(_:)),
-                keyEquivalent: ""
-            )
-            sortAscItem.representedObject = dataColumnIndex
-            sortAscItem.target = self
-            menu.addItem(sortAscItem)
-
-            let sortDescItem = NSMenuItem(
-                title: String(localized: "Sort Descending"),
-                action: #selector(sortDescending(_:)),
-                keyEquivalent: ""
-            )
-            sortDescItem.representedObject = dataColumnIndex
-            sortDescItem.target = self
-            menu.addItem(sortDescItem)
-
-            if currentSortState.isSorting {
-                let clearSortItem = NSMenuItem(
-                    title: String(localized: "Don't Sort"),
-                    action: #selector(clearSortAction),
-                    keyEquivalent: ""
-                )
-                clearSortItem.target = self
-                menu.addItem(clearSortItem)
-            }
-
-            menu.addItem(NSMenuItem.separator())
-        }
-
-        if let dataColumnIndex = dataColumnIndex(from: column.identifier) {
-            let selectItem = NSMenuItem(
-                title: String(localized: "Select Column"),
-                action: #selector(selectColumnFromHeaderMenu(_:)),
-                keyEquivalent: ""
-            )
-            selectItem.representedObject = dataColumnIndex
-            selectItem.target = self
-            menu.addItem(selectItem)
-        }
-
-        let copyItem = NSMenuItem(title: String(localized: "Copy Column Name"), action: #selector(copyColumnName(_:)), keyEquivalent: "")
-        copyItem.representedObject = baseName
-        copyItem.target = self
-        menu.addItem(copyItem)
-
-        if let dataColumnIndex = dataColumnIndex(from: column.identifier) {
-            let copyValuesItem = NSMenuItem(
-                title: String(localized: "Copy Column Values"),
-                action: #selector(copyColumnValues(_:)),
-                keyEquivalent: ""
-            )
-            copyValuesItem.representedObject = dataColumnIndex
-            copyValuesItem.target = self
-            menu.addItem(copyValuesItem)
-        }
-
-        if let dataColumnIndex = dataColumnIndex(from: column.identifier),
-           isEditable,
-           cachedRowCount > 0,
-           isColumnWritable(baseName),
-           !primaryKeyColumns.contains(baseName) {
-            let fillItem = NSMenuItem(
-                title: String(localized: "Fill Column…"),
-                action: #selector(fillColumn(_:)),
-                keyEquivalent: ""
-            )
-            fillItem.representedObject = dataColumnIndex
-            fillItem.target = self
-            menu.addItem(fillItem)
-        }
-
-        if supportsColumnCommands {
-            let filterItem = NSMenuItem(
-                title: String(localized: "Filter with column"),
-                action: #selector(filterWithColumn(_:)),
-                keyEquivalent: ""
-            )
-            filterItem.representedObject = baseName
-            filterItem.target = self
-            menu.addItem(filterItem)
-        }
-
-        if supportsValueFilter, let dataColumnIndex = dataColumnIndex(from: column.identifier) {
-            let filterValuesItem = NSMenuItem(
-                title: String(localized: "Filter Values…"),
-                action: #selector(filterColumnValues(_:)),
-                keyEquivalent: ""
-            )
-            filterValuesItem.representedObject = dataColumnIndex
-            filterValuesItem.target = self
-            menu.addItem(filterValuesItem)
-
-            if valueFilterState.isActive(column: dataColumnIndex) {
-                let clearColumnItem = NSMenuItem(
-                    title: String(localized: "Clear Value Filter"),
-                    action: #selector(clearColumnValueFilter(_:)),
-                    keyEquivalent: ""
-                )
-                clearColumnItem.representedObject = dataColumnIndex
-                clearColumnItem.target = self
-                menu.addItem(clearColumnItem)
-            }
-        }
-
-        if valueFilterState.isActive {
-            let clearAllItem = NSMenuItem(
-                title: String(localized: "Clear All Value Filters"),
-                action: #selector(clearAllValueFiltersAction),
-                keyEquivalent: ""
-            )
-            clearAllItem.target = self
-            menu.addItem(clearAllItem)
-        }
-
-        if let dataColumnIndex = dataColumnIndex(from: column.identifier),
-           let highlightItem = delegate?.dataGridHighlightValuesMenuItem(forColumn: dataColumnIndex) {
-            menu.addItem(highlightItem)
-        }
-
-        if let dataColumnIndex = dataColumnIndex(from: column.identifier) {
-            addDisplayFormatMenu(to: menu, dataColumnIndex: dataColumnIndex, tableRows: tableRows)
-        }
-
-        menu.addItem(NSMenuItem.separator())
-
-        let sizeToFitItem = NSMenuItem(title: String(localized: "Size to Fit"), action: #selector(sizeColumnToFit(_:)), keyEquivalent: "")
-        sizeToFitItem.representedObject = columnIndex
-        sizeToFitItem.target = self
-        menu.addItem(sizeToFitItem)
-
-        let sizeAllItem = NSMenuItem(title: String(localized: "Size All Columns to Fit"), action: #selector(sizeAllColumnsToFit(_:)), keyEquivalent: "")
-        sizeAllItem.target = self
-        menu.addItem(sizeAllItem)
-
-        menu.addItem(NSMenuItem.separator())
-        let visibilityGroupStart = menu.items.count
-
-        if supportsColumnCommands {
-            let hideItem = NSMenuItem(
-                title: String(localized: "Hide Column"), action: #selector(hideColumn(_:)), keyEquivalent: ""
-            )
-            hideItem.representedObject = baseName
-            hideItem.target = self
-            menu.addItem(hideItem)
-        }
-
-        if supportsColumnCommands,
-           delegate != nil,
-           columnPool.hasUserHiddenColumns {
-            let showAllItem = NSMenuItem(
-                title: String(localized: "Show All Columns"),
-                action: #selector(showAllColumns),
-                keyEquivalent: ""
-            )
-            showAllItem.target = self
-            menu.addItem(showAllItem)
-        }
-
-        if menu.items.count > visibilityGroupStart {
-            menu.addItem(NSMenuItem.separator())
-        }
-        addFreezeMenuItems(to: menu, forColumnIdentifier: column.identifier)
-
-        appendColumnStructureItems(to: menu, forColumnIdentifier: column.identifier)
-    }
-
-    private func addDisplayFormatMenu(
-        to menu: NSMenu,
-        dataColumnIndex: Int,
-        tableRows: TableRows
-    ) {
-        let columnType = dataColumnIndex < tableRows.columnTypes.count
-            ? tableRows.columnTypes[dataColumnIndex]
-            : nil
-        let applicableFormats = ValueDisplayFormat.applicableFormats(
-            for: columnType,
-            databaseType: databaseType
-        )
-        guard applicableFormats.count > 1 else { return }
-
-        let displaySubmenu = NSMenu()
-        let currentFormat = dataColumnIndex < columnDisplayFormats.count
-            ? columnDisplayFormats[dataColumnIndex] ?? .raw
-            : .raw
-        let storageKeys = ValueDisplayFormatColumnKey.storageKeys(for: tableRows.columns)
-        guard storageKeys.indices.contains(dataColumnIndex) else { return }
-        for format in applicableFormats {
-            let item = NSMenuItem(
-                title: format.displayName,
-                action: #selector(setDisplayFormat(_:)),
-                keyEquivalent: ""
-            )
-            item.representedObject = DisplayFormatMenuItem(
-                storageKey: storageKeys[dataColumnIndex],
-                columnIndex: dataColumnIndex,
-                format: format
-            )
-            item.target = self
-            item.state = (format == currentFormat) ? .on : .off
-            displaySubmenu.addItem(item)
-        }
-        let displayItem = NSMenuItem(title: String(localized: "Display As"), action: nil, keyEquivalent: "")
-        displayItem.submenu = displaySubmenu
-        menu.addItem(displayItem)
-    }
-
-    private func addFreezeMenuItems(to menu: NSMenu, forColumnIdentifier identifier: NSUserInterfaceItemIdentifier) {
-        guard let dataColumnIndex = dataColumnIndex(from: identifier),
-              let position = displayPosition(ofDataColumnIndex: dataColumnIndex) else { return }
-
-        if frozenColumnCount != position + 1 {
-            let fits = canFreezeColumns(throughDisplayPosition: position)
-            let freezeItem = NSMenuItem(
-                title: String(localized: "Freeze Up to This Column"),
-                action: fits ? #selector(freezeColumnsFromHeaderMenu(_:)) : nil,
-                keyEquivalent: ""
-            )
-            freezeItem.representedObject = position
-            freezeItem.target = self
-            if !fits {
-                freezeItem.toolTip = String(localized: "These columns would leave too little room to scroll the rest.")
-            }
-            menu.addItem(freezeItem)
-        }
-
-        if frozenColumnCount > 0 {
-            let unfreezeItem = NSMenuItem(
-                title: String(localized: "Unfreeze Columns"),
-                action: #selector(unfreezeColumnsFromHeaderMenu),
-                keyEquivalent: ""
-            )
-            unfreezeItem.target = self
-            menu.addItem(unfreezeItem)
-        }
-    }
-
-    @objc func freezeColumnsFromHeaderMenu(_ sender: NSMenuItem) {
-        guard let position = sender.representedObject as? Int else { return }
-        freezeColumns(throughDisplayPosition: position)
-    }
-
-    @objc func unfreezeColumnsFromHeaderMenu() {
-        unfreezeColumns()
-    }
-
-    private func appendColumnStructureItems(to menu: NSMenu, forColumnIdentifier identifier: NSUserInterfaceItemIdentifier) {
-        guard let dataColumnIndex = dataColumnIndex(from: identifier),
-              let structureItems = delegate?.dataGridColumnStructureMenuItems(forColumn: dataColumnIndex),
-              !structureItems.isEmpty else { return }
-        menu.addItem(NSMenuItem.separator())
-        for item in structureItems {
-            menu.addItem(item)
-        }
-    }
-
-    @objc func sortAscending(_ sender: NSMenuItem) {
-        guard let columnIndex = sender.representedObject as? Int else { return }
-        announceSort(column: columnIndex, direction: .ascending)
-    }
-
-    @objc func sortDescending(_ sender: NSMenuItem) {
-        guard let columnIndex = sender.representedObject as? Int else { return }
-        announceSort(column: columnIndex, direction: .descending)
-    }
-
-    private func announceSort(column columnIndex: Int, direction: SortDirection) {
-        let state = SortState(
-            columns: [SortColumn(
-                columnIndex: columnIndex,
-                direction: direction,
-                columnName: identitySchema.columnName(for: columnIndex)
-            )],
-            source: .user
-        )
-        delegate?.dataGridSortStateChanged(state)
-    }
-
-    @objc func showAllColumns() {
-        delegate?.dataGridShowAllColumns()
-    }
-
-    /// Sends the user's own empty sort, which is not the same value as a tab that has not decided.
-    /// `wantsDefaultSort` reads the source, so a `.user` empty state is what keeps the app default
-    /// from being written straight back over Don't Sort on the next load.
-    @objc func clearSortAction() {
-        delegate?.dataGridSortStateChanged(SortState(columns: [], source: .user))
-    }
-
-    /// Focuses the grid too, so the Copy that usually follows acts on the column rather than on
-    /// whatever held focus before the header was right-clicked.
-    @objc func selectColumnFromHeaderMenu(_ sender: NSMenuItem) {
-        guard let dataColumnIndex = sender.representedObject as? Int else { return }
-        selectColumn(dataColumnIndex)
-        if let tableView {
-            tableView.window?.makeFirstResponder(tableView)
-        }
-    }
-
-    @objc func copyColumnName(_ sender: NSMenuItem) {
-        guard let columnName = sender.representedObject as? String else { return }
-        ClipboardService.shared.writeText(columnName)
-    }
-
-    @objc func copyColumnValues(_ sender: NSMenuItem) {
-        guard let columnIndex = sender.representedObject as? Int else { return }
-        copyColumnValues(columnIndex: columnIndex)
-    }
-
-    @objc func filterWithColumn(_ sender: NSMenuItem) {
-        guard let columnName = sender.representedObject as? String else { return }
-        delegate?.dataGridFilterColumn(columnName)
-    }
-
-    @objc func filterColumnValues(_ sender: NSMenuItem) {
-        guard let dataIndex = sender.representedObject as? Int,
-              let tableView,
-              let header = tableView.headerView as? SortableHeaderView,
-              let columnIndex = tableColumnIndex(for: dataIndex),
-              let cell = tableView.tableColumns[columnIndex].headerCell as? SortableHeaderCell else { return }
-        let anchor = cell.funnelRect(forBounds: header.displayedHeaderRect(ofColumn: columnIndex))
-        presentValueFilterPopover(forColumn: dataIndex, anchor: anchor, in: header)
-    }
-
-    @objc func clearColumnValueFilter(_ sender: NSMenuItem) {
-        guard let dataIndex = sender.representedObject as? Int else { return }
-        applyValueFilter(nil, columnName: "", forColumn: dataIndex)
-    }
-
-    @objc func clearAllValueFiltersAction() {
-        clearAllValueFilters()
-    }
-
-    @objc func hideColumn(_ sender: NSMenuItem) {
-        guard let columnName = sender.representedObject as? String else { return }
-        delegate?.dataGridHideColumn(columnName)
-    }
-
-    @objc func sizeColumnToFit(_ sender: NSMenuItem) {
-        guard let tableView,
-              let columnIndex = sender.representedObject as? Int,
-              columnIndex >= 0 && columnIndex < tableView.tableColumns.count else { return }
-
-        let column = tableView.tableColumns[columnIndex]
-        guard let dataColumnIndex = dataColumnIndex(from: column.identifier) else { return }
-
-        markColumnWidthUserSized(column)
-        column.width = fitToContentWidth(
-            for: column,
-            dataColumnIndex: dataColumnIndex,
-            tableRows: tableRowsProvider()
-        )
-        scheduleLayoutPersist()
-    }
-
-    /// Every `column.width` write posts its own resize notification, and each one that reaches
-    /// `tableViewColumnDidResize` takes a fresh `captureColumnLayout()` walk across every attached
-    /// column, so fitting the table costs its column count squared. The loop claims ownership per
-    /// column already, and the repaint runs ahead of the same guard.
-    @objc func sizeAllColumnsToFit(_ sender: NSMenuItem) {
-        guard let tableView else { return }
-
-        let tableRows = tableRowsProvider()
-        let fittedColumns = tableView.tableColumns.filter { column in
-            guard presentsColumn(column), let index = dataColumnIndex(from: column.identifier) else { return false }
-            return index < tableRows.columns.count
-        }
-
-        let wasRebuildingColumns = isRebuildingColumns
-        isRebuildingColumns = true
-        for column in fittedColumns {
-            guard let dataColumnIndex = dataColumnIndex(from: column.identifier) else { continue }
-
-            markColumnWidthUserSized(column)
-            column.width = fitToContentWidth(
-                for: column,
-                dataColumnIndex: dataColumnIndex,
-                tableRows: tableRows,
-                fittedColumnCount: fittedColumns.count
-            )
-        }
-        isRebuildingColumns = wasRebuildingColumns
-
-        scheduleLayoutPersist()
-    }
-
-    /// Gated whole, not just at the reload. `applyDisplayFormats` remaps the value filter and
-    /// rewrites the format array before it reports whether anything moved, so gating the reload
-    /// alone left a declined change half-applied: the state moved, the grid did not, and the next
-    /// unrelated update would have shown the reorder anyway.
-    ///
-    /// Only when a filter is active, because that is the only way a format change can renumber the
-    /// display at all. Without one this is a repaint, and repaints do not touch pending edits.
-    @objc func setDisplayFormat(_ sender: NSMenuItem) {
-        guard let info = sender.representedObject as? DisplayFormatMenuItem else { return }
-        guard valueFilterState.isActive else {
-            applyDisplayFormatSelection(info)
-            return
-        }
-        confirmDisplayOrderChange { [weak self] in
-            self?.applyDisplayFormatSelection(info)
-        }
-    }
-
-    private func applyDisplayFormatSelection(_ info: DisplayFormatMenuItem) {
-        if let scope = tableScope {
-            ValueDisplayFormatService.shared.setOverride(
-                info.format,
-                columnKey: info.storageKey,
-                scope: scope
-            )
-        }
-
-        let formats = DisplayFormatArray.setting(
-            info.format,
-            at: info.columnIndex,
-            in: columnDisplayFormats,
-            columnCount: tableRowsProvider().columns.count
-        )
-        let remappedValueFilters = updateDisplayFormats(formats)
-
-        if remappedValueFilters {
-            reloadAfterValueFilterChange()
-            return
-        }
-
-        reloadAfterDisplayFormatChange()
-    }
-}
-
-/// Builds the format array the grid and the SwiftUI recompute must agree on.
-/// A short array reads as a change on the next update and costs a second full reload.
-enum DisplayFormatArray {
-    static func setting(
-        _ format: ValueDisplayFormat,
-        at columnIndex: Int,
-        in existing: [ValueDisplayFormat?],
-        columnCount: Int
-    ) -> [ValueDisplayFormat?] {
-        var formats = existing
-        while formats.count < max(columnCount, columnIndex + 1) {
-            formats.append(nil)
-        }
-        formats[columnIndex] = format
-        return formats
-    }
-}
-
-/// Payload for the "Display As" context menu item
-private final class DisplayFormatMenuItem {
-    let storageKey: String
-    let columnIndex: Int
-    let format: ValueDisplayFormat
-
-    init(storageKey: String, columnIndex: Int, format: ValueDisplayFormat) {
-        self.storageKey = storageKey
-        self.columnIndex = columnIndex
-        self.format = format
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+UnloadedValues.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+UnloadedValues.swift
deleted file mode 100644
index 917608904f..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+UnloadedValues.swift
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-//  DataGridView+UnloadedValues.swift
-//  TablePro
-//
-
-import AppKit
-
-extension TableViewCoordinator {
-    // False while the rows' unloaded values load; `retry` runs once every one has arrived, and only
-    // while each display position still shows the row it showed, since `retry` addresses positions.
-    func unloadedValuesAreLoaded(
-        displayRows: some Sequence<Int>,
-        columns: IndexSet? = nil,
-        retry: @escaping @MainActor () -> Void
-    ) -> Bool {
-        let positions = Array(displayRows)
-        let tableRows = tableRowsProvider()
-        let shown = positions.map { displayRow(at: $0, in: tableRows) }
-        let ids = shown.compactMap { $0 }
-            .filter { row in row.unloadedColumns.keys.contains { columns?.contains($0) ?? true } }
-            .map(\.id)
-        guard !ids.isEmpty else { return true }
-        guard let delegate else {
-            NSSound.beep()
-            return false
-        }
-        let shownIDs = shown.map { $0?.id }
-        delegate.dataGridLoadUnloadedValues(rowIDs: ids, columns: columns) { [weak self] loaded in
-            guard let self else { return }
-            let current = self.tableRowsProvider()
-            guard loaded, positions.map({ self.displayRow(at: $0, in: current)?.id }) == shownIDs else {
-                NSSound.beep()
-                return
-            }
-            retry()
-        }
-        return false
-    }
-
-    func unloadedValuesAreLoaded(targets: [SetValueTarget], retry: @escaping @MainActor () -> Void) -> Bool {
-        unloadedValuesAreLoaded(
-            displayRows: Set(targets.map(\.displayRow)),
-            columns: IndexSet(targets.map(\.columnIndex)),
-            retry: retry
-        )
-    }
-
-    func isUnloaded(row: Int, columnIndex: Int) -> Bool {
-        displayRow(at: row)?.unloadedByteCount(columnIndex) != nil
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+ValueFilter.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+ValueFilter.swift
deleted file mode 100644
index 8106ff1bda..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+ValueFilter.swift
+++ /dev/null
@@ -1,205 +0,0 @@
-//
-//  DataGridView+ValueFilter.swift
-//  TablePro
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-
-extension TableViewCoordinator {
-    func distinctValues(forColumn dataIndex: Int) -> [ColumnDistinctValue] {
-        let tableRows = tableRowsProvider()
-        guard dataIndex >= 0, dataIndex < tableRows.columns.count else { return [] }
-        let columnType = dataIndex < tableRows.columnTypes.count ? tableRows.columnTypes[dataIndex] : nil
-
-        var counts: [String: Int] = [:]
-        var order: [String] = []
-        var nullCount = 0
-
-        for row in tableRows.rows {
-            guard dataIndex < row.values.count else { continue }
-            let rawValue = row.values[dataIndex]
-            if case .null = rawValue {
-                nullCount += 1
-                continue
-            }
-            let display = displayValue(forID: row.id, column: dataIndex, rawValue: rawValue, columnType: columnType)
-                ?? rawValue.asText ?? ""
-            if counts[display] == nil { order.append(display) }
-            counts[display, default: 0] += 1
-        }
-
-        var result = order
-            .sorted { $0.localizedStandardCompare($1) == .orderedAscending }
-            .map { ColumnDistinctValue(display: $0, isNull: false, count: counts[$0] ?? 0) }
-        if nullCount > 0 {
-            result.insert(ColumnDistinctValue(display: "", isNull: true, count: nullCount), at: 0)
-        }
-        return result
-    }
-
-    /// Recomputes what the grid shows. A grid with an owner takes the owner's order, so the grid and
-    /// the readers that run without it cannot disagree about which row sits at a display position,
-    /// including after an edit has taken a row out of the filter's match.
-    func recomputeValueFilteredIDs() {
-        if let displayOrderProvider {
-            valueFilteredIDs = displayOrderProvider()
-            return
-        }
-        let tableRows = tableRowsProvider()
-        valueFilteredIDs = GridDisplayOrderResolver.resolve(
-            tableRows: tableRows,
-            valueFilter: valueFilterState,
-            displayFormats: columnDisplayFormats,
-            databaseType: databaseType
-        )
-    }
-
-    /// Forgets filters whose column has moved or gone, so the header stops flagging a column that
-    /// no longer filters anything.
-    ///
-    /// Kept separate from `recomputeValueFilteredIDs` because that one runs on every view update
-    /// and must not write to the filter's owner, while this one only runs on a wholesale
-    /// replacement. The resolver treats a stale entry as inert either way, so a filter that has not
-    /// been pruned yet still narrows nothing.
-    func pruneStaleValueFilters() {
-        guard valueFilterState.isActive else { return }
-        var state = valueFilterState
-        guard state.prune(againstColumns: tableRowsProvider().columns) else { return }
-        valueFilterState = state
-    }
-
-    func applyValueFilter(
-        _ filter: ColumnValueFilter?,
-        columnName: String,
-        forColumn dataIndex: Int,
-        onApplied: (() -> Void)? = nil
-    ) {
-        /// Nothing to confirm when the filter lands on the state it already had. Opening the popover
-        /// and pressing Apply without touching anything is an ordinary thing to do, and asking the
-        /// reader to discard their edits for a change that moves no row at all trains them to
-        /// dismiss the alert without reading it.
-        var candidate = valueFilterState
-        if let filter {
-            candidate.set(filter, columnName: columnName, forColumn: dataIndex)
-        } else {
-            candidate.clear(column: dataIndex)
-        }
-        guard candidate != valueFilterState else {
-            onApplied?()
-            return
-        }
-
-        confirmDisplayOrderChange { [weak self] in
-            guard let self else { return }
-            self.valueFilterState = candidate
-            self.reloadAfterValueFilterChange()
-            onApplied?()
-        }
-    }
-
-    func clearAllValueFilters() {
-        guard valueFilterState.isActive else { return }
-        confirmDisplayOrderChange { [weak self] in
-            guard let self else { return }
-            self.valueFilterState.clearAll()
-            self.reloadAfterValueFilterChange()
-        }
-    }
-
-    /// A grid with no owner has no pending edits to lose, and the protocol default runs the work
-    /// directly, so the structure, create-table and inspector grids are unaffected.
-    func confirmDisplayOrderChange(_ apply: @escaping () -> Void) {
-        guard let delegate else {
-            apply()
-            return
-        }
-        delegate.dataGridConfirmDisplayOrderChange(then: apply)
-    }
-
-    func reloadAfterValueFilterChange() {
-        recomputeValueFilteredIDs()
-        updateCache()
-        visualIndex.rebuild(from: changeManager)
-        selectionController.clear()
-        tableView?.reloadData()
-        updateValueFilterHeaderIndicators()
-        startBackgroundPrewarm()
-    }
-
-    func updateValueFilterHeaderIndicators() {
-        guard let header = tableView?.headerView as? SortableHeaderView else { return }
-        header.updateValueFilterIndicators(activeColumns: valueFilterState.activeColumns)
-    }
-
-    func presentValueFilterPopover(forColumn dataIndex: Int, anchor rect: NSRect, in view: NSView) {
-        let tableRows = tableRowsProvider()
-        guard dataIndex >= 0, dataIndex < tableRows.columns.count else { return }
-        // The values are listed and matched as loaded, so a value still on the server loads first.
-        let unloaded = tableRows.rows.filter { $0.unloadedByteCount(dataIndex) != nil }.map(\.id)
-        if !unloaded.isEmpty {
-            guard let delegate else {
-                NSSound.beep()
-                return
-            }
-            let reopen: @MainActor (Bool) -> Void = { [weak self, weak view] loaded in
-                guard let self, let view, loaded else {
-                    NSSound.beep()
-                    return
-                }
-                self.presentValueFilterPopover(forColumn: dataIndex, anchor: rect, in: view)
-            }
-            delegate.dataGridLoadUnloadedValues(rowIDs: unloaded, columns: IndexSet(integer: dataIndex), completion: reopen)
-            return
-        }
-        let columnName = tableRows.columns[dataIndex]
-        let values = distinctValues(forColumn: dataIndex)
-        let initialFilter = valueFilterState.filter(forColumn: dataIndex)
-        let loadedRowCount = tableRows.count
-
-        dismissActiveValueFilterPopover()
-        activeValueFilterPopover = PopoverPresenter.show(
-            relativeTo: rect,
-            of: view,
-            preferredEdge: .maxY
-        ) { [weak self] dismiss in
-            ColumnValueFilterPopover(
-                columnName: columnName,
-                values: values,
-                loadedRowCount: loadedRowCount,
-                initialFilter: initialFilter,
-                /// Dismissed from inside the applied work, not beside it. The confirmation is a
-                /// sheet and resolves asynchronously, so closing here would put the popover away
-                /// before the reader had answered the alert it raised.
-                onApply: { filter in
-                    self?.applyValueFilter(
-                        filter,
-                        columnName: columnName,
-                        forColumn: dataIndex,
-                        onApplied: dismiss
-                    )
-                },
-                onCancel: dismiss
-            )
-        }
-    }
-
-    func dismissActiveValueFilterPopover() {
-        guard let popover = activeValueFilterPopover else { return }
-        activeValueFilterPopover = nil
-        popover.close()
-    }
-
-    /// A popover carries the display row and the column index it was opened from, and those are
-    /// positions rather than identities: replacing the rows moves a record somewhere else, so a
-    /// commit afterwards writes the edit to whichever record now sits at that position. The
-    /// distinct values behind the value filter go stale the same way. Closing is the only honest
-    /// answer, because there is nothing to re-anchor to once the record has moved.
-    func dismissPopoversBoundToDisplayPositions() {
-        dismissActiveCellEditorPopover()
-        dismissPoppedOutCellEditor()
-        dismissActiveValueFilterPopover()
-        dismissFKPreviewOnColumnChange()
-    }
-}
diff --git a/apple/TablePro/Views/Results/Extensions/DataGridView+Viewport.swift b/apple/TablePro/Views/Results/Extensions/DataGridView+Viewport.swift
deleted file mode 100644
index 8b332d0b8c..0000000000
--- a/apple/TablePro/Views/Results/Extensions/DataGridView+Viewport.swift
+++ /dev/null
@@ -1,115 +0,0 @@
-//
-//  DataGridView+Viewport.swift
-//  TablePro
-//
-
-import AppKit
-import Foundation
-
-internal struct GridViewportSample: Equatable {
-    let firstVisibleRow: Int
-    let offset: CGFloat
-}
-
-extension TableViewCoordinator {
-    func viewportSample() -> GridViewportSample? {
-        guard let tableView, tableView.numberOfRows > 0 else { return nil }
-        let visibleRect = unobscuredVisibleRect(of: tableView)
-        let visibleRows = tableView.rows(in: visibleRect)
-        guard visibleRows.length > 0, visibleRows.location < tableView.numberOfRows else { return nil }
-        let offset = visibleRect.minY - tableView.rect(ofRow: visibleRows.location).minY
-        return GridViewportSample(firstVisibleRow: visibleRows.location, offset: max(0, offset))
-    }
-
-    // The clip view keeps its offset in points, so a new row height would otherwise bring other rows into view.
-    func keepingFirstVisibleRow(_ change: () -> Void) {
-        guard let tableView, let sample = viewportSample(), tableView.rowHeight > 0 else {
-            change()
-            return
-        }
-        let previousHeight = tableView.rowHeight
-        change()
-        let offset = sample.offset * tableView.rowHeight / previousHeight
-        let rowOrigin = tableView.rect(ofRow: sample.firstVisibleRow).minY
-        let horizontalOffset = tableView.enclosingScrollView?.contentView.bounds.origin.x ?? 0
-        tableView.scroll(NSPoint(x: horizontalOffset, y: rowOrigin + offset - headerInset(of: tableView)))
-    }
-
-    func applyViewportPlacement(_ placement: GridViewportPlacement) {
-        guard let tableView, tableView.numberOfRows > 0 else { return }
-        let tableRows = tableRowsProvider()
-        scrollFirstVisibleRow(of: placement, in: tableView, tableRows: tableRows)
-
-        let selectedRows = displayRows(for: placement.selectedRows, in: tableRows, rowLimit: tableView.numberOfRows)
-        guard !selectedRows.isEmpty else { return }
-        selectDisplayRows(selectedRows, in: tableView)
-
-        guard placement.revealsSelection, let firstSelectedRow = selectedRows.first else { return }
-        tableView.scrollRowToVisible(firstSelectedRow)
-    }
-
-    func selectedRowIDs() -> [RowID] {
-        guard let tableView else { return [] }
-        let tableRows = tableRowsProvider()
-        return tableView.selectedRowIndexes.compactMap { displayRow(at: $0, in: tableRows)?.id }
-    }
-
-    func reselectRows(_ rowIDs: [RowID]) {
-        guard let tableView, !rowIDs.isEmpty else { return }
-        let rows = displayRows(for: rowIDs, in: tableRowsProvider(), rowLimit: tableView.numberOfRows)
-        guard !rows.isEmpty else { return }
-        selectDisplayRows(rows, in: tableView)
-    }
-
-    private func scrollFirstVisibleRow(
-        of placement: GridViewportPlacement,
-        in tableView: NSTableView,
-        tableRows: TableRows
-    ) {
-        let topInset = headerInset(of: tableView)
-        let horizontalOffset = tableView.enclosingScrollView?.contentView.bounds.origin.x ?? 0
-        guard let rowID = placement.firstVisibleRow,
-              let displayRow = DisplayRowMapping.displayIndex(forRowID: rowID, displayIDs: displayIDs, in: tableRows),
-              displayRow < tableView.numberOfRows else {
-            tableView.scroll(NSPoint(x: horizontalOffset, y: -topInset))
-            return
-        }
-        let rowOrigin = tableView.rect(ofRow: displayRow).minY
-        tableView.scroll(NSPoint(x: horizontalOffset, y: rowOrigin + placement.firstVisibleOffset - topInset))
-    }
-
-    private func headerInset(of tableView: NSTableView) -> CGFloat {
-        tableView.enclosingScrollView?.contentView.contentInsets.top ?? 0
-    }
-
-    private func unobscuredVisibleRect(of tableView: NSTableView) -> NSRect {
-        let topInset = headerInset(of: tableView)
-        var rect = tableView.visibleRect
-        rect.origin.y += topInset
-        rect.size.height = max(0, rect.size.height - topInset)
-        return rect
-    }
-
-    /// One pass over a value filter's display order, so a large restored selection is not a search per row.
-    private func displayRows(for rowIDs: [RowID], in tableRows: TableRows, rowLimit: Int) -> IndexSet {
-        guard let displayIDs, rowIDs.count > 1 else {
-            return IndexSet(
-                rowIDs
-                    .compactMap { DisplayRowMapping.displayIndex(forRowID: $0, displayIDs: displayIDs, in: tableRows) }
-                    .filter { $0 < rowLimit }
-            )
-        }
-        let wanted = Set(rowIDs)
-        var rows = IndexSet()
-        for (position, id) in displayIDs.prefix(rowLimit).enumerated() where wanted.contains(id) {
-            rows.insert(position)
-        }
-        return rows
-    }
-
-    private func selectDisplayRows(_ rows: IndexSet, in tableView: NSTableView) {
-        selectionController.clear()
-        selectRowsProgrammatically(rows, in: tableView)
-        publishRowSelection(rowSelection: Set(rows))
-    }
-}
diff --git a/apple/TablePro/Views/Results/FindBarView.swift b/apple/TablePro/Views/Results/FindBarView.swift
deleted file mode 100644
index 6c65a62625..0000000000
--- a/apple/TablePro/Views/Results/FindBarView.swift
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-//  FindBarView.swift
-//  TablePro
-//
-
-import SwiftUI
-
-struct FindBarView: View {
-    @ObservedObject var coordinator: MainContentCoordinator
-    let findState: TabFindState
-    /// Changes whenever the rows under the bar are replaced: a page change, a refresh, a re-run, a
-    /// sort, or a value filter. The match list describes display positions, so it is stale the
-    /// moment any of those move and has to be recomputed rather than reused.
-    let rowsRevision: Int
-    let onSearchAllRows: () -> Void
-
-    @State private var term: String = ""
-
-    var body: some View {
-        HStack(spacing: 8) {
-            NativeSearchField(
-                text: $term,
-                placeholder: String(localized: "Find in loaded rows"),
-                controlSize: .regular,
-                onSubmit: { coordinator.findCoordinator.stepForward() },
-                focusOnAppear: true,
-                accessibilityIdentifier: "find-in-results-field"
-            )
-            .frame(maxWidth: 320)
-            .onChange(of: term) { newValue in
-                coordinator.findCoordinator.setTerm(newValue)
-            }
-
-            Text(counterText)
-                .font(.callout)
-                .foregroundStyle(.secondary)
-                .monospacedDigit()
-                .accessibilityLabel(counterText)
-
-            HStack(spacing: 2) {
-                Button(action: { coordinator.findCoordinator.stepBackward() }) {
-                    Image(systemName: "chevron.left")
-                }
-                .help(String(localized: "Previous match"))
-                .accessibilityLabel(String(localized: "Previous match"))
-
-                Button(action: { coordinator.findCoordinator.stepForward() }) {
-                    Image(systemName: "chevron.right")
-                }
-                .help(String(localized: "Next match"))
-                .accessibilityLabel(String(localized: "Next match"))
-            }
-            .buttonStyle(.borderless)
-            .disabled(findState.matches.isEmpty)
-
-            if showsEscalation {
-                Button(String(localized: "Search All Rows"), action: onSearchAllRows)
-                    .buttonStyle(.borderless)
-            }
-
-            Spacer()
-
-            Button(String(localized: "Done")) {
-                coordinator.findCoordinator.dismiss()
-            }
-            .buttonStyle(.borderless)
-        }
-        .padding(.horizontal, 12)
-        .padding(.vertical, 6)
-        .onAppear { term = findState.term }
-        .onChange(of: rowsRevision) { _ in
-            coordinator.findCoordinator.runSearch()
-        }
-    }
-
-    private var counterText: String {
-        guard !findState.term.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return "" }
-        return FindCounterText.text(
-            matchCount: findState.matches.count,
-            currentIndex: findState.currentMatchIndex,
-            scope: findState.scope
-        )
-    }
-
-    /// Escalating rewrites the whole filter set with an OR search, because `filterLogicMode` is one
-    /// mode for every row. Offering it on top of filters the user already applied would either
-    /// discard them or loosen them, so the button only appears when there are none.
-    private var showsEscalation: Bool {
-        guard findState.matches.isEmpty, findState.canEscalateToAllRows, coordinator.supportsMatchAnyFilters else {
-            return false
-        }
-        return coordinator.selectedTabFilterState.filters.isEmpty
-    }
-}
diff --git a/apple/TablePro/Views/Results/HeldRowsGridDelegate.swift b/apple/TablePro/Views/Results/HeldRowsGridDelegate.swift
deleted file mode 100644
index 82285bbe20..0000000000
--- a/apple/TablePro/Views/Results/HeldRowsGridDelegate.swift
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-//  HeldRowsGridDelegate.swift
-//  TablePro
-//
-
-import AppKit
-import Combine
-
-/// Carries a grid's header clicks back to the view that holds its rows.
-///
-/// `DataGridView` announces a sort rather than performing one, because every grid it normally
-/// draws re-runs its query to get the next page in the new order. The agent result pane and a table
-/// listing hold their whole result and have no query to re-run, so they answer the announcement
-/// themselves.
-@MainActor
-internal final class HeldRowsGridDelegate: ObservableObject, DataGridViewDelegate {
-    internal var onSortStateChanged: ((SortState) -> Void)?
-    private weak var gridCoordinator: TableViewCoordinator?
-
-    internal func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        gridCoordinator = tableViewCoordinator
-    }
-
-    internal func dataGridSortStateChanged(_ state: SortState) {
-        onSortStateChanged?(state)
-    }
-
-    internal func dataGridCopyRows(_ indices: Set<Int>) {
-        gridCoordinator?.copyRowsAsTSV(at: indices, includeHeaders: false)
-    }
-}
diff --git a/apple/TablePro/Views/Results/KeyHandlingTableView+CopyCommands.swift b/apple/TablePro/Views/Results/KeyHandlingTableView+CopyCommands.swift
deleted file mode 100644
index 35f91a9678..0000000000
--- a/apple/TablePro/Views/Results/KeyHandlingTableView+CopyCommands.swift
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-//  KeyHandlingTableView+CopyCommands.swift
-//  TablePro
-//
-
-import AppKit
-
-extension KeyHandlingTableView: GridCopyCommandResponding {
-    func copyCellValue(_ sender: Any?) {
-        guard let cell = pasteAnchorCell() else { return }
-        coordinator?.copyCellValue(at: cell.row, columnIndex: cell.column)
-    }
-
-    func copyRowsAsCsv(_ sender: Any?) {
-        copySelectedRows(as: .csv)
-    }
-
-    func copyRowsAsCsvWithHeaders(_ sender: Any?) {
-        copySelectedRows(as: .csvWithHeaders)
-    }
-
-    func copyRowsAsMarkdown(_ sender: Any?) {
-        copySelectedRows(as: .markdown)
-    }
-
-    func copyRowsAsInClause(_ sender: Any?) {
-        guard let coordinator, let column = inClauseColumn() else { return }
-        coordinator.copyRowsAsInClause(at: coordinator.currentRowSelection(), columnIndex: column)
-    }
-
-    func copyRowsAsInsertStatements(_ sender: Any?) {
-        guard let coordinator, coordinator.canCopyRowsAsInsert else { return }
-        coordinator.copyRowsAsInsert(at: coordinator.currentRowSelection())
-    }
-
-    func copyRowsAsUpdateStatements(_ sender: Any?) {
-        guard let coordinator, coordinator.canCopyRowsAsUpdate else { return }
-        coordinator.copyRowsAsUpdate(at: coordinator.currentRowSelection())
-    }
-
-    // Nil for any other action, so the caller falls through to its own validation.
-    func canPerformCopyCommand(_ action: Selector?) -> Bool? {
-        switch action {
-        case #selector(GridCopyCommandResponding.copyCellValue(_:)):
-            return pasteAnchorCell() != nil
-        case #selector(GridCopyCommandResponding.copyRowsAsCsv(_:)),
-             #selector(GridCopyCommandResponding.copyRowsAsCsvWithHeaders(_:)),
-             #selector(GridCopyCommandResponding.copyRowsAsMarkdown(_:)):
-            return hasRowsToCopy
-        case #selector(GridCopyCommandResponding.copyRowsAsInClause(_:)):
-            return hasRowsToCopy && inClauseColumn() != nil
-        case #selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:)):
-            return hasRowsToCopy && coordinator?.canCopyRowsAsInsert == true
-        case #selector(GridCopyCommandResponding.copyRowsAsUpdateStatements(_:)):
-            return hasRowsToCopy && coordinator?.canCopyRowsAsUpdate == true
-        default:
-            return nil
-        }
-    }
-
-    // The Structure grids list definitions, and an INSERT built from them would target the table they describe.
-    private var hasRowsToCopy: Bool {
-        guard let coordinator, coordinator.appliesRowCopyFormat else { return false }
-        return !coordinator.currentRowSelection().isEmpty
-    }
-
-    private func copySelectedRows(as format: RowCopyFormat) {
-        guard let coordinator, coordinator.appliesRowCopyFormat else { return }
-        coordinator.copyRows(at: coordinator.currentRowSelection(), as: format)
-    }
-
-    // The one column a cell selection covers, else the focused cell's, as the row menu takes the clicked one.
-    private func inClauseColumn() -> Int? {
-        if let coordinator, !coordinator.selectionController.isEmpty {
-            let columns = coordinator.dataColumnIndices(in: coordinator.selectionController.selection.affectedColumns)
-            if columns.count == 1 { return columns[0] }
-        }
-        return pasteAnchorCell()?.column
-    }
-}
diff --git a/apple/TablePro/Views/Results/KeyHandlingTableView.swift b/apple/TablePro/Views/Results/KeyHandlingTableView.swift
deleted file mode 100644
index 3677d7f24f..0000000000
--- a/apple/TablePro/Views/Results/KeyHandlingTableView.swift
+++ /dev/null
@@ -1,939 +0,0 @@
-import AppKit
-
-final class KeyHandlingTableView: NSTableView {
-    weak var coordinator: TableViewCoordinator?
-    weak var selectionOverlay: GridSelectionOverlay?
-
-    /// A table with no grid draws the app's theme.
-    var themeScope: ThemeScope {
-        coordinator?.themeScope ?? .live
-    }
-
-    private var isRaisingOverlay = false
-
-    override var acceptsFirstResponder: Bool {
-        true
-    }
-
-    override func viewDidMoveToWindow() {
-        super.viewDidMoveToWindow()
-        guard coordinator?.tabType == .table, let window,
-              let mainCoordinator = (coordinator?.delegate as? DataTabGridDelegate)?.coordinator,
-              mainCoordinator.consumePendingGridFocus() else { return }
-        window.makeFirstResponder(self)
-    }
-
-    /// The table's background, and the column separators continued past the last row.
-    ///
-    /// A row view covers whatever the table view drew beneath it, so the separators here reach only
-    /// the area no row occupies, which is exactly the area the rows cannot draw. The background is
-    /// the grid's own rather than `super`'s, for the reason on
-    /// `DataGridBodyChrome.drawTableBackground(in:of:)`.
-    override func drawBackground(inClipRect clipRect: NSRect) {
-        DataGridBodyChrome.drawTableBackground(in: clipRect, of: self, scope: themeScope)
-        guard let coordinator else { return }
-        let lastRowBottom = numberOfRows > 0 ? rect(ofRow: numberOfRows - 1).maxY : bounds.minY
-        let belowRows = clipRect.intersection(
-            NSRect(x: clipRect.minX, y: lastRowBottom, width: clipRect.width, height: bounds.height)
-        )
-        guard !belowRows.isEmpty else { return }
-        DataGridBodyChrome.drawColumnSeparators(
-            in: belowRows,
-            of: self,
-            tableView: self,
-            presentsColumn: { coordinator.presentsColumn(atTableColumnIndex: $0) }
-        )
-    }
-
-    /// A reload changes which rows the pinned row gutter numbers, and the gutter is not a subview of
-    /// the table, so nothing the reload redraws reaches it. Its frame follows the table's only once
-    /// the rows outgrow the viewport, so a result with fewer rows than the one before it left the
-    /// old numbers painted beside rows that were gone.
-    override func reloadData() {
-        super.reloadData()
-        coordinator?.repaintRowGutter()
-    }
-
-    /// AppKit sizes the table to its columns, so the document ends at the last column's divider.
-    /// Widening the frame AppKit proposes, rather than insetting the clip view, keeps the header and
-    /// the row views covering the trailing space, and holds through reloads, column changes and
-    /// window resizes. Measured on macOS 27, the same padding added in `tile()` was lost on
-    /// `reloadData` and on a clip resize.
-    override func setFrameSize(_ newSize: NSSize) {
-        super.setFrameSize(NSSize(width: max(newSize.width, trailingExtent), height: newSize.height))
-    }
-
-    /// Measured from the last shown column, which is AppKit's own extent: hidden columns and pool
-    /// slots occupy nothing. Asking the pool which columns it presents instead cost ten times as much
-    /// with thousands of surplus slots, and mid-reconcile it can name a column not yet unhidden.
-    private var trailingExtent: CGFloat {
-        guard let last = tableColumns.lastIndex(where: { !$0.isHidden }) else { return 0 }
-        return rect(ofColumn: last).maxX + DataGridMetrics.trailingSpace
-    }
-
-    /// AppKit reorders `tableColumns` as a dragged column passes each neighbour but posts
-    /// `columnDidMoveNotification` only at mouse-up, where the coordinator settles the new order.
-    /// The body follows the drag step by step, so the map from a data column to where it now sits
-    /// has to follow each pass. The display order is read before the first pass and kept: a drag
-    /// that passes a neighbour and comes back leaves the order, and the selection, as they were.
-    override func moveColumn(_ oldIndex: Int, toColumn newIndex: Int) {
-        let isDragging = (headerView?.draggedColumn ?? -1) >= 0
-        if isDragging {
-            _ = coordinator?.presentedDataColumns
-        }
-        super.moveColumn(oldIndex, toColumn: newIndex)
-        guard isDragging else { return }
-        coordinator?.invalidateTableColumnIndexMap()
-    }
-
-    override func didAddSubview(_ subview: NSView) {
-        super.didAddSubview(subview)
-        guard !isRaisingOverlay else { return }
-        isRaisingOverlay = true
-        defer { isRaisingOverlay = false }
-        raiseSelectionOverlayIfNeeded(subview: subview)
-    }
-
-    private func raiseSelectionOverlayIfNeeded(subview: NSView) {
-        guard let selectionOverlay,
-              selectionOverlay.superview === self,
-              subview !== selectionOverlay,
-              subviews.last !== selectionOverlay else { return }
-        addSubview(selectionOverlay)
-    }
-
-    var selection = TableSelection() {
-        didSet {
-            guard let (rows, columns) = selection.reloadIndexes(from: oldValue) else { return }
-            scheduleFocusReload(rows: rows, columns: columns)
-        }
-    }
-
-    private var pendingFocusReloadRows: IndexSet?
-    private var pendingFocusReloadColumns: IndexSet?
-
-    private func scheduleFocusReload(rows: IndexSet, columns: IndexSet) {
-        if pendingFocusReloadRows != nil {
-            pendingFocusReloadRows?.formUnion(rows)
-            pendingFocusReloadColumns?.formUnion(columns)
-            return
-        }
-        pendingFocusReloadRows = rows
-        pendingFocusReloadColumns = columns
-        DispatchQueue.main.async { [weak self] in
-            self?.flushPendingFocusReload()
-        }
-    }
-
-    private func flushPendingFocusReload() {
-        guard let pendingRows = pendingFocusReloadRows,
-              let pendingColumns = pendingFocusReloadColumns else { return }
-        pendingFocusReloadRows = nil
-        pendingFocusReloadColumns = nil
-        let validRows = pendingRows.filteredIndexSet { $0 < numberOfRows }
-        let validColumns = pendingColumns.filteredIndexSet { $0 < numberOfColumns }
-        guard !validRows.isEmpty, !validColumns.isEmpty else { return }
-        coordinator?.redrawCells(rows: validRows, tableColumnIndexes: validColumns)
-    }
-
-    var focusedRow: Int {
-        get { selection.focusedRow }
-        set { selection.focusedRow = newValue }
-    }
-
-    var focusedColumn: Int {
-        get { selection.focusedColumn }
-        set { selection.focusedColumn = newValue }
-    }
-
-    /// Set while the cursor is the one a row selection seeded for the keyboard, not one the user put
-    /// on a cell. A cell click, an arrow key or Tab clears it.
-    var isCursorSeededByRowSelection = false
-
-    /// The cell a Shift+click or Cmd+click starts from when no cell selection exists yet.
-    func pointerSelectionSeed() -> GridCoord? {
-        guard gridSelection?.isEmpty == true, !isCursorSeededByRowSelection else { return nil }
-        return focusedGridCoord()
-    }
-
-    private var gridSelection: GridSelectionController? { coordinator?.selectionController }
-
-    private func withProgrammaticRowSelection(_ work: () -> Void) {
-        let coordinator = coordinator
-        let wasApplying = coordinator?.isApplyingProgrammaticRowSelection ?? false
-        coordinator?.isApplyingProgrammaticRowSelection = true
-        work()
-        coordinator?.isApplyingProgrammaticRowSelection = wasApplying
-    }
-
-    private func totalRows() -> Int { numberOfRows }
-
-    /// The columns a selection can span: the presented run, not every slot the result carries. A
-    /// hidden column has no display position, so counting slots would let Shift+Arrow and Select All
-    /// run past the end of the run.
-    private func totalDataColumns() -> Int {
-        coordinator?.presentedColumnCount ?? 0
-    }
-
-    // A point over the pinned band names the frozen column drawn there, not the one scrolled under it.
-    override func column(at point: NSPoint) -> Int {
-        guard let unscrolled = coordinator?.freezingBand()?.unscrolledPoint(point) else {
-            return super.column(at: point)
-        }
-        return super.column(at: unscrolled)
-    }
-
-    override func mouseDown(with event: NSEvent) {
-        window?.makeFirstResponder(self)
-
-        let point = convert(event.locationInWindow, from: nil)
-        let clickedRow = row(at: point)
-        let clickedColumn = column(at: point)
-
-        if event.clickCount == 2 && clickedRow == -1 && coordinator?.isEditable == true {
-            coordinator?.delegate?.dataGridAddRow()
-            return
-        }
-
-        guard clickedRow >= 0,
-              clickedColumn >= 0,
-              clickedColumn < numberOfColumns else {
-            gridSelection?.clear()
-            super.mouseDown(with: event)
-            return
-        }
-
-        let isDataColumn = presentsDataColumn(at: clickedColumn)
-        let modifiers = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-
-        if event.clickCount >= 2 {
-            super.mouseDown(with: event)
-            return
-        }
-
-        guard isDataColumn,
-              let schema = coordinator?.identitySchema,
-              let dataColumn = DataGridView.dataColumnIndex(for: clickedColumn, in: self, schema: schema) else {
-            gridSelection?.clear()
-            super.mouseDown(with: event)
-            if !isDataColumn {
-                focusedRow = -1
-                focusedColumn = -1
-            }
-            return
-        }
-
-        let alreadyFocusedHere = clickedRow == focusedRow && clickedColumn == focusedColumn
-        guard let displayColumn = coordinator?.displayPosition(ofDataColumnIndex: dataColumn) else {
-            super.mouseDown(with: event)
-            return
-        }
-        let coord = GridCoord(row: clickedRow, displayColumn: displayColumn)
-        guard let controller = gridSelection else {
-            super.mouseDown(with: event)
-            return
-        }
-
-        let focus = pointerSelectionSeed()
-        isCursorSeededByRowSelection = false
-        let disposition = controller.beginDrag(at: coord, modifiers: modifiers, focus: focus)
-        switch disposition {
-        case .replaceFocus(let activeCoord):
-            withProgrammaticRowSelection {
-                selectRowIndexes(IndexSet(integer: activeCoord.row), byExtendingSelection: false)
-            }
-            focusedRow = activeCoord.row
-            focusedColumn = coordinator?.tableColumnIndex(forDisplayPosition: activeCoord.displayColumn)
-                ?? clickedColumn
-        case .clearFocus:
-            deselectAll(nil)
-            focusedRow = -1
-            focusedColumn = -1
-        case .clickThrough:
-            super.mouseDown(with: event)
-        }
-
-        trackDrag(initial: coord, schema: schema)
-
-        if modifiers.isEmpty,
-           alreadyFocusedHere,
-           selectedRowIndexes.count == 1,
-           coordinator?.canStartInlineEdit(row: clickedRow, columnIndex: dataColumn) == true {
-            coordinator?.handleCellInteraction(
-                row: clickedRow,
-                tableColumn: clickedColumn,
-                columnIndex: dataColumn,
-                tableView: self
-            )
-        }
-    }
-
-    private func trackDrag(initial: GridCoord, schema: ColumnIdentitySchema) {
-        guard let window, let controller = gridSelection else { return }
-        var dragged = false
-        let mask: NSEvent.EventTypeMask = [.leftMouseDragged, .leftMouseUp]
-        while let event = window.nextEvent(matching: mask) {
-            if event.type == .leftMouseUp {
-                controller.endDrag(dragged: dragged, originalCoord: initial)
-                return
-            }
-            let point = pointClearOfPinnedGutter(convert(event.locationInWindow, from: nil))
-            autoscroll(with: event)
-            guard let rowIdx = clampRow(row(at: point), at: point),
-                  let columnIdx = clampDataColumn(column(at: point), at: point, schema: schema) else { continue }
-            let coord = GridCoord(row: rowIdx, displayColumn: columnIdx)
-            if coord != initial { dragged = true }
-            controller.continueDrag(to: coord)
-        }
-    }
-
-    /// Pushes a drag point out from under the pinned row gutter, and scrolls to reveal what it
-    /// covers.
-    ///
-    /// `autoscroll(with:)` measures against the clip view, which the gutter does not shrink, so a
-    /// drag parked over the strip never scrolls and the column under it resolves normally. The user
-    /// would then be extending the selection over a column the gutter is hiding.
-    ///
-    /// Scrolled through `scroll(_:)`, which moves the header with the rows. Scrolling the clip view
-    /// and reflecting it leaves the header clip where it was, measured on macOS 27, so the headings
-    /// stop lining up with their columns.
-    private func pointClearOfPinnedGutter(_ point: NSPoint) -> NSPoint {
-        guard let clipView = enclosingScrollView?.contentView else { return point }
-        let gutterWidth = DataGridRowGutterView.width(of: self)
-        guard gutterWidth > 0 else { return point }
-        let edge = clipView.bounds.origin.x + gutterWidth
-        guard point.x < edge else { return point }
-        // The first frozen column sits at the gutter's edge at every offset, so nothing needs revealing.
-        if coordinator?.freezingBand() != nil {
-            return NSPoint(x: edge, y: point.y)
-        }
-        let target = max(0, clipView.bounds.origin.x - gutterWidth)
-        if target != clipView.bounds.origin.x {
-            scroll(NSPoint(x: target, y: clipView.bounds.origin.y))
-            return NSPoint(x: max(point.x, target + gutterWidth), y: point.y)
-        }
-        return NSPoint(x: edge, y: point.y)
-    }
-
-    private func clampRow(_ value: Int, at point: NSPoint) -> Int? {
-        guard numberOfRows > 0 else { return nil }
-        return GridDragClamp.row(
-            hit: value,
-            pointY: point.y,
-            rowCount: numberOfRows,
-            lastRowMaxY: rect(ofRow: numberOfRows - 1).maxY
-        )
-    }
-
-    private func clampDataColumn(_ value: Int, at point: NSPoint, schema: ColumnIdentitySchema) -> Int? {
-        guard let first = coordinator?.firstPresentedColumnIndex(),
-              let last = coordinator?.lastPresentedColumnIndex() else { return nil }
-        guard let candidate = GridDragClamp.column(
-            hit: value,
-            pointX: point.x,
-            firstPresented: first,
-            lastPresented: last,
-            lastPresentedMaxX: rect(ofColumn: last).maxX
-        ) else { return nil }
-        guard let dataIndex = DataGridView.dataColumnIndex(for: candidate, in: self, schema: schema) else {
-            return nil
-        }
-        return coordinator?.displayPosition(ofDataColumnIndex: dataIndex)
-    }
-
-    @objc func delete(_ sender: Any?) {
-        guard let coordinator, coordinator.isEditable else { return }
-        let indices = coordinator.currentRowSelection()
-        guard !indices.isEmpty else { return }
-        coordinator.delegate?.dataGridDeleteRows(indices)
-    }
-
-    @objc func copy(_ sender: Any?) {
-        if let controller = gridSelection, !controller.isEmpty {
-            coordinator?.copyGridSelection(controller.selection)
-            return
-        }
-        // A row-number click seeds the cursor for the keyboard only: the user picked the whole row.
-        if !isCursorSeededByRowSelection, let cell = focusedDataCell() {
-            coordinator?.copyCellValue(at: cell.row, columnIndex: cell.columnIndex)
-            return
-        }
-        coordinator?.copyRowsInCopyFormat(at: Set(selectedRowIndexes))
-    }
-
-    @objc func copyRowsAsTSV(_ sender: Any?) {
-        guard let coordinator else { return }
-        coordinator.delegate?.dataGridCopyRows(coordinator.currentRowSelection())
-    }
-
-    /// Select All selects the rows, which is what `NSTableView.selectAll(_:)` itself does: measured
-    /// on macOS 27 it reports every row and no column at all, and AppKit logs that column selection
-    /// is unsupported in a view-based table.
-    ///
-    /// It performs the same reset a row-gutter click does, so the two routes into a whole-row
-    /// selection leave the grid in one state. Building a cell rectangle over the whole grid instead
-    /// made every column indistinguishable from one picked by its heading, so the entire heading row
-    /// painted as selected, and `activeCell` left a cell cursor sitting on the first cell of a
-    /// selection that owns every row.
-    @objc override func selectAll(_ sender: Any?) {
-        let totalRows = totalRows()
-        guard totalRows > 0 else {
-            super.selectAll(sender)
-            return
-        }
-        gridSelection?.clear()
-        /// Marked programmatic, and the cursor cleared after the write rather than before it:
-        /// `tableViewSelectionDidChange` answers an unmarked write by seeding a cell cursor, so
-        /// clearing first left Cmd+A with a cursor on the last row it had just selected.
-        withProgrammaticRowSelection {
-            selectRowIndexes(IndexSet(integersIn: 0..<totalRows), byExtendingSelection: false)
-        }
-        focusedRow = -1
-        focusedColumn = -1
-    }
-
-    private func focusedDataCell() -> (row: Int, columnIndex: Int)? {
-        guard selectedRowIndexes.count == 1,
-              focusedRow >= 0,
-              presentsDataColumn(at: focusedColumn),
-              let schema = coordinator?.identitySchema,
-              let dataColumn = DataGridView.dataColumnIndex(for: focusedColumn, in: self, schema: schema) else {
-            return nil
-        }
-        return (focusedRow, dataColumn)
-    }
-
-    @objc func paste(_ sender: Any?) {
-        guard coordinator?.isEditable == true else { return }
-        if coordinator?.pasteValueIntoSelectedCells() == true { return }
-        if let anchor = pasteAnchorCell(),
-           coordinator?.pasteCellsFromClipboard(anchorRow: anchor.row, anchorColumn: anchor.column) == true {
-            return
-        }
-        coordinator?.delegate?.dataGridPasteRows()
-    }
-
-    /// The cell a paste would land in, and the cell a command about "this cell" acts on.
-    /// Deliberately looser than `focusedDataCell()`, which also requires a single selected row: a
-    /// paste anchors on the focused cell alone.
-    func pasteAnchorCell() -> (row: Int, column: Int)? {
-        guard focusedRow >= 0,
-              presentsDataColumn(at: focusedColumn),
-              let schema = coordinator?.identitySchema,
-              let dataCol = DataGridView.dataColumnIndex(for: focusedColumn, in: self, schema: schema) else {
-            return nil
-        }
-        return (focusedRow, dataCol)
-    }
-
-    /// Both routes `paste(_:)` can take, asked before the menu item is enabled. The item used to be
-    /// enabled whenever the grid was editable and had a delegate, which lit it over query-result
-    /// tabs where `pasteRows()` returns at its first guard. AppKit gives a disabled item its key
-    /// equivalent anyway, so an enabled-but-dead item swallows Command+V in silence.
-    private var canPaste: Bool {
-        guard let coordinator, coordinator.isEditable else { return false }
-        if coordinator.delegate?.dataGridCanPasteRows() == true { return true }
-        if coordinator.canPasteValueIntoSelectedCells() { return true }
-        guard let anchor = pasteAnchorCell() else { return false }
-        return coordinator.canPasteCellsFromClipboard(anchorRow: anchor.row, anchorColumn: anchor.column)
-    }
-
-    override func validateUserInterfaceItem(_ item: NSValidatedUserInterfaceItem) -> Bool {
-        if let command = Self.setValueCommand(for: item.action) {
-            return canApplySetValue(command)
-        }
-        if item.action == #selector(SetValueCommandResponding.setCellsToValue(_:)) {
-            return coordinator?.isSetCellsToValueOffered(for: setValueTargets()) == true
-        }
-        if let canCopy = canPerformCopyCommand(item.action) {
-            return canCopy
-        }
-        switch item.action {
-        case #selector(delete(_:)), #selector(deleteBackward(_:)):
-            let hasGridSelection = gridSelection?.isEmpty == false
-            return coordinator?.isEditable == true && (hasGridSelection || !selectedRowIndexes.isEmpty)
-        case #selector(copy(_:)):
-            let hasGridSelection = gridSelection?.isEmpty == false
-            return hasGridSelection || !selectedRowIndexes.isEmpty
-        case #selector(copyRowsAsTSV(_:)):
-            let hasGridSelection = gridSelection?.isEmpty == false
-            return hasGridSelection || !selectedRowIndexes.isEmpty
-        case #selector(paste(_:)):
-            return canPaste
-        case #selector(insertNewline(_:)):
-            return selectedRow >= 0 && presentsDataColumn(at: focusedColumn)
-        case #selector(selectAll(_:)):
-            return numberOfRows > 0
-        default:
-            return super.validateUserInterfaceItem(item)
-        }
-    }
-
-    override func keyDown(with event: NSEvent) {
-        guard let key = KeyCode(rawValue: event.keyCode) else {
-            super.keyDown(with: event)
-            return
-        }
-
-        let modifiers = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-        let row = selectedRow
-
-        switch key {
-        case .leftArrow:
-            handleArrow(.left, modifiers: modifiers, currentRow: row, event: event)
-            return
-        case .rightArrow:
-            handleArrow(.right, modifiers: modifiers, currentRow: row, event: event)
-            return
-        case .upArrow:
-            handleArrow(.up, modifiers: modifiers, currentRow: row, event: event)
-            return
-        case .downArrow:
-            handleArrow(.down, modifiers: modifiers, currentRow: row, event: event)
-            return
-        case .home, .end, .pageUp, .pageDown:
-            super.keyDown(with: event)
-            return
-        case .space:
-            /// Caps Lock is in `deviceIndependentFlagsMask` and is not a chord modifier, so it has
-            /// to be masked out here the way `BoundKey.matches` masks it.
-            if modifiers.intersection([.command, .shift, .option, .control]) == [.shift] {
-                selectRowsIntersectingSelection()
-                return
-            }
-            if modifiers.intersection([.command, .shift, .option, .control]).isEmpty,
-               coordinator?.toggleCheckboxesForSelection() == true {
-                return
-            }
-        case .delete, .forwardDelete:
-            if modifiers.isEmpty || matchesDeleteShortcut(event) {
-                deleteSelectedRowsIfPossible()
-                return
-            }
-        default:
-            break
-        }
-
-        if let fkCombo = AppSettingsManager.shared.keyboard.shortcut(for: .previewFKReference),
-           !fkCombo.isCleared,
-           fkCombo.matches(event),
-           selectedRow >= 0,
-           presentsDataColumn(at: focusedColumn),
-           let schema = coordinator?.identitySchema,
-           let columnIndex = DataGridView.dataColumnIndex(for: focusedColumn, in: self, schema: schema) {
-            coordinator?.toggleForeignKeyPreview(
-                tableView: self,
-                row: selectedRow,
-                column: focusedColumn,
-                columnIndex: columnIndex
-            )
-            return
-        }
-
-        interpretKeyEvents([event])
-    }
-
-    /// Widens the selection to every whole row it touches, on Shift+Space, which is the spreadsheet
-    /// convention for it.
-    ///
-    /// Numbers spells the same command Option-Command-Return, and that is taken: it is the shipped
-    /// default for Execute Query Without Limit (`KeyboardShortcutModels`), which is a menu item, and
-    /// AppKit resolves a menu key equivalent before the event reaches a view. Plain Space is Preview
-    /// FK here and Control-Space is the editor's completions, so Shift+Space is both free and the
-    /// binding a spreadsheet user already knows.
-    ///
-    /// This is the keyboard half of #2664. The row-number gutter is now pinned, but a route that
-    /// needs no pointer at all is what makes whole-row selection reachable from wherever the cell
-    /// cursor already is, and it is what `GridSelectionController.selectEntireRow` was written for.
-    func selectRowsIntersectingSelection() {
-        guard let coordinator, let controller = gridSelection else { return }
-        let totalColumns = totalDataColumns()
-        guard totalColumns > 0 else { return }
-        let rows = coordinator.currentRowSelection(fallbackRow: focusedRow >= 0 ? focusedRow : nil)
-        guard !rows.isEmpty else { return }
-
-        controller.selectEntireRows(rows, totalColumns: totalColumns)
-        withProgrammaticRowSelection {
-            selectRowIndexes(IndexSet(rows), byExtendingSelection: false)
-        }
-        coordinator.repaintRowGutter()
-    }
-
-    private func matchesDeleteShortcut(_ event: NSEvent) -> Bool {
-        guard let combo = AppSettingsManager.shared.keyboard.shortcut(for: .delete), !combo.isCleared else {
-            return false
-        }
-        return combo.matches(event)
-    }
-
-    private func handleArrow(_ direction: GridSelectionController.Direction, modifiers: NSEvent.ModifierFlags, currentRow: Int, event: NSEvent) {
-        isCursorSeededByRowSelection = false
-        if modifiers.contains(.shift) {
-            if extendGridSelection(direction: direction, jumpToEdge: modifiers.contains(.command)) {
-                return
-            }
-            super.keyDown(with: event)
-            return
-        }
-        gridSelection?.clear()
-        switch direction {
-        case .left: handleLeftArrow(currentRow: currentRow)
-        case .right: handleRightArrow(currentRow: currentRow)
-        case .up, .down: super.keyDown(with: event)
-        }
-    }
-
-    private func extendGridSelection(direction: GridSelectionController.Direction, jumpToEdge: Bool) -> Bool {
-        guard let controller = gridSelection else { return false }
-        let seed = controller.isEmpty ? focusedGridCoord() : nil
-        guard !controller.isEmpty || seed != nil else { return false }
-        controller.extendActiveCell(
-            from: seed,
-            direction: direction,
-            jumpToEdge: jumpToEdge,
-            totalRows: totalRows(),
-            totalColumns: totalDataColumns()
-        )
-        return true
-    }
-
-    private func focusedGridCoord() -> GridCoord? {
-        guard let cell = focusedDataCell(),
-              let displayColumn = coordinator?.displayPosition(ofDataColumnIndex: cell.columnIndex) else { return nil }
-        return GridCoord(row: cell.row, displayColumn: displayColumn)
-    }
-
-    @objc override func insertNewline(_ sender: Any?) {
-        let row = selectedRow
-        guard row >= 0,
-              presentsDataColumn(at: focusedColumn),
-              let schema = coordinator?.identitySchema,
-              let columnIndex = DataGridView.dataColumnIndex(for: focusedColumn, in: self, schema: schema),
-              let coordinator else {
-            return
-        }
-        // The cell cursor can sit on a column the window left out, and a cell with no view behind
-        // it opens nothing at all. Reaching it first also puts it on screen, where the editor the
-        // keystroke is about to open belongs.
-        coordinator.scrollColumnToVisible(tableColumnIndex: focusedColumn)
-        coordinator.handleCellInteraction(row: row, tableColumn: focusedColumn, columnIndex: columnIndex, tableView: self)
-    }
-
-    /// Escape gives the grid back, whichever kind of selection owns it.
-    ///
-    /// The row arm is not optional: Select All no longer leaves a cell rectangle behind, so without
-    /// it Escape would answer Cmd+A by falling through to `super` and doing nothing.
-    @objc override func cancelOperation(_ sender: Any?) {
-        if let controller = gridSelection, !controller.isEmpty {
-            controller.clear()
-            return
-        }
-        guard !selectedRowIndexes.isEmpty else {
-            super.cancelOperation(sender)
-            return
-        }
-        deselectAll(nil)
-        focusedRow = -1
-        focusedColumn = -1
-    }
-
-    private func deleteSelectedRowsIfPossible() {
-        guard coordinator?.isEditable == true else { return }
-        guard gridSelection?.isEmpty == false || !selectedRowIndexes.isEmpty else { return }
-        delete(nil)
-    }
-
-    private func handleLeftArrow(currentRow: Int) {
-        let target = focusedColumn < 0
-            ? lastVisibleDataColumn()
-            : previousVisibleDataColumn(before: focusedColumn)
-        guard presentsDataColumn(at: target) else { return }
-        focusedColumn = target
-        coordinator?.dismissFKPreviewOnColumnChange()
-        if currentRow >= 0 { coordinator?.scrollColumnToVisible(tableColumnIndex: target) }
-    }
-
-    private func handleRightArrow(currentRow: Int) {
-        let target = presentsDataColumn(at: focusedColumn)
-            ? nextVisibleDataColumn(after: focusedColumn)
-            : firstVisibleDataColumn()
-        guard presentsDataColumn(at: target) else { return }
-        focusedColumn = target
-        coordinator?.dismissFKPreviewOnColumnChange()
-        if currentRow >= 0 { coordinator?.scrollColumnToVisible(tableColumnIndex: target) }
-    }
-
-    private func firstVisibleDataColumn() -> Int {
-        coordinator?.firstPresentedColumnIndex() ?? -1
-    }
-
-    private func lastVisibleDataColumn() -> Int {
-        coordinator?.lastPresentedColumnIndex() ?? -1
-    }
-
-    private func nextVisibleDataColumn(after current: Int) -> Int {
-        coordinator?.nextPresentedColumnIndex(after: current) ?? -1
-    }
-
-    private func previousVisibleDataColumn(before current: Int) -> Int {
-        coordinator?.previousPresentedColumnIndex(before: current) ?? -1
-    }
-
-    /// Whether this position in `tableColumns` holds one of the columns the result presents.
-    ///
-    /// The row-number column and the window's two spacers are attached columns as well, and one
-    /// spacer sits immediately before the first data column, so no fixed position answers this.
-    func presentsDataColumn(at index: Int) -> Bool {
-        guard index >= 0, index < numberOfColumns else { return false }
-        guard let coordinator else { return !tableColumns[index].isHidden }
-        return coordinator.presentsColumn(atTableColumnIndex: index)
-    }
-
-    /// `NSResponder` declares these two but does not implement them, so calling `super` raises
-    /// `doesNotRecognizeSelector`. With no cell cursor to move, Tab has to leave the grid the way
-    /// it leaves any other view, or focus is trapped here for the rest of the session.
-    /// VoiceOver follows the focused element, and a table view reports itself rather than the
-    /// cell the grid's own cursor is on, so the cursor was invisible to it. The selected-cells
-    /// override is clamped to the visible rows: AppKit will happily ask for every cell in a
-    /// million-row selection otherwise.
-    /// The cursor moved, so assistive technology is told to re-read where focus now is.
-    ///
-    /// A cell is drawn rather than mounted, so the element comes from the row's own accessibility
-    /// children rather than from a cell view.
-    ///
-    /// Nothing is posted until a client has asked the grid something. The element does not exist
-    /// before that, so the notification had nowhere to land, and asking for it was itself enough to
-    /// mount a view per visible cell in every grid: the cost `#2381` removed, charged to a session
-    /// that pressed Tab once.
-    internal func postCellCursorMoved() {
-        guard DataGridAccessibility.isActive else { return }
-        guard selectedRow >= 0, presentsDataColumn(at: focusedColumn) else { return }
-        guard let element = accessibilityCellElement(row: selectedRow, tableColumnIndex: focusedColumn) else { return }
-        NSAccessibility.post(element: element, notification: .focusedUIElementChanged)
-    }
-
-    /// What stands for one cell: the view mounted for accessibility, which exists only once a
-    /// client has asked the grid anything. Asking marks accessibility active, so the first such
-    /// question is also what brings the views into being.
-    private func accessibilityCellElement(row: Int, tableColumnIndex: Int) -> Any? {
-        DataGridAccessibility.markActive()
-        return view(atColumn: tableColumnIndex, row: row, makeIfNecessary: false) as? DataGridCellAccessibilityView
-    }
-
-    override func accessibilityCell(forColumn column: Int, row: Int) -> Any? {
-        accessibilityCellElement(row: row, tableColumnIndex: column) ?? super.accessibilityCell(forColumn: column, row: row)
-    }
-
-    /// Anything walking the tree reaches here, which is the grid's signal that a client is attached.
-    override func accessibilityChildren() -> [Any]? {
-        DataGridAccessibility.markActive()
-        return super.accessibilityChildren()
-    }
-
-    /// `NSTableView` answers an accessibility hit test itself and stops at a cell, so a point inside
-    /// a row but outside every column resolved to the table rather than to the row: an ancestor
-    /// rather than a descendant, which a client reads as the row not being reachable at that point.
-    /// A result narrower than the grid leaves most of each row in exactly that state.
-    override func accessibilityHitTest(_ point: NSPoint) -> Any? {
-        DataGridAccessibility.markActive()
-        guard let window else { return super.accessibilityHitTest(point) }
-        let local = convert(window.convertPoint(fromScreen: point), from: nil)
-        let index = row(at: local)
-        guard index >= 0, let rowView = rowView(atRow: index, makeIfNecessary: false) else {
-            return super.accessibilityHitTest(point)
-        }
-        return rowView.accessibilityHitTest(point) ?? rowView
-    }
-
-    override func accessibilitySelectedCells() -> [Any]? {
-        guard let controller = gridSelection, !controller.isEmpty else {
-            return super.accessibilitySelectedCells()
-        }
-        let visible = rows(in: visibleRect)
-        guard visible.length > 0 else { return [] }
-        var cells: [Any] = []
-        for rectangle in controller.selection.rectangles {
-            for row in rectangle.rows where NSLocationInRange(row, visible) {
-                for displayColumn in rectangle.columns {
-                    guard let position = coordinator?.tableColumnIndex(forDisplayPosition: displayColumn),
-                          let element = accessibilityCellElement(row: row, tableColumnIndex: position) else { continue }
-                    cells.append(element)
-                }
-            }
-        }
-        return cells
-    }
-
-    override func insertTab(_ sender: Any?) {
-        guard !moveFocusToNextCell() else { return }
-        window?.selectKeyView(following: self)
-    }
-
-    override func insertBacktab(_ sender: Any?) {
-        guard !moveFocusToPreviousCell() else { return }
-        window?.selectKeyView(preceding: self)
-    }
-
-    private func moveFocusToNextCell() -> Bool {
-        let row = selectedRow
-        guard row >= 0, presentsDataColumn(at: focusedColumn) else { return false }
-
-        var nextColumn = nextVisibleDataColumn(after: focusedColumn)
-        var nextRow = row
-        if nextColumn < 0 {
-            let wrapped = firstVisibleDataColumn()
-            guard wrapped >= 0, row + 1 < numberOfRows else { return true }
-            nextColumn = wrapped
-            nextRow = row + 1
-        }
-        focusCell(row: nextRow, column: nextColumn)
-        return true
-    }
-
-    private func moveFocusToPreviousCell() -> Bool {
-        let row = selectedRow
-        guard row >= 0, presentsDataColumn(at: focusedColumn) else { return false }
-
-        var previousColumn = previousVisibleDataColumn(before: focusedColumn)
-        var previousRow = row
-        if previousColumn < 0 {
-            let wrapped = lastVisibleDataColumn()
-            guard wrapped >= 0, row > 0 else { return true }
-            previousColumn = wrapped
-            previousRow = row - 1
-        }
-        focusCell(row: previousRow, column: previousColumn)
-        return true
-    }
-
-    /// The one way the cell cursor is moved by a keystroke, used by Tab inside the grid and by the
-    /// inline editor's own Tab and arrow navigation.
-    internal func focusCell(row: Int, column: Int) {
-        selectRowIndexes(IndexSet(integer: row), byExtendingSelection: false)
-        isCursorSeededByRowSelection = false
-        focusedRow = row
-        focusedColumn = column
-        scrollRowToVisible(row)
-        coordinator?.scrollColumnToVisible(tableColumnIndex: column)
-        postCellCursorMoved()
-    }
-
-    override func rightMouseDown(with event: NSEvent) {
-        let point = convert(event.locationInWindow, from: nil)
-        let clickedRow = row(at: point)
-        if clickedRow >= 0, clickIsInsideSelection(row: clickedRow, point: point) {
-            window?.makeFirstResponder(self)
-            if let menu = menu(for: event) {
-                NSMenu.popUpContextMenu(menu, with: event, for: self)
-            }
-            return
-        }
-        super.rightMouseDown(with: event)
-    }
-
-    private func clickIsInsideSelection(row clickedRow: Int, point: NSPoint) -> Bool {
-        if selectedRowIndexes.contains(clickedRow) { return true }
-        guard let controller = gridSelection, !controller.isEmpty else { return false }
-        let clickedColumn = column(at: point)
-        guard clickedColumn >= 0,
-              let schema = coordinator?.identitySchema,
-              let dataColumn = DataGridView.dataColumnIndex(for: clickedColumn, in: self, schema: schema) else {
-            return false
-        }
-        guard let displayColumn = coordinator?.displayPosition(ofDataColumnIndex: dataColumn) else { return false }
-        return controller.selection.contains(row: clickedRow, displayColumn: displayColumn)
-    }
-
-    override func menu(for event: NSEvent) -> NSMenu? {
-        let point = convert(event.locationInWindow, from: nil)
-        let clickedRow = row(at: point)
-        let clickedColumn = column(at: point)
-
-        if clickedRow >= 0, let rowView = rowView(atRow: clickedRow, makeIfNecessary: false) as? DataGridRowView {
-            if let schema = coordinator?.identitySchema,
-               clickedColumn >= 0,
-               let dataColumn = DataGridView.dataColumnIndex(for: clickedColumn, in: self, schema: schema),
-               let controller = gridSelection,
-               !controller.isEmpty,
-               let displayColumn = coordinator?.displayPosition(ofDataColumnIndex: dataColumn),
-               controller.selection.contains(row: clickedRow, displayColumn: displayColumn) {
-                return rowView.contextMenu(for: event)
-            }
-            if !selectedRowIndexes.contains(clickedRow) {
-                selectRowIndexes(IndexSet(integer: clickedRow), byExtendingSelection: false)
-            }
-            return rowView.contextMenu(for: event)
-        }
-
-        if let menu = coordinator?.delegate?.dataGridEmptySpaceMenu() {
-            return menu
-        }
-
-        return super.menu(for: event)
-    }
-}
-
-// MARK: - Edit > Set Value
-
-extension KeyHandlingTableView: SetValueCommandResponding {
-    func setValueEmpty(_ sender: Any?) {
-        applySetValue(.empty)
-    }
-
-    func setValueNull(_ sender: Any?) {
-        applySetValue(.null)
-    }
-
-    func setValueDefault(_ sender: Any?) {
-        applySetValue(.defaultValue)
-    }
-
-    func generateUUIDv4(_ sender: Any?) {
-        applySetValue(.uuid(.v4))
-    }
-
-    func generateUUIDv7(_ sender: Any?) {
-        applySetValue(.uuid(.v7))
-    }
-
-    func setCellsToValue(_ sender: Any?) {
-        coordinator?.setCellsToValue(setValueTargets())
-    }
-
-    static func setValueCommand(for action: Selector?) -> SetValueCommand? {
-        switch action {
-        case #selector(SetValueCommandResponding.setValueEmpty(_:)):
-            return SetValueCommand.empty
-        case #selector(SetValueCommandResponding.setValueNull(_:)):
-            return SetValueCommand.null
-        case #selector(SetValueCommandResponding.setValueDefault(_:)):
-            return SetValueCommand.defaultValue
-        case #selector(SetValueCommandResponding.generateUUIDv4(_:)):
-            return SetValueCommand.uuid(.v4)
-        case #selector(SetValueCommandResponding.generateUUIDv7(_:)):
-            return SetValueCommand.uuid(.v7)
-        default:
-            return nil
-        }
-    }
-
-    /// Dimmed unless some target cell takes the command, as the context menu leaves the item out.
-    private func canApplySetValue(_ command: SetValueCommand) -> Bool {
-        guard let coordinator else { return false }
-        return coordinator.isSetValueOffered(command, for: setValueTargets())
-    }
-
-    private func applySetValue(_ command: SetValueCommand) {
-        coordinator?.applySetValue(command, to: setValueTargets())
-    }
-
-    /// The cell selection, else the focused cell, the way the context menu reads the clicked one.
-    private func setValueTargets() -> [SetValueTarget] {
-        guard let coordinator else { return [] }
-        if gridSelection?.isEmpty == false {
-            return coordinator.setValueTargets(clicked: nil)
-        }
-        guard let anchor = pasteAnchorCell() else { return [] }
-        return coordinator.setValueTargets(clicked: SetValueTarget(displayRow: anchor.row, columnIndex: anchor.column))
-    }
-}
diff --git a/apple/TablePro/Views/Results/ResultMapView.swift b/apple/TablePro/Views/Results/ResultMapView.swift
index 427d082e7a..53b4589a9b 100644
--- a/apple/TablePro/Views/Results/ResultMapView.swift
+++ b/apple/TablePro/Views/Results/ResultMapView.swift
@@ -29,12 +29,12 @@ struct ResultMapView: View {
     let columns: [SpatialColumn]
     let tableRows: TableRows
     let displayIDs: [RowID]?
-    let selectedRowIndices: Set<Int>
+    let selectedRowIDs: Set<RowID>
     let tabId: UUID
     let resultSetId: UUID
     let dataRevision: Int
     let displayRevision: Int
-    let onSelectRow: (Int?) -> Void
+    let onSelectRow: (RowID?) -> Void
 
     @State private var state = ResultPaneProjectionState<ResultMapProjection, ResultMapProjectionKey>()
     @State private var fitToken = 0
@@ -99,18 +99,16 @@ struct ResultMapView: View {
                     Text(projection.diagnostics.emptyReason)
                 }
             } else {
-                /// While a rebuild runs the old shapes stay up. The token names the key they were
-                /// built for, so the new shapes still read as new, and their row ids index the old
-                /// rows, so they take no click and show no selection until the new shapes land.
+                // Old shapes stay up during a rebuild; their row ids index the old rows, so they take no click or selection meanwhile.
                 let isCurrent = state.isCurrent(for: projectionKey)
                 ResultMapCanvas(
                     projection: projection,
                     projectionToken: state.key.hashValue,
-                    selectedRowIDs: isCurrent ? selectedRowIDs(in: projection) : [],
+                    selectedRowIDs: isCurrent ? selectedRowIDs : [],
                     fitToken: fitToken,
                     onSelect: { rowID in
                         guard isCurrent else { return }
-                        select(rowID: rowID)
+                        onSelectRow(rowID)
                     }
                 )
                 .accessibilityIdentifier("result-map")
@@ -123,62 +121,23 @@ struct ResultMapView: View {
         }
     }
 
-    /// The map is one element to VoiceOver: `MKMapView` reports itself as an image and publishes no
-    /// children for overlays, measured. The data grid stays the accessible representation of the
-    /// rows, and this label says what the map adds.
+    // MKMapView reports as an image with no overlay children (measured), so the map is one element and the grid stays the rows.
     private func accessibilityLabel(for projection: ResultMapProjection) -> String {
         let base = String(
             format: String(localized: "Map of %1$d shapes from %2$d rows."),
             projection.diagnostics.drawnShapes,
             projection.diagnostics.drawnRows
         )
-        guard !selectedRowIndices.isEmpty else { return base }
+        guard !selectedRowIDs.isEmpty else { return base }
         return base + " " + String(
             format: String(localized: "%d rows selected."),
-            selectedRowIndices.count
+            selectedRowIDs.count
         )
     }
 
-    // MARK: - Selection
-
-    /// Selection crosses the mode switch through `GridSelectionState`, whose indices are display
-    /// positions rather than offsets into `TableRows.rows`. A per-column value filter makes those
-    /// diverge, so both directions go through `DisplayRowMapping`.
-    private func selectedRowIDs(in projection: ResultMapProjection) -> Set<RowID> {
-        var ids = Set<RowID>()
-        for index in selectedRowIndices {
-            guard let rowIndex = DisplayRowMapping.rowIndex(
-                forDisplay: index,
-                displayIDs: displayIDs,
-                in: tableRows
-            ) else {
-                continue
-            }
-            ids.insert(tableRows.rows[rowIndex].id)
-        }
-        return ids
-    }
-
-    private func select(rowID: RowID?) {
-        guard let rowID else {
-            onSelectRow(nil)
-            return
-        }
-        let displayIndex = DisplayRowMapping.displayIndex(
-            forRowID: rowID,
-            displayIDs: displayIDs,
-            in: tableRows
-        )
-        onSelectRow(displayIndex)
-    }
-
     // MARK: - Projection
 
-    /// A connection switch re-parents the pane and SwiftUI re-runs `task(id:)` with an unchanged
-    /// key; rebuilding then would replace the drawing and lose the user's zoom and pan, so a
-    /// projection already built for that key is kept. `task(id:)` cancels the previous task when
-    /// the key changes, and a cancelled projection commits nothing. New shapes are fitted once they
-    /// are drawn, not when the key changes, so the fit frames them rather than the old ones.
+    // Kept when built for this key: a connection switch re-runs task(id:) with it unchanged, and a rebuild lost zoom and pan.
     private func rebuild(for expectedKey: ResultMapProjectionKey) async {
         if state.isCurrent(for: expectedKey) { return }
         guard let column = resolved else { return }
diff --git a/apple/TablePro/Views/Results/ResultsJsonView.swift b/apple/TablePro/Views/Results/ResultsJsonView.swift
index 5ef2c9812e..0c6b96b9d6 100644
--- a/apple/TablePro/Views/Results/ResultsJsonView.swift
+++ b/apple/TablePro/Views/Results/ResultsJsonView.swift
@@ -8,7 +8,7 @@ import TableProPluginKit
 
 internal struct ResultsJsonView: View {
     let tableRows: TableRows
-    let selectedRowIndices: Set<Int>
+    let selectedRowIDs: Set<RowID>
     let displayIDs: [RowID]?
     let deletedRowIDs: Set<RowID>
     let valueFilter: GridValueFilterState
@@ -31,7 +31,7 @@ internal struct ResultsJsonView: View {
 
     init(
         tableRows: TableRows,
-        selectedRowIndices: Set<Int>,
+        selectedRowIDs: Set<RowID>,
         displayIDs: [RowID]?,
         deletedRowIDs: Set<RowID>,
         valueFilter: GridValueFilterState,
@@ -40,7 +40,7 @@ internal struct ResultsJsonView: View {
         columnLayout: ColumnLayoutState
     ) {
         self.tableRows = tableRows
-        self.selectedRowIndices = selectedRowIndices
+        self.selectedRowIDs = selectedRowIDs
         self.displayIDs = displayIDs
         self.deletedRowIDs = deletedRowIDs
         self.valueFilter = valueFilter
@@ -49,16 +49,16 @@ internal struct ResultsJsonView: View {
         self.columnLayout = columnLayout
         self._viewMode = State(initialValue: AppSettingsManager.shared.editor.jsonViewerPreferredMode)
         self._resolvedRowCount = State(
-            initialValue: selectedRowIndices.isEmpty
+            initialValue: selectedRowIDs.isEmpty
                 ? (displayIDs?.count ?? tableRows.count)
-                : selectedRowIndices.count
+                : selectedRowIDs.count
         )
     }
 
     private struct RenderKey: Equatable {
         let dataRevision: Int
         let displayRevision: Int
-        let selectedRowIndices: Set<Int>
+        let selectedRowIDs: Set<RowID>
         let deletedRowIDs: Set<RowID>
         let valueFilter: GridValueFilterState
         let hiddenColumns: Set<String>
@@ -69,7 +69,7 @@ internal struct ResultsJsonView: View {
         RenderKey(
             dataRevision: dataRevision,
             displayRevision: displayRevision,
-            selectedRowIndices: selectedRowIndices,
+            selectedRowIDs: selectedRowIDs,
             deletedRowIDs: deletedRowIDs,
             valueFilter: valueFilter,
             hiddenColumns: columnLayout.hiddenColumns,
@@ -77,10 +77,7 @@ internal struct ResultsJsonView: View {
         )
     }
 
-    /// Says how much of the result is on screen, and why the rest is not.
-    ///
-    /// Rows marked for deletion are left out of the document, so the count has to name them or they
-    /// read as rows that silently went missing.
+    // Deleted rows are left out of the document, so the count names them or they read as silently missing.
     private var rowCountText: String {
         let rowCount = tableRows.count
         if heldBackDeletionCount > 0 {
@@ -211,15 +208,12 @@ internal struct ResultsJsonView: View {
 
     // MARK: - JSON Generation
 
-    /// A connection switch re-parents the pane and SwiftUI re-runs `task(id:)` with an unchanged
-    /// key; re-serializing every row then gives the tree a new root and recomputes its whole
-    /// projection, so a document already rendered for that key is kept. A cancelled render records
-    /// no key, so the next appearance renders it.
+    // Kept per key: a connection switch re-runs task(id:) with the same key, and re-serializing rebuilds the whole tree.
     private func rebuild(for key: RenderKey) async {
         guard renderedKey != key else { return }
         let snapshot = tableRows
         let ids = displayIDs
-        let selectedIndices = selectedRowIndices
+        let selectedIndices = Set(DataGridRowOrder(filteredIDs: ids, revision: 0).displayIndexes(of: selectedRowIDs, in: snapshot))
         let deletedIDs = deletedRowIDs
         let layout = columnLayout
 
@@ -258,7 +252,7 @@ internal struct ResultsJsonView: View {
         let parseResult: Result<JSONTreeNode, JSONTreeParseError>
     }
 
-    /// Renders the rows the grid is showing, through the same serializer as Copy as JSON.
+    // Same serializer as Copy as JSON.
     nonisolated static func computeJson(
         tableRows: TableRows,
         displayIDs: [RowID]?,
diff --git a/apple/TablePro/Views/Results/Selection/GridDragClamp.swift b/apple/TablePro/Views/Results/Selection/GridDragClamp.swift
deleted file mode 100644
index edb7624eed..0000000000
--- a/apple/TablePro/Views/Results/Selection/GridDragClamp.swift
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-//  GridDragClamp.swift
-//  TablePro
-//
-
-import CoreGraphics
-
-/// Which row and column a drag point names, once `NSTableView`'s "outside" sentinel is read
-/// correctly.
-///
-/// `column(at:)` and `row(at:)` both answer -1 for a point outside every column or row, at *either*
-/// end. The grid used to clamp that sentinel as though it could only mean "before the first", so a
-/// drag past the trailing edge collapsed the selection back to the near edge instead of holding at
-/// the far one.
-///
-/// Measured on a table 429pt wide whose row-number column sits at index 0:
-///
-///     column(at: x = 5000) = -1      column(at: x = -30) = -1
-///     row(at: y = 99999)   = -1      row(at: y = -30)    = -1
-///
-/// So the point decides, not the sentinel. Pure, and separate from the tracking loop, so the
-/// behaviour is testable without a live drag.
-enum GridDragClamp {
-    /// - Returns: the presented column the point names, or nil when the grid presents none.
-    static func column(
-        hit: Int,
-        pointX: CGFloat,
-        firstPresented: Int,
-        lastPresented: Int,
-        lastPresentedMaxX: CGFloat
-    ) -> Int? {
-        guard firstPresented >= 0, lastPresented >= firstPresented else { return nil }
-        guard hit < 0 else { return min(max(hit, firstPresented), lastPresented) }
-        return pointX >= lastPresentedMaxX ? lastPresented : firstPresented
-    }
-
-    /// - Returns: the row the point names, or nil when the grid has no rows.
-    static func row(hit: Int, pointY: CGFloat, rowCount: Int, lastRowMaxY: CGFloat) -> Int? {
-        guard rowCount > 0 else { return nil }
-        guard hit < 0 else { return min(hit, rowCount - 1) }
-        return pointY >= lastRowMaxY ? rowCount - 1 : 0
-    }
-}
diff --git a/apple/TablePro/Views/Results/Selection/GridSelectionController.swift b/apple/TablePro/Views/Results/Selection/GridSelectionController.swift
deleted file mode 100644
index 38d165be0a..0000000000
--- a/apple/TablePro/Views/Results/Selection/GridSelectionController.swift
+++ /dev/null
@@ -1,337 +0,0 @@
-import AppKit
-
-@MainActor
-final class GridSelectionController {
-    enum Direction {
-        case up
-        case down
-        case left
-        case right
-    }
-
-    private(set) var selection: GridSelection = .empty
-
-    weak var tableView: NSTableView?
-    weak var overlay: GridSelectionOverlay?
-    weak var coordinator: TableViewCoordinator?
-
-    private var dragOrigin: GridCoord?
-    private var dragMode: DragMode = .replace
-    private var dragBaseSelection: GridSelection = .empty
-    var onSelectionChange: ((GridSelection) -> Void)?
-
-    var isEmpty: Bool { selection.isEmpty }
-
-    private enum DragMode {
-        case replace
-        case additive
-    }
-
-    func update(_ newSelection: GridSelection) {
-        guard selection != newSelection else { return }
-        let old = selection
-        selection = newSelection
-        overlay?.selection = newSelection
-        let dirty = reloadColumns(for: old, new: newSelection)
-        reloadRowsForFill(old: old, new: newSelection, dirtyColumns: dirty)
-        postAccessibilityAnnouncement(for: newSelection)
-        onSelectionChange?(newSelection)
-    }
-
-    private func postAccessibilityAnnouncement(for newSelection: GridSelection) {
-        guard let tableView else { return }
-        NSAccessibility.post(
-            element: tableView,
-            notification: .announcementRequested,
-            userInfo: [
-                .announcement: Self.accessibilityAnnouncement(for: newSelection),
-                .priority: NSAccessibilityPriorityLevel.medium.rawValue
-            ]
-        )
-        /// The announcement is a one-off sentence. This is the notification a table is supposed
-        /// to post so assistive technology can re-read the selection on its own terms.
-        NSAccessibility.post(element: tableView, notification: .selectedCellsChanged)
-    }
-
-    func clear() {
-        guard !selection.isEmpty else { return }
-        update(.empty)
-    }
-
-    /// `focus` is the cell a plain click left focused. That click clears the cell selection, so
-    /// without it Shift+click and Cmd+click would lose the first cell.
-    func beginDrag(at coord: GridCoord, modifiers: NSEvent.ModifierFlags, focus: GridCoord? = nil) -> MouseDisposition {
-        let cleanModifiers = modifiers.intersection([.command, .shift, .option, .control])
-        if cleanModifiers.contains(.command) && !cleanModifiers.contains(.shift) {
-            dragOrigin = coord
-            dragMode = .additive
-            if selection.isEmpty, let focus {
-                dragBaseSelection = .single(GridRect(cell: focus), anchor: focus, active: focus)
-            } else {
-                dragBaseSelection = selection
-            }
-            return .replaceFocus(coord)
-        }
-        if cleanModifiers.contains(.shift) && !cleanModifiers.contains(.command) {
-            let anchor = selection.anchor ?? focus ?? coord
-            dragOrigin = anchor
-            dragMode = .replace
-            dragBaseSelection = .empty
-            update(.single(GridRect.between(anchor, coord), anchor: anchor, active: coord))
-            return .replaceFocus(coord)
-        }
-        dragOrigin = coord
-        dragMode = .replace
-        dragBaseSelection = .empty
-        if !selection.isEmpty {
-            update(.empty)
-        }
-        return .replaceFocus(coord)
-    }
-
-    func continueDrag(to coord: GridCoord) {
-        guard let origin = dragOrigin else { return }
-        switch dragMode {
-        case .replace:
-            update(.single(GridRect.between(origin, coord), anchor: origin, active: coord))
-        case .additive:
-            var rectangles = dragBaseSelection.rectangles
-            rectangles.append(GridRect.between(origin, coord))
-            /// The picked columns come along. Rebuilding from the base rectangles alone dropped
-            /// them, so a Cmd+drag in the body unpainted a heading the user had picked and took its
-            /// column out of `selectedFullColumnDataIndices`, disabling the column commands.
-            update(
-                GridSelection(
-                    rectangles: rectangles,
-                    activeCell: coord,
-                    anchor: origin,
-                    columns: dragBaseSelection.columns
-                )
-            )
-        }
-    }
-
-    func endDrag(dragged: Bool, originalCoord: GridCoord) {
-        defer {
-            dragOrigin = nil
-            dragMode = .replace
-            dragBaseSelection = .empty
-        }
-        guard !dragged, dragMode == .additive else { return }
-        applyCmdClickToggle(at: originalCoord)
-    }
-
-    private func applyCmdClickToggle(at coord: GridCoord) {
-        guard !dragBaseSelection.contains(coord) else {
-            update(dragBaseSelection.removing(cell: coord))
-            return
-        }
-        update(
-            GridSelection(
-                rectangles: dragBaseSelection.rectangles + [GridRect(cell: coord)],
-                activeCell: coord,
-                anchor: coord,
-                columns: dragBaseSelection.columns
-            )
-        )
-    }
-
-    func selectEntireColumn(_ displayColumn: Int, totalRows: Int) {
-        guard displayColumn >= 0, totalRows > 0 else { return }
-        update(.column(displayColumn, totalRows: totalRows))
-    }
-
-    /// Toggles one column in and out of the selection, which is what Cmd+click means everywhere
-    /// else on the system.
-    ///
-    /// Adding without a matching removal also grew the rectangle list without bound: `union`
-    /// concatenates, so Cmd+clicking one heading twice left two identical rectangles behind, and
-    /// the overlay, the row fill and `columns(in:)` each walk every rectangle for every visible row.
-    func addEntireColumn(_ displayColumn: Int, totalRows: Int) {
-        guard displayColumn >= 0, totalRows > 0 else { return }
-        guard !selection.columns.contains(displayColumn) else {
-            removeEntireColumn(displayColumn, totalRows: totalRows)
-            return
-        }
-        let addition = GridSelection.column(displayColumn, totalRows: totalRows)
-        update(selection.isEmpty ? addition : selection.union(addition))
-    }
-
-    private func removeEntireColumn(_ displayColumn: Int, totalRows: Int) {
-        let dropped = GridRect(rows: 0...(totalRows - 1), columns: displayColumn...displayColumn)
-        let rectangles = selection.rectangles.filter { $0 != dropped }
-        var columns = selection.columns
-        columns.remove(displayColumn)
-        guard let last = rectangles.last else {
-            update(.empty)
-            return
-        }
-        let active = GridCoord(row: last.rows.lowerBound, displayColumn: last.columns.lowerBound)
-        update(GridSelection(rectangles: rectangles, activeCell: active, anchor: active, columns: columns))
-    }
-
-    /// Display positions. `selectedFullColumnDataIndices()` is what a caller indexing column names
-    /// or values wants.
-    func selectedFullColumns() -> IndexSet {
-        selection.columns
-    }
-
-    /// The fully selected columns as data indices, for callers that index `TableRows.columns` or a
-    /// row's values. The inspector's CSV column insert and delete are the reason this exists: a
-    /// display position used there deletes the wrong column of the user's file.
-    func selectedFullColumnDataIndices() -> IndexSet {
-        dataIndices(from: selection.columns)
-    }
-
-    /// Every column the selection touches, as data indices.
-    func affectedDataColumns() -> IndexSet {
-        dataIndices(from: selection.affectedColumns)
-    }
-
-    private func dataIndices(from positions: IndexSet) -> IndexSet {
-        guard let coordinator else { return positions }
-        return IndexSet(coordinator.dataColumnIndices(in: positions))
-    }
-
-    func selectEntireRow(_ row: Int, totalColumns: Int) {
-        selectEntireRows([row], totalColumns: totalColumns)
-    }
-
-    /// Widens a selection to the whole of every row it touches, which is what Shift+Space asks for.
-    ///
-    /// One rectangle per contiguous run, not per row. Gaps have to survive, so a single spanning
-    /// rectangle is wrong, but a rectangle per row is just as wrong at the other end: Select All
-    /// then Shift+Space over a Fetch All result would build hundreds of thousands of them, and the
-    /// overlay, the row fill and `columns(in:)` all walk every rectangle for every visible row.
-    func selectEntireRows(_ rows: some Collection<Int>, totalColumns: Int) {
-        guard totalColumns > 0 else { return }
-        let sorted = rows.filter { $0 >= 0 }.sorted()
-        guard let first = sorted.first else { return }
-        let columns = 0...(totalColumns - 1)
-
-        var rectangles: [GridRect] = []
-        var runStart = first
-        var runEnd = first
-        for row in sorted.dropFirst() {
-            if row == runEnd + 1 {
-                runEnd = row
-                continue
-            }
-            rectangles.append(GridRect(rows: runStart...runEnd, columns: columns))
-            runStart = row
-            runEnd = row
-        }
-        rectangles.append(GridRect(rows: runStart...runEnd, columns: columns))
-
-        let anchor = GridCoord(row: first, displayColumn: 0)
-        update(GridSelection(rectangles: rectangles, activeCell: anchor, anchor: anchor))
-    }
-
-    func extendActiveCell(from seed: GridCoord? = nil, direction: Direction, jumpToEdge: Bool, totalRows: Int, totalColumns: Int) {
-        guard let active = selection.activeCell ?? seed else { return }
-        let origin = selection.anchor ?? seed ?? active
-        let next = step(from: active, direction: direction, jumpToEdge: jumpToEdge, totalRows: totalRows, totalColumns: totalColumns)
-        update(.single(GridRect.between(origin, next), anchor: origin, active: next))
-    }
-
-    func moveActiveCell(direction: Direction, jumpToEdge: Bool, totalRows: Int, totalColumns: Int) -> GridCoord? {
-        guard let active = selection.activeCell else { return nil }
-        let next = step(from: active, direction: direction, jumpToEdge: jumpToEdge, totalRows: totalRows, totalColumns: totalColumns)
-        update(.single(GridRect(cell: next), anchor: next, active: next))
-        return next
-    }
-
-    private func step(from coord: GridCoord, direction: Direction, jumpToEdge: Bool, totalRows: Int, totalColumns: Int) -> GridCoord {
-        switch direction {
-        case .up:
-            return GridCoord(row: jumpToEdge ? 0 : max(0, coord.row - 1), displayColumn: coord.displayColumn)
-        case .down:
-            return GridCoord(
-                row: jumpToEdge ? max(0, totalRows - 1) : min(totalRows - 1, coord.row + 1),
-                displayColumn: coord.displayColumn
-            )
-        case .left:
-            return GridCoord(row: coord.row, displayColumn: jumpToEdge ? 0 : max(0, coord.displayColumn - 1))
-        case .right:
-            return GridCoord(
-                row: coord.row,
-                displayColumn: jumpToEdge
-                    ? max(0, totalColumns - 1)
-                    : min(totalColumns - 1, coord.displayColumn + 1)
-            )
-        }
-    }
-
-    private func reloadColumns(for old: GridSelection, new: GridSelection) -> IndexSet {
-        let union = old.affectedColumns.union(new.affectedColumns)
-        if let headerView = (tableView as? KeyHandlingTableView)?.headerView as? SortableHeaderView {
-            headerView.updateColumnSelectionIndicators(
-                selectedColumns: new.columns,
-                dirtyColumns: union.union(old.columns).union(new.columns)
-            )
-        }
-        return union
-    }
-
-    private func reloadRowsForFill(old: GridSelection, new: GridSelection, dirtyColumns: IndexSet) {
-        guard let tableView = tableView else { return }
-        guard tableView.numberOfRows > 0 else { return }
-
-        let visible = tableView.rows(in: tableView.visibleRect)
-        guard visible.length > 0 else { return }
-        let visibleRange = visible.location..<(visible.location + visible.length)
-
-        var rowsToReload = IndexSet()
-        let oldVisible = old.affectedRows.intersection(IndexSet(integersIn: visibleRange))
-        let newVisible = new.affectedRows.intersection(IndexSet(integersIn: visibleRange))
-        rowsToReload.formUnion(oldVisible.symmetricDifference(newVisible))
-        for row in newVisible where new.columns(in: row) != old.columns(in: row) {
-            rowsToReload.insert(row)
-        }
-        if rowsToReload.isEmpty { return }
-
-        for row in rowsToReload {
-            (tableView.rowView(atRow: row, makeIfNecessary: false) as? DataGridRowView)?.needsDisplay = true
-        }
-    }
-}
-
-internal extension GridSelectionController {
-    static func accessibilityAnnouncement(for selection: GridSelection) -> String {
-        guard let rect = selection.boundingRectangle else {
-            return String(localized: "Cell selection cleared")
-        }
-        return String(
-            format: String(localized: "%d cells selected, rows %d to %d, columns %d to %d"),
-            selection.uniqueCellCount,
-            rect.rows.lowerBound + 1,
-            rect.rows.upperBound + 1,
-            rect.columns.lowerBound + 1,
-            rect.columns.upperBound + 1
-        )
-    }
-
-    func applyInsertedRows(_ indices: IndexSet, newRowCount: Int) {
-        update(selection.insertingRows(indices, newRowCount: newRowCount))
-    }
-
-    func applyRemovedRows(_ indices: IndexSet, newRowCount: Int) {
-        update(selection.removingRows(indices, newRowCount: newRowCount))
-    }
-}
-
-enum MouseDisposition {
-    case replaceFocus(GridCoord)
-    case clearFocus
-    case clickThrough
-}
-
-private extension IndexSet {
-    func symmetricDifference(_ other: IndexSet) -> IndexSet {
-        var result = self
-        result.formUnion(other)
-        let common = self.intersection(other)
-        result.subtract(common)
-        return result
-    }
-}
diff --git a/apple/TablePro/Views/Results/Selection/GridSelectionOverlay.swift b/apple/TablePro/Views/Results/Selection/GridSelectionOverlay.swift
deleted file mode 100644
index ef29cfcdb8..0000000000
--- a/apple/TablePro/Views/Results/Selection/GridSelectionOverlay.swift
+++ /dev/null
@@ -1,139 +0,0 @@
-import AppKit
-import TableProTheme
-
-@MainActor
-final class GridSelectionOverlay: NSView {
-    var selection: GridSelection = .empty {
-        didSet {
-            guard oldValue != selection else { return }
-            needsDisplay = true
-        }
-    }
-
-    weak var tableView: NSTableView?
-    weak var coordinator: TableViewCoordinator?
-
-    private static let borderWidth: CGFloat = 1.0
-    private static let activeCellBorderWidth: CGFloat = 2.0
-    private static let borderAlpha: CGFloat = 0.7
-
-    override init(frame frameRect: NSRect) {
-        super.init(frame: frameRect)
-        wantsLayer = true
-        autoresizingMask = [.width, .height]
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-        wantsLayer = true
-        autoresizingMask = [.width, .height]
-    }
-
-    override var isFlipped: Bool { true }
-    override var acceptsFirstResponder: Bool { false }
-    override func hitTest(_ point: NSPoint) -> NSView? { nil }
-
-    override func viewDidChangeEffectiveAppearance() {
-        super.viewDidChangeEffectiveAppearance()
-        needsDisplay = true
-    }
-
-    override func draw(_ dirtyRect: NSRect) {
-        drawSelection(in: dirtyRect)
-    }
-
-    override func setNeedsDisplay(_ invalidRect: NSRect) {
-        super.setNeedsDisplay(invalidRect)
-        coordinator?.pinnedBandNeedsDisplay(tableRect: invalidRect)
-    }
-
-    // Also drawn by the pinned band, in a context translated to the table's origin.
-    func drawSelection(in dirtyRect: NSRect) {
-        guard let tableView, let coordinator else { return }
-        let editingCell = activeOverlayCell(in: coordinator)
-
-        let resolved = coordinator.themeScope.resolved
-        Self.rangeBorderColor(resolved).setStroke()
-        for rect in selection.rectangles {
-            guard let frame = frame(for: rect, in: tableView, coordinator: coordinator) else { continue }
-            guard frame.intersects(dirtyRect) else { continue }
-            if isPickedColumn(rect, columns: selection.columns) { continue }
-            if let editingCell, rect.contains(editingCell) { continue }
-            let inset = frame.insetBy(dx: Self.borderWidth / 2, dy: Self.borderWidth / 2)
-            let path = NSBezierPath(rect: inset)
-            path.lineWidth = Self.borderWidth
-            path.stroke()
-        }
-
-        if let active = selection.activeCell,
-           editingCell != active,
-           selection.rectangles.count > 1 || (selection.rectangles.first?.rows.count ?? 0) > 1 || (selection.rectangles.first?.columns.count ?? 0) > 1,
-           let frame = frame(for: GridRect(cell: active), in: tableView, coordinator: coordinator),
-           frame.intersects(dirtyRect) {
-            Self.activeCellBorderColor(resolved).setStroke()
-            let inset = frame.insetBy(dx: Self.activeCellBorderWidth / 2, dy: Self.activeCellBorderWidth / 2)
-            let path = NSBezierPath(rect: inset)
-            path.lineWidth = Self.activeCellBorderWidth
-            path.stroke()
-        }
-    }
-
-    static func activeCellBorderColor(_ resolved: ResolvedTheme) -> NSColor {
-        resolved.isOverridden(.gridFocusBorder) ? resolved[.gridFocusBorder] : .controlAccentColor
-    }
-
-    /// A theme's opaque selection fill hides the selection at 70%, so the outline takes the active
-    /// cell's border color instead, the way the native outline and active cell share the accent.
-    static func rangeBorderColor(_ resolved: ResolvedTheme) -> NSColor {
-        let base = resolved.isOverridden(.gridSelection) ? activeCellBorderColor(resolved) : resolved[.gridSelection]
-        let alpha = borderAlpha
-        return NSColor(name: nil) { _ in base.withAlphaComponent(alpha) }
-    }
-
-    private func activeOverlayCell(in coordinator: TableViewCoordinator) -> GridCoord? {
-        if let editor = coordinator.overlayEditor, editor.isActive,
-           let position = coordinator.displayPosition(ofDataColumnIndex: editor.columnIndex) {
-            return GridCoord(row: editor.row, displayColumn: position)
-        }
-        if let viewer = coordinator.overlayViewer, viewer.isActive,
-           let position = coordinator.displayPosition(ofDataColumnIndex: viewer.columnIndex) {
-            return GridCoord(row: viewer.row, displayColumn: position)
-        }
-        return nil
-    }
-
-    /// A column the user picked by its heading needs no outline, because the heading itself carries
-    /// the selection.
-    ///
-    /// Asked of the picked columns rather than of the rectangle's height. A block whose rows happen
-    /// to reach both ends of the page is not a column selection, and skipping its outline left an
-    /// ordinary swept block with no border at all on a short page, and nothing visible whatsoever in
-    /// a one-row result.
-    private func isPickedColumn(_ rect: GridRect, columns: IndexSet) -> Bool {
-        guard !columns.isEmpty else { return false }
-        return columns.contains(integersIn: rect.columns.lowerBound...rect.columns.upperBound)
-    }
-
-    private func frame(for rect: GridRect, in tableView: NSTableView, coordinator: TableViewCoordinator) -> NSRect? {
-        guard tableView.numberOfRows > 0, tableView.numberOfColumns > 0 else { return nil }
-        let firstRow = max(0, rect.rows.lowerBound)
-        let lastRow = min(tableView.numberOfRows - 1, rect.rows.upperBound)
-        guard firstRow <= lastRow else { return nil }
-
-        let rowRectTop = tableView.rect(ofRow: firstRow)
-        let rowRectBottom = tableView.rect(ofRow: lastRow)
-        let topY = rowRectTop.minY
-        let bottomY = rowRectBottom.maxY
-
-        var leadingX = CGFloat.infinity
-        var trailingX = -CGFloat.infinity
-        for position in rect.columns.lowerBound...rect.columns.upperBound {
-            guard let tableColumnIndex = coordinator.tableColumnIndex(forDisplayPosition: position) else { continue }
-            let columnRect = tableView.rect(ofColumn: tableColumnIndex)
-            leadingX = min(leadingX, columnRect.minX)
-            trailingX = max(trailingX, columnRect.maxX)
-        }
-        guard trailingX > leadingX else { return nil }
-        return NSRect(x: leadingX, y: topY, width: trailingX - leadingX, height: bottomY - topY)
-    }
-}
diff --git a/apple/TablePro/Views/Results/SelectionSummaryTracker.swift b/apple/TablePro/Views/Results/SelectionSummaryTracker.swift
index ca1cf59b56..60c4ae9b31 100644
--- a/apple/TablePro/Views/Results/SelectionSummaryTracker.swift
+++ b/apple/TablePro/Views/Results/SelectionSummaryTracker.swift
@@ -55,7 +55,7 @@ final class SelectionSummaryTracker {
         currentSummary = nil
     }
 
-    /// A drag reports every step and a paste every cell, so the calls of one turn share one run.
+    // A drag reports every step and a paste every cell, so the calls of one turn share one run.
     private func scheduleRecompute() {
         guard state != nil else {
             cancel()
@@ -88,27 +88,3 @@ final class SelectionSummaryTracker {
         state.publish(summary, from: owner)
     }
 }
-
-internal extension TableViewCoordinator {
-    /// Nil while fewer than two cells are selected, which is when the grid reports no summary.
-    func selectionSummaryInput() -> SelectionSummaryInput? {
-        let selection = selectionController.selection
-        guard selection.hasMultipleCells else { return nil }
-        let tableRows = tableRowsProvider()
-        let policy = delegate?.dataGridSummaryColumnPolicy() ?? .derived(
-            columnTypes: tableRows.columnTypes,
-            displayFormats: columnDisplayFormats,
-            columnCount: tableRows.columns.count
-        )
-        return SelectionSummaryInput(
-            selection: selection,
-            tableRows: tableRows,
-            displayIDs: displayIDs,
-            dataColumnsByDisplayPosition: presentedDataColumns,
-            policy: policy,
-            deletedRowIDs: changeManager.deletedRowIDs,
-            insertedRowIDs: changeManager.insertedRowIDs,
-            modifiedCells: changeManager.modifiedCells
-        )
-    }
-}
diff --git a/apple/TablePro/Views/Results/SortableHeaderCell.swift b/apple/TablePro/Views/Results/SortableHeaderCell.swift
deleted file mode 100644
index fb340549ab..0000000000
--- a/apple/TablePro/Views/Results/SortableHeaderCell.swift
+++ /dev/null
@@ -1,341 +0,0 @@
-//
-//  SortableHeaderCell.swift
-//  TablePro
-//
-
-import AppKit
-import TableProTheme
-
-@MainActor
-final class SortableHeaderCell: NSTableHeaderCell {
-    var sortDirection: SortDirection?
-    var sortPriority: Int?
-    /// The order came from the Default row sort setting, not from a click.
-    ///
-    /// Drawn muted and without a priority number, so the grid can say the rows are ordered without
-    /// claiming the user ordered them.
-    var isDefaultSort: Bool = false
-    var isColumnSelected: Bool = false
-    var isEmphasized: Bool = true
-    var isValueFiltered: Bool = false
-    var isFunnelVisible: Bool = false
-    var supportsValueFilter: Bool = true
-    /// Switched off for one pass of `SortableHeaderView.draw`: the row-number and frozen titles belong
-    /// to the pinned headings alone, and the overhang a bounce exposes takes a heading's chrome with no cell.
-    var drawsInterior = true
-    var drawsDivider = true
-
-    private static let indicatorPadding: CGFloat = 4
-    private static let indicatorSpacing: CGFloat = 2
-    private static let priorityFontSize: CGFloat = 9
-    private static let commentFontSize: CGFloat = 10
-    private static let commentLineSpacing: CGFloat = 1
-    private static let defaultIndicatorSize = NSSize(width: 9, height: 6)
-    private static let defaultSortIndicatorAlpha: CGFloat = 0.45
-    private static let funnelSize = NSSize(width: 13, height: 13)
-    private static let funnelPointSize: CGFloat = 11
-
-    private static let commentFont = NSFont.systemFont(ofSize: commentFontSize)
-
-    static let commentLineHeight: CGFloat = {
-        let lineHeight = NSAttributedString(
-            string: "X",
-            attributes: [.font: commentFont]
-        ).size().height
-        return (lineHeight + commentLineSpacing).rounded(.up)
-    }()
-
-    override init(textCell string: String) {
-        super.init(textCell: string)
-        lineBreakMode = .byTruncatingTail
-        truncatesLastVisibleLine = true
-        wraps = false
-    }
-
-    required init(coder: NSCoder) {
-        super.init(coder: coder)
-        lineBreakMode = .byTruncatingTail
-        truncatesLastVisibleLine = true
-        wraps = false
-    }
-
-    /// A cell drawn outside the grid's header takes the app's theme.
-    private static func themeScope(of controlView: NSView?) -> ThemeScope {
-        (controlView as? SortableHeaderView)?.themeScope ?? .live
-    }
-
-    override func draw(withFrame cellFrame: NSRect, in controlView: NSView) {
-        if drawsDivider {
-            SortableHeaderChrome.drawColumnDivider(in: cellFrame, scope: Self.themeScope(of: controlView))
-        }
-        guard drawsInterior else { return }
-        drawInterior(withFrame: cellFrame, in: controlView)
-    }
-
-    override func drawInterior(withFrame cellFrame: NSRect, in controlView: NSView) {
-        let scope = Self.themeScope(of: controlView)
-        if isColumnSelected {
-            DataGridBodyChrome.selectionColor(emphasized: isEmphasized, scope: scope).setFill()
-            cellFrame.fill()
-        }
-
-        let foreground = foregroundColor(emphasized: isColumnSelected && isEmphasized, scope: scope)
-        drawTitle(
-            in: titleRect(forBounds: cellFrame),
-            font: titleFont(isSorted: sortDirection != nil && !isDefaultSort),
-            color: foreground,
-            comment: visibleComment(in: controlView),
-            commentColor: commentColor(emphasized: isColumnSelected && isEmphasized, scope: scope)
-        )
-
-        var trailingCursorX = cellFrame.maxX - Self.indicatorPadding
-
-        if supportsValueFilter {
-            if isValueFiltered || isFunnelVisible {
-                let funnelImage = Self.funnelImage(
-                    active: isValueFiltered,
-                    color: funnelColor(active: isValueFiltered, emphasized: isColumnSelected, scope: scope)
-                )
-                let drawSize = funnelImage?.size ?? Self.funnelSize
-                let funnelRect = NSRect(
-                    x: trailingCursorX - drawSize.width,
-                    y: cellFrame.midY - drawSize.height / 2,
-                    width: drawSize.width,
-                    height: drawSize.height
-                )
-                Self.drawIndicator(image: funnelImage, in: funnelRect)
-            }
-            trailingCursorX -= Self.funnelSize.width + Self.indicatorSpacing
-        }
-
-        guard let direction = sortDirection else { return }
-
-        let indicatorColor = isDefaultSort
-            ? foreground.withAlphaComponent(Self.defaultSortIndicatorAlpha)
-            : foreground
-        let indicatorImage = Self.indicatorImage(for: direction, color: indicatorColor)
-        let indicatorSize = indicatorImage?.size ?? Self.defaultIndicatorSize
-        let indicatorOriginX = trailingCursorX - indicatorSize.width
-        let indicatorOriginY = cellFrame.midY - indicatorSize.height / 2
-        let indicatorRect = NSRect(
-            x: indicatorOriginX,
-            y: indicatorOriginY,
-            width: indicatorSize.width,
-            height: indicatorSize.height
-        )
-        Self.drawIndicator(image: indicatorImage, in: indicatorRect)
-
-        if let priorityText = priorityNumberString() {
-            let priorityWidth = Self.measureWidth(of: priorityText, color: foreground)
-            let textOriginX = indicatorOriginX - Self.indicatorSpacing - priorityWidth
-            let textRect = NSRect(
-                x: textOriginX,
-                y: cellFrame.minY,
-                width: priorityWidth,
-                height: cellFrame.height
-            )
-            Self.drawPriorityText(priorityText, in: textRect, color: foreground)
-        }
-    }
-
-    func funnelRect(forBounds rect: NSRect) -> NSRect {
-        guard supportsValueFilter else { return .null }
-        let size = Self.funnelSize
-        return NSRect(
-            x: rect.maxX - Self.indicatorPadding - size.width,
-            y: rect.midY - size.height / 2,
-            width: size.width,
-            height: size.height
-        )
-    }
-
-    override func titleRect(forBounds rect: NSRect) -> NSRect {
-        let inset = min(DataGridMetrics.cellHorizontalInset, rect.width / 2)
-        let availableWidth = max(0, rect.width - inset * 2 - reservedTrailingWidth())
-        return NSRect(
-            x: rect.minX + inset,
-            y: rect.minY,
-            width: availableWidth,
-            height: rect.height
-        )
-    }
-
-    private func reservedTrailingWidth() -> CGFloat {
-        var width: CGFloat = 0
-        if supportsValueFilter {
-            width += Self.funnelSize.width + Self.indicatorSpacing
-        }
-        if let direction = sortDirection {
-            width += Self.indicatorImage(for: direction, color: .secondaryLabelColor)?.size.width
-                ?? Self.defaultIndicatorSize.width
-            if let priorityText = priorityNumberString() {
-                width += Self.measureWidth(of: priorityText, color: .secondaryLabelColor) + Self.indicatorSpacing
-            }
-        }
-        guard width > 0 else { return 0 }
-        return width + Self.indicatorPadding * 2
-    }
-
-    private func funnelColor(active: Bool, emphasized: Bool, scope: ThemeScope) -> NSColor {
-        if emphasized { return scope.resolved[.gridSelectionText] }
-        return active ? .controlAccentColor : .secondaryLabelColor
-    }
-
-    private static func funnelImage(active: Bool, color: NSColor) -> NSImage? {
-        let symbolName = active ? "line.3.horizontal.decrease.circle.fill" : "line.3.horizontal.decrease.circle"
-        let configuration = NSImage.SymbolConfiguration(pointSize: funnelPointSize, weight: .regular)
-            .applying(.init(hierarchicalColor: color))
-        return NSImage(systemSymbolName: symbolName, accessibilityDescription: nil)?
-            .withSymbolConfiguration(configuration)
-    }
-
-    private func titleFont(isSorted: Bool) -> NSFont {
-        let baseFont = font ?? NSFont.systemFont(ofSize: NSFont.smallSystemFontSize)
-        guard isSorted else { return baseFont }
-        return NSFontManager.shared.convert(baseFont, toHaveTrait: .boldFontMask)
-    }
-
-    private func visibleComment(in controlView: NSView?) -> String? {
-        guard let headerView = controlView as? SortableHeaderView else { return nil }
-        return headerView.comment(for: self)
-    }
-
-    func foregroundColor(emphasized: Bool, scope: ThemeScope) -> NSColor {
-        scope.resolved[emphasized ? .gridSelectionText : .gridHeaderText]
-    }
-
-    private func commentColor(emphasized: Bool, scope: ThemeScope) -> NSColor {
-        emphasized ? scope.resolved[.gridSelectionText] : .secondaryLabelColor
-    }
-
-    private func drawTitle(
-        in rect: NSRect,
-        font titleFont: NSFont,
-        color: NSColor,
-        comment: String?,
-        commentColor: NSColor
-    ) {
-        let paragraph = NSMutableParagraphStyle()
-        paragraph.alignment = alignment
-        paragraph.lineBreakMode = .byTruncatingTail
-
-        let titleAttributes: [NSAttributedString.Key: Any] = [
-            .font: titleFont,
-            .foregroundColor: color,
-            .paragraphStyle: paragraph
-        ]
-
-        let title = NSAttributedString(string: stringValue, attributes: titleAttributes)
-        let textHeight = title.size().height
-        guard let comment else {
-            let drawRect = NSRect(
-                x: rect.minX,
-                y: rect.midY - textHeight / 2,
-                width: rect.width,
-                height: textHeight
-            )
-            title.draw(in: drawRect)
-            return
-        }
-
-        let commentAttributes: [NSAttributedString.Key: Any] = [
-            .font: Self.commentFont,
-            .foregroundColor: commentColor,
-            .paragraphStyle: paragraph
-        ]
-        let commentText = NSAttributedString(string: comment, attributes: commentAttributes)
-        let commentHeight = commentText.size().height
-        let stackHeight = textHeight + Self.commentLineSpacing + commentHeight
-        let stackMinY = rect.midY - stackHeight / 2
-
-        let drawRect = NSRect(
-            x: rect.minX,
-            y: stackMinY,
-            width: rect.width,
-            height: textHeight
-        )
-        title.draw(in: drawRect)
-
-        let commentRect = NSRect(
-            x: rect.minX,
-            y: stackMinY + textHeight + Self.commentLineSpacing,
-            width: rect.width,
-            height: commentHeight
-        )
-        commentText.draw(in: commentRect)
-    }
-
-    override func drawSortIndicator(
-        withFrame cellFrame: NSRect,
-        in controlView: NSView,
-        ascending: Bool,
-        priority: Int
-    ) {}
-
-    override func accessibilityLabel() -> String? {
-        var components = [super.accessibilityLabel() ?? stringValue]
-        if let direction = sortDirection {
-            switch direction {
-            case .ascending:
-                components.append(String(localized: "Sorted ascending"))
-            case .descending:
-                components.append(String(localized: "Sorted descending"))
-            }
-            if let sortPriority, sortPriority >= 2 {
-                components.append(String(format: String(localized: "Priority %d"), sortPriority))
-            }
-        }
-        if isValueFiltered {
-            components.append(String(localized: "Filtered"))
-        }
-        return components.joined(separator: ", ")
-    }
-
-    private func priorityNumberString() -> String? {
-        guard let sortPriority, sortPriority >= 2 else { return nil }
-        return String(sortPriority)
-    }
-
-    private static func indicatorImage(for direction: SortDirection, color: NSColor) -> NSImage? {
-        let symbolName = direction == .ascending ? "chevron.up" : "chevron.down"
-        let configuration = NSImage.SymbolConfiguration(pointSize: priorityFontSize, weight: .semibold)
-            .applying(.init(hierarchicalColor: color))
-        return NSImage(systemSymbolName: symbolName, accessibilityDescription: nil)?
-            .withSymbolConfiguration(configuration)
-    }
-
-    private static func drawIndicator(image: NSImage?, in rect: NSRect) {
-        guard let image else { return }
-        image.draw(
-            in: rect,
-            from: .zero,
-            operation: .sourceOver,
-            fraction: 1.0,
-            respectFlipped: true,
-            hints: nil
-        )
-    }
-
-    private static func drawPriorityText(_ text: String, in rect: NSRect, color: NSColor) {
-        let attributes = priorityAttributes(color: color)
-        let textSize = (text as NSString).size(withAttributes: attributes)
-        let drawRect = NSRect(
-            x: rect.minX,
-            y: rect.midY - textSize.height / 2,
-            width: rect.width,
-            height: textSize.height
-        )
-        (text as NSString).draw(in: drawRect, withAttributes: attributes)
-    }
-
-    private static func measureWidth(of text: String, color: NSColor) -> CGFloat {
-        (text as NSString).size(withAttributes: priorityAttributes(color: color)).width
-    }
-
-    private static func priorityAttributes(color: NSColor) -> [NSAttributedString.Key: Any] {
-        [
-            .font: NSFont.systemFont(ofSize: priorityFontSize, weight: .medium),
-            .foregroundColor: color
-        ]
-    }
-}
diff --git a/apple/TablePro/Views/Results/SortableHeaderChrome.swift b/apple/TablePro/Views/Results/SortableHeaderChrome.swift
deleted file mode 100644
index 6eae000b56..0000000000
--- a/apple/TablePro/Views/Results/SortableHeaderChrome.swift
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-//  SortableHeaderChrome.swift
-//  TablePro
-//
-
-import AppKit
-import TableProTheme
-
-@MainActor
-enum SortableHeaderChrome {
-    static let separatorThickness: CGFloat = 1
-    static let columnDividerHeight: CGFloat = 16
-
-    /// The cells never draw a background of their own, so the header lays one down under
-    /// `NSTableHeaderView.draw`; without a theme override it is the table's own background.
-    static func backgroundColor(scope: ThemeScope) -> NSColor {
-        scope.resolved[.gridHeaderBackground]
-    }
-
-    static func lineColor(scope: ThemeScope) -> NSColor {
-        scope.resolved[.gridLine]
-    }
-
-    static func fillBackground(_ rect: NSRect, scope: ThemeScope) {
-        backgroundColor(scope: scope).setFill()
-        rect.fill()
-    }
-
-    static func drawBottomSeparator(in bounds: NSRect, scope: ThemeScope) {
-        lineColor(scope: scope).setFill()
-        NSRect(
-            x: bounds.minX,
-            y: bounds.maxY - separatorThickness,
-            width: bounds.width,
-            height: separatorThickness
-        ).fill()
-    }
-
-    static func drawColumnDivider(in cellFrame: NSRect, scope: ThemeScope) {
-        let dividerHeight = min(columnDividerHeight, cellFrame.height)
-        lineColor(scope: scope).setFill()
-        NSRect(
-            x: cellFrame.maxX - separatorThickness,
-            y: cellFrame.midY - dividerHeight / 2,
-            width: separatorThickness,
-            height: dividerHeight
-        ).fill()
-    }
-}
diff --git a/apple/TablePro/Views/Results/SortableHeaderEmphasis.swift b/apple/TablePro/Views/Results/SortableHeaderEmphasis.swift
deleted file mode 100644
index 232a55188d..0000000000
--- a/apple/TablePro/Views/Results/SortableHeaderEmphasis.swift
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-//  SortableHeaderEmphasis.swift
-//  TablePro
-//
-
-import AppKit
-
-/// `NSTableRowView.isEmphasized` is key window *and* table focus, and the header has to answer the
-/// same question or the two halves of one selection disagree.
-internal enum SortableHeaderEmphasis {
-    internal static func isEmphasized(tableViewHoldsFocus: Bool, isKeyWindow: Bool) -> Bool {
-        tableViewHoldsFocus && isKeyWindow
-    }
-
-    /// A cell being edited or viewed takes focus in a text view the grid mounts in the table's
-    /// scroll view, beside the table rather than inside it, so focus is resolved by ancestry from
-    /// the scroll view rather than by identity with the table.
-    internal static func holdsFocus(tableView: NSTableView?, in window: NSWindow?) -> Bool {
-        guard let tableView, let responder = window?.firstResponder as? NSView else { return false }
-        return responder.isDescendant(of: tableView.enclosingScrollView ?? tableView)
-    }
-}
diff --git a/apple/TablePro/Views/Results/SortableHeaderView.swift b/apple/TablePro/Views/Results/SortableHeaderView.swift
deleted file mode 100644
index 8c12cd26b6..0000000000
--- a/apple/TablePro/Views/Results/SortableHeaderView.swift
+++ /dev/null
@@ -1,877 +0,0 @@
-//
-//  SortableHeaderView.swift
-//  TablePro
-//
-
-import AppKit
-import os
-import TableProTheme
-
-struct HeaderSortTransition: Equatable {
-    let newState: SortState
-}
-
-/// The header click cycle: first direction, its opposite, then the engine's own order.
-///
-/// Every transition it returns is stamped `.user`, including the empty one. The empty state is the
-/// user saying "no order", which is a different thing from a tab that has not decided yet, and only
-/// the stamp keeps `wantsDefaultSort` from writing the app default back over it.
-enum HeaderSortCycle {
-    static func nextTransition(
-        state: SortState,
-        clickedColumn: Int,
-        isMultiSort: Bool,
-        firstClickDirection: SortDirection
-    ) -> HeaderSortTransition {
-        let transition = isMultiSort
-            ? multiSortTransition(state: state, clickedColumn: clickedColumn, firstClickDirection: firstClickDirection)
-            : singleSortTransition(state: state, clickedColumn: clickedColumn, firstClickDirection: firstClickDirection)
-        var stamped = transition.newState
-        stamped.source = .user
-        return HeaderSortTransition(newState: stamped)
-    }
-
-    private static func multiSortTransition(
-        state: SortState,
-        clickedColumn: Int,
-        firstClickDirection: SortDirection
-    ) -> HeaderSortTransition {
-        guard let existingIndex = state.columns.firstIndex(where: { $0.columnIndex == clickedColumn }) else {
-            var newState = state
-            newState.columns.append(SortColumn(columnIndex: clickedColumn, direction: firstClickDirection))
-            return HeaderSortTransition(newState: newState)
-        }
-
-        let existing = state.columns[existingIndex]
-        if existing.direction == firstClickDirection {
-            var newState = state
-            newState.columns[existingIndex].direction = firstClickDirection.opposite
-            return HeaderSortTransition(newState: newState)
-        }
-        var newState = state
-        newState.columns.remove(at: existingIndex)
-        return HeaderSortTransition(newState: newState)
-    }
-
-    private static func singleSortTransition(
-        state: SortState,
-        clickedColumn: Int,
-        firstClickDirection: SortDirection
-    ) -> HeaderSortTransition {
-        guard let primary = state.columns.first, primary.columnIndex == clickedColumn else {
-            var newState = SortState()
-            newState.columns = [SortColumn(columnIndex: clickedColumn, direction: firstClickDirection)]
-            return HeaderSortTransition(newState: newState)
-        }
-
-        if primary.direction == firstClickDirection {
-            var newState = SortState()
-            newState.columns = [SortColumn(columnIndex: clickedColumn, direction: firstClickDirection.opposite)]
-            return HeaderSortTransition(newState: newState)
-        }
-        return HeaderSortTransition(newState: SortState())
-    }
-}
-
-@MainActor
-final class SortableHeaderView: NSTableHeaderView {
-    weak var coordinator: TableViewCoordinator?
-
-    var themeScope: ThemeScope {
-        coordinator?.themeScope ?? .live
-    }
-
-    private static let clickDragThreshold: CGFloat = 4
-    /// AppKit's own divider band, measured on macOS 27: a press from 3pt before a column's trailing
-    /// edge up to, not including, 2pt after it resizes. A wider band showed the resize cursor where
-    /// the press reorders the column instead, and a click there sorted nothing.
-    private static let resizeZone: Range<CGFloat> = -3..<2
-    private static let fallbackHeight: CGFloat = 28
-
-    private var mouseMovedTrackingArea: NSTrackingArea?
-    private var hoveredColumnIndex: Int?
-
-    private let naturalHeight: CGFloat
-    private var commentsByColumn: [NSUserInterfaceItemIdentifier: String] = [:]
-
-    var commentHeaderHeight: CGFloat {
-        naturalHeight + SortableHeaderCell.commentLineHeight
-    }
-
-    var showsComments = false {
-        didSet {
-            guard showsComments != oldValue else { return }
-            applyHeaderHeight()
-        }
-    }
-
-    func updateComments(_ comments: [NSUserInterfaceItemIdentifier: String]) {
-        guard commentsByColumn != comments else { return }
-        commentsByColumn = comments
-        needsDisplay = true
-    }
-
-    func comment(for cell: NSCell) -> String? {
-        guard let tableView,
-              let column = tableView.tableColumns.first(where: { $0.headerCell === cell }) else {
-            return nil
-        }
-        return commentsByColumn[column.identifier]
-    }
-
-    private let emphasisObservers = OSAllocatedUnfairLock<[any NSObjectProtocol]>(uncheckedState: [])
-    private let scrollObserver = OSAllocatedUnfairLock<(any NSObjectProtocol)?>(uncheckedState: nil)
-    private var firstResponderObservation: NSKeyValueObservation?
-    /// Where the pinned row-number heading was last painted, so a scroll can clear it from there.
-    ///
-    /// Recorded by the drawing itself rather than by the scroll, because the heading is also painted
-    /// when nothing scrolled: row numbers turned on, or the column widening for a longer number,
-    /// while the grid is already scrolled sideways.
-    private(set) var drawnPinnedHeadingRect: NSRect?
-    private var bodyFollowsColumnDrag = false
-
-    override init(frame frameRect: NSRect) {
-        naturalHeight = frameRect.height > 0 ? frameRect.height : Self.fallbackHeight
-        super.init(frame: frameRect)
-    }
-
-    deinit {
-        emphasisObservers.withLockUnchecked { $0.forEach(NotificationCenter.default.removeObserver) }
-        scrollObserver.withLockUnchecked { $0.map(NotificationCenter.default.removeObserver) }
-    }
-
-    required init?(coder: NSCoder) {
-        naturalHeight = Self.fallbackHeight
-        super.init(coder: coder)
-    }
-
-    override func viewDidMoveToWindow() {
-        super.viewDidMoveToWindow()
-        emphasisObservers.withLockUnchecked {
-            $0.forEach(NotificationCenter.default.removeObserver)
-            $0.removeAll()
-        }
-        firstResponderObservation = nil
-        guard let window else {
-            applyEmphasis(false)
-            return
-        }
-        for name in [NSWindow.didBecomeKeyNotification, NSWindow.didResignKeyNotification] {
-            let observer = NotificationCenter.default.addObserver(
-                forName: name,
-                object: window,
-                queue: .main
-            ) { [weak self] _ in
-                MainActor.assumeIsolated { self?.refreshEmphasis() }
-            }
-            emphasisObservers.withLockUnchecked { $0.append(observer) }
-        }
-        /// The header and the row bodies are two halves of one selection, so they have to agree on
-        /// what emphasis means. `NSTableRowView.isEmphasized` is key window *and* table focus, and
-        /// keying the header on the window alone left a sorted column accent blue over a grey body.
-        /// AppKit publishes no first-responder notification but does notify KVO by hand.
-        firstResponderObservation = window.observe(\.firstResponder, options: [.initial, .new]) { [weak self] _, _ in
-            MainActor.assumeIsolated { self?.refreshEmphasis() }
-        }
-    }
-
-    /// The header scrolls in a clip view of its own, and the pinned row-number heading is drawn at that
-    /// clip's leading edge, so the clip's bounds are the one signal that always agrees with where the
-    /// heading belongs. The rows' clip view is not: scrolling it alone, measured on macOS 27, leaves
-    /// this one where it was.
-    override func viewDidMoveToSuperview() {
-        super.viewDidMoveToSuperview()
-        scrollObserver.withLockUnchecked { observer in
-            observer.map(NotificationCenter.default.removeObserver)
-            observer = nil
-        }
-        guard let clipView = superview as? NSClipView else { return }
-        clipView.postsBoundsChangedNotifications = true
-        let observer = NotificationCenter.default.addObserver(
-            forName: NSView.boundsDidChangeNotification,
-            object: clipView,
-            queue: .main
-        ) { [weak self] _ in
-            MainActor.assumeIsolated { self?.pinnedHeadingsDidMove() }
-        }
-        scrollObserver.withLockUnchecked { $0 = observer }
-    }
-
-    private func refreshEmphasis() {
-        applyEmphasis(
-            SortableHeaderEmphasis.isEmphasized(
-                tableViewHoldsFocus: SortableHeaderEmphasis.holdsFocus(tableView: tableView, in: window),
-                isKeyWindow: window?.isKeyWindow ?? false
-            )
-        )
-    }
-
-    private func applyEmphasis(_ isEmphasized: Bool) {
-        guard let tableView else { return }
-        var changed = false
-        for column in tableView.tableColumns {
-            guard let cell = column.headerCell as? SortableHeaderCell,
-                  cell.isEmphasized != isEmphasized else { continue }
-            cell.isEmphasized = isEmphasized
-            changed = true
-        }
-        guard changed else { return }
-        needsDisplay = true
-        /// The pinned row gutter paints the row selection itself, from this same rule, and nothing else
-        /// tells it the answer changed: its selected rows kept the accent colour after the grid lost
-        /// focus, beside rows that had already turned grey.
-        coordinator?.repaintRowGutter()
-    }
-
-    private func applyHeaderHeight() {
-        let targetHeight = showsComments ? commentHeaderHeight : naturalHeight
-        if frame.height != targetHeight {
-            setFrameSize(NSSize(width: frame.width, height: targetHeight))
-        }
-        tableView?.enclosingScrollView?.tile()
-        needsDisplay = true
-    }
-
-    /// AppKit redraws the header on every step of a divider or reorder drag, but posts the column
-    /// notifications only at mouse-up, and the body's cells are drawn rather than mounted, so nothing
-    /// else moves them. `viewWillDraw` is where a view may mark others for the same display pass.
-    /// The pass after a drag repaints once more: a reorder released before passing a neighbour
-    /// posts no notification at all.
-    override func viewWillDraw() {
-        super.viewWillDraw()
-        let isDragging = resizedColumn >= 0 || draggedColumn >= 0
-        guard isDragging || bodyFollowsColumnDrag else { return }
-        bodyFollowsColumnDrag = isDragging
-        coordinator?.columnGeometryDidChange()
-    }
-
-    override func draw(_ dirtyRect: NSRect) {
-        let scope = themeScope
-        SortableHeaderChrome.fillBackground(dirtyRect, scope: scope)
-        let band = coordinator?.pinnedBand()
-        let pinnedCells = pinnedHeadingCells(band: band)
-        pinnedCells.forEach { $0.drawsInterior = false }
-        drawHeadings(in: dirtyRect)
-        pinnedCells.forEach { $0.drawsInterior = true }
-        drawOverhang(in: dirtyRect)
-        drawPinnedHeadings(in: dirtyRect, band: band)
-        SortableHeaderChrome.drawBottomSeparator(in: bounds.union(dirtyRect), scope: scope)
-    }
-
-    // Only the pinned pass paints these, so a bounce shows each once; a dragged heading keeps its own.
-    private func pinnedHeadingCells(band: DataGridPinnedBand?) -> [SortableHeaderCell] {
-        guard let tableView else { return [] }
-        var indexes = band?.frozenColumns ?? IndexSet()
-        if draggedColumn >= 0 {
-            indexes.remove(draggedColumn)
-        }
-        if let rowNumberColumnIndex {
-            indexes.insert(rowNumberColumnIndex)
-        }
-        return indexes.compactMap { index in
-            index < tableView.tableColumns.count ? tableView.tableColumns[index].headerCell as? SortableHeaderCell : nil
-        }
-    }
-
-    /// `NSTableHeaderView.draw` paints AppKit's band over the fill before the cells, measured on
-    /// macOS 27, so a themed header draws its cells itself and the default theme keeps `super`.
-    private func drawHeadings(in rect: NSRect) {
-        let scope = themeScope
-        guard scope.resolved.isOverridden(.gridHeaderBackground), let tableView else {
-            super.draw(rect)
-            return
-        }
-        let dragged = draggedColumn
-        let columns = tableView.columnIndexes(in: NSRect(x: rect.minX, y: 0, width: rect.width, height: 1))
-        for index in columns where index != dragged {
-            let heading = headerRect(ofColumn: index)
-            guard heading.width > 0, heading.intersects(rect) else { continue }
-            tableView.tableColumns[index].headerCell.draw(withFrame: heading, in: self)
-        }
-        guard dragged >= 0, dragged < tableView.numberOfColumns else { return }
-        let floating = headerRect(ofColumn: dragged).offsetBy(dx: draggedDistance, dy: 0)
-        guard floating.intersects(rect) else { return }
-        SortableHeaderChrome.fillBackground(floating, scope: scope)
-        tableView.tableColumns[dragged].headerCell.draw(withFrame: floating, in: self)
-    }
-
-    /// Paints the part of the dirty rect outside the header's bounds, which a sideways bounce exposes,
-    /// as blank heading.
-    ///
-    /// AppKit lays its translucent grey over the header's bounds only, so the overhang read as the
-    /// bare fill: in dark mode a darker band beside the headings, measured at 40 against 65. One
-    /// heading drawn with no cell content and repeated across the band matches them, the same move
-    /// the pinned heading makes.
-    private func drawOverhang(in dirtyRect: NSRect) {
-        /// Clamped before the rects are built: `NSRect.width` reports a negative width as positive.
-        let leading = max(0, min(dirtyRect.maxX, bounds.minX) - dirtyRect.minX)
-        let trailingStart = max(dirtyRect.minX, bounds.maxX)
-        let trailing = max(0, dirtyRect.maxX - trailingStart)
-        let bands = [
-            NSRect(x: dirtyRect.minX, y: bounds.minY, width: leading, height: bounds.height),
-            NSRect(x: trailingStart, y: bounds.minY, width: trailing, height: bounds.height)
-        ].filter { $0.width > 0 }
-        guard !bands.isEmpty, let tableView,
-              let index = tableView.tableColumns.indices.first(where: { headerRect(ofColumn: $0).width > 0 }),
-              let cell = tableView.tableColumns[index].headerCell as? SortableHeaderCell,
-              let context = NSGraphicsContext.current?.cgContext else { return }
-        let heading = headerRect(ofColumn: index)
-        let (drewInterior, drewDivider) = (cell.drawsInterior, cell.drawsDivider)
-        cell.drawsInterior = false
-        cell.drawsDivider = false
-        defer {
-            cell.drawsInterior = drewInterior
-            cell.drawsDivider = drewDivider
-        }
-        for band in bands {
-            var originX = band.minX
-            while originX < band.maxX {
-                context.saveGState()
-                band.clip()
-                context.translateBy(x: originX - heading.minX, y: 0)
-                SortableHeaderChrome.fillBackground(heading, scope: themeScope)
-                drawHeadings(in: heading)
-                context.restoreGState()
-                originX += heading.width
-            }
-        }
-    }
-
-    // MARK: - Pinned headings
-
-    /// The row-number heading's own rect held at the visible leading edge, where the pinned row gutter
-    /// below it sits. Nil when row numbers are off.
-    var pinnedRowNumberHeadingRect: NSRect? {
-        guard let index = rowNumberColumnIndex else { return nil }
-        let heading = headerRect(ofColumn: index)
-        guard heading.width > 0 else { return nil }
-        return NSRect(x: visibleRect.minX, y: heading.minY, width: heading.width, height: heading.height)
-    }
-
-    func isInPinnedRowNumberHeading(_ point: NSPoint) -> Bool {
-        pinnedRowNumberHeadingRect?.contains(point) ?? false
-    }
-
-    private var rowNumberColumnIndex: Int? {
-        guard let tableView else { return nil }
-        let index = tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        guard index >= 0, !tableView.tableColumns[index].isHidden else { return nil }
-        return index
-    }
-
-    private func pinnedHeadingRect(band: DataGridPinnedBand?) -> NSRect? {
-        guard let band, band.width > 0 else { return pinnedRowNumberHeadingRect }
-        return NSRect(x: visibleRect.minX, y: bounds.minY, width: band.width, height: bounds.height)
-    }
-
-    // AppKit resolves a point over the band to the column scrolled underneath.
-    func frozenHeadingColumn(at point: NSPoint) -> Int? {
-        guard let band = coordinator?.freezingBand(), !isInPinnedRowNumberHeading(point) else { return nil }
-        let unscrolled = NSPoint(x: point.x - visibleRect.minX, y: point.y)
-        guard unscrolled.x >= 0, unscrolled.x < band.width, bounds.contains(point) else { return nil }
-        let index = column(at: unscrolled)
-        return band.pins(index) ? index : nil
-    }
-
-    func displayedColumn(at point: NSPoint) -> Int {
-        frozenHeadingColumn(at: point) ?? column(at: point)
-    }
-
-    func displayedHeaderRect(ofColumn index: Int) -> NSRect {
-        let heading = headerRect(ofColumn: index)
-        guard coordinator?.freezingBand()?.pins(index) == true else { return heading }
-        return heading.offsetBy(dx: visibleRect.minX, dy: 0)
-    }
-
-    /// Paints the pinned band's headings at the visible leading edge, at every offset.
-    ///
-    /// It is the only pass that paints the "#" and the frozen headings. The headings underneath are
-    /// drawn blank, because a bounce past the leading edge slides them out from under this one, which
-    /// showed them twice.
-    ///
-    /// It is the drawing that paints the headings unscrolled, moved: the band's rect goes through
-    /// this view's own fill and `super.draw`, translated to the leading edge and clipped to it. No
-    /// separate view can stand in for this. On macOS 27 `NSTableHeaderView.draw` lays its own
-    /// translucent grey over the fill, measured at 50 against the fill's 30 in dark mode, and nothing
-    /// else goes through it: the view that pinned this heading before was always darker than the
-    /// headings beside it. The fill replaces pixels rather than blending over them, so the headings
-    /// scrolled underneath are gone from the band rather than showing through it.
-    private func drawPinnedHeadings(in dirtyRect: NSRect, band: DataGridPinnedBand?) {
-        guard let pinned = pinnedHeadingRect(band: band) else {
-            drawnPinnedHeadingRect = nil
-            return
-        }
-        guard pinned.intersects(dirtyRect), let context = NSGraphicsContext.current?.cgContext else { return }
-        let unscrolled = NSRect(x: 0, y: pinned.minY, width: pinned.width, height: pinned.height)
-        context.saveGState()
-        pinned.clip()
-        context.translateBy(x: pinned.minX, y: 0)
-        SortableHeaderChrome.fillBackground(unscrolled, scope: themeScope)
-        drawHeadings(in: unscrolled)
-        if band?.isFreezing == true {
-            SortableHeaderChrome.lineColor(scope: themeScope).setFill()
-            NSRect(
-                x: unscrolled.maxX - DataGridRowGutterView.frozenDividerThickness,
-                y: unscrolled.minY,
-                width: DataGridRowGutterView.frozenDividerThickness,
-                height: unscrolled.height
-            ).fill()
-        }
-        context.restoreGState()
-        drawnPinnedHeadingRect = pinned
-    }
-
-    /// Clears the headings from where they were last painted and asks for them where they now belong.
-    private func pinnedHeadingsDidMove() {
-        if let drawn = drawnPinnedHeadingRect {
-            setNeedsDisplay(drawn)
-        }
-        if let current = pinnedHeadingRect(band: coordinator?.pinnedBand()) {
-            setNeedsDisplay(current)
-        }
-    }
-
-    // A frozen heading invalidated at its home has to repaint where the band shows it.
-    override func setNeedsDisplay(_ invalidRect: NSRect) {
-        super.setNeedsDisplay(invalidRect)
-        let offset = visibleRect.minX
-        guard offset != 0, let band = coordinator?.freezingBand() else { return }
-        let frozen = NSRect(x: 0, y: bounds.minY, width: band.width, height: bounds.height).intersection(invalidRect)
-        guard !frozen.isEmpty else { return }
-        super.setNeedsDisplay(frozen.offsetBy(dx: offset, dy: 0))
-    }
-
-    /// The pinned heading answers for the row-number column, which has no header menu. Left to AppKit
-    /// the click resolves to whichever column is scrolled underneath and offers to sort that.
-    override func menu(for event: NSEvent) -> NSMenu? {
-        guard !isInPinnedRowNumberHeading(convert(event.locationInWindow, from: nil)) else { return nil }
-        return super.menu(for: event)
-    }
-
-    /// The pinned heading has the row-number column's tooltip, which is none. AppKit resolves the tooltip
-    /// of the column under the point, which there is the column scrolled out of sight, and would show its
-    /// name, type and comment over the `#`. An empty string is AppKit's own "no tooltip here". A frozen
-    /// heading has its own column's.
-    override func view(
-        _ view: NSView,
-        stringForToolTip tag: NSView.ToolTipTag,
-        point: NSPoint,
-        userData data: UnsafeMutableRawPointer?
-    ) -> String {
-        guard !isInPinnedRowNumberHeading(point) else { return "" }
-        if let frozen = frozenHeadingColumn(at: point), let tableView {
-            return tableView.tableColumns[frozen].headerToolTip ?? ""
-        }
-        return super.view(view, stringForToolTip: tag, point: point, userData: data)
-    }
-
-    override func updateTrackingAreas() {
-        super.updateTrackingAreas()
-        if let existing = mouseMovedTrackingArea {
-            removeTrackingArea(existing)
-        }
-        let area = NSTrackingArea(
-            rect: bounds,
-            options: [.activeInKeyWindow, .mouseMoved, .mouseEnteredAndExited, .inVisibleRect],
-            owner: self,
-            userInfo: nil
-        )
-        addTrackingArea(area)
-        mouseMovedTrackingArea = area
-    }
-
-    /// `NSCursor.resizeLeftRight` is deprecated in favour of the direction-aware column
-    /// cursor, which the rest of the app already uses.
-    static var columnResizeCursor: NSCursor {
-        if #available(macOS 15.0, *) {
-            return .columnResize
-        }
-        return .resizeLeftRight
-    }
-
-    override func mouseMoved(with event: NSEvent) {
-        guard tableView != nil else {
-            super.mouseMoved(with: event)
-            return
-        }
-        let point = convert(event.locationInWindow, from: nil)
-        if isInResizeZone(point: point) {
-            SortableHeaderView.columnResizeCursor.set()
-            updateFunnelHover(column: nil)
-        } else {
-            NSCursor.arrow.set()
-            updateFunnelHover(column: hoverableColumn(at: point))
-        }
-    }
-
-    override func mouseExited(with event: NSEvent) {
-        super.mouseExited(with: event)
-        updateFunnelHover(column: nil)
-    }
-
-    /// `headerRect(ofColumn:)` gives a hidden column a zero rect, so its trailing edge is x = 0. The
-    /// pool keeps user-hidden columns and the surplus slots of a wider result attached with
-    /// `userResizingMask` set, and each one reports a divider at the header's leading edge.
-    ///
-    /// Nothing under the pinned row-number heading is a resize zone either: the edges scrolled under
-    /// it belong to columns the reader cannot see there.
-    internal func isInResizeZone(point: NSPoint) -> Bool {
-        resizableColumn(at: point) != nil
-    }
-
-    // Over the band only a frozen column's edge resizes, measured where the band shows it.
-    private func resizableColumn(at point: NSPoint) -> Int? {
-        guard let tableView, let coordinator, !isInPinnedRowNumberHeading(point) else { return nil }
-        var probe = point
-        var pinnedBand: DataGridPinnedBand?
-        if let band = coordinator.freezingBand(),
-           point.x - visibleRect.minX >= 0, point.x - visibleRect.minX < band.width {
-            probe.x -= visibleRect.minX
-            pinnedBand = band
-        }
-        return tableView.tableColumns.indices.first { index in
-            let column = tableView.tableColumns[index]
-            guard column.resizingMask.contains(.userResizingMask),
-                  coordinator.presentsColumn(column),
-                  pinnedBand?.pins(index) ?? true else { return false }
-            return Self.resizeZone.contains(probe.x - headerRect(ofColumn: index).maxX)
-        }
-    }
-
-    private func hoverableColumn(at point: NSPoint) -> Int? {
-        guard let tableView, !isInPinnedRowNumberHeading(point) else { return nil }
-        let columnIndex = displayedColumn(at: point)
-        guard columnIndex >= 0, columnIndex < tableView.numberOfColumns else { return nil }
-        guard tableView.tableColumns[columnIndex].identifier != ColumnIdentitySchema.rowNumberIdentifier else { return nil }
-        return columnIndex
-    }
-
-    private func updateFunnelHover(column columnIndex: Int?) {
-        guard hoveredColumnIndex != columnIndex else { return }
-        let previous = hoveredColumnIndex
-        hoveredColumnIndex = columnIndex
-        guard let tableView else { return }
-        for index in [previous, columnIndex].compactMap({ $0 }) {
-            guard index >= 0, index < tableView.tableColumns.count,
-                  let cell = tableView.tableColumns[index].headerCell as? SortableHeaderCell else { continue }
-            let shouldShow = index == columnIndex
-            if cell.isFunnelVisible != shouldShow {
-                cell.isFunnelVisible = shouldShow
-                setNeedsDisplay(headerRect(ofColumn: index))
-            }
-        }
-    }
-
-    func updateValueFilterIndicators(activeColumns: Set<Int>) {
-        guard let tableView, let coordinator else { return }
-        for (columnIndex, column) in tableView.tableColumns.enumerated() {
-            guard let cell = column.headerCell as? SortableHeaderCell,
-                  let dataIndex = coordinator.dataColumnIndex(from: column.identifier) else { continue }
-            let shouldBeFiltered = activeColumns.contains(dataIndex)
-            if cell.isValueFiltered != shouldBeFiltered {
-                cell.isValueFiltered = shouldBeFiltered
-                setNeedsDisplay(headerRect(ofColumn: columnIndex))
-            }
-        }
-    }
-
-    /// The two index sets are display positions, which is the space a selection speaks; a column's
-    /// data index is the slot it occupies in the result and is not what a position names.
-    func updateColumnSelectionIndicators(selectedColumns: IndexSet, dirtyColumns: IndexSet) {
-        guard let tableView = tableView, let coordinator = coordinator else { return }
-        for (columnIndex, column) in tableView.tableColumns.enumerated() {
-            guard let cell = column.headerCell as? SortableHeaderCell,
-                  let dataIndex = coordinator.dataColumnIndex(from: column.identifier),
-                  let position = coordinator.displayPosition(ofDataColumnIndex: dataIndex) else { continue }
-            let shouldBeSelected = selectedColumns.contains(position)
-            if cell.isColumnSelected != shouldBeSelected {
-                cell.isColumnSelected = shouldBeSelected
-                setNeedsDisplay(headerRect(ofColumn: columnIndex))
-            } else if dirtyColumns.contains(position) {
-                setNeedsDisplay(headerRect(ofColumn: columnIndex))
-            }
-        }
-    }
-
-    func applySortState(_ state: SortState, schema: ColumnIdentitySchema) {
-        guard let tableView else { return }
-        applySortDescriptors(state: state, schema: schema, in: tableView)
-        applySortIndicators(state: state, schema: schema, in: tableView)
-    }
-
-    /// Mirrors the whole sort onto `tableView.sortDescriptors`, never just its leading entry.
-    ///
-    /// AppKit maintains this array itself on every unmodified header click, and a plain click on a
-    /// second column *prepends* the new descriptor while keeping the old ones behind it. Comparing
-    /// only `.first` therefore left AppKit's stale secondary in place, so the array claimed a
-    /// two-column sort the app was not running.
-    private func applySortDescriptors(
-        state: SortState,
-        schema: ColumnIdentitySchema,
-        in tableView: NSTableView
-    ) {
-        let descriptors = Self.presentedColumns(of: state, in: schema).map { entry in
-            NSSortDescriptor(key: entry.name, ascending: entry.direction == .ascending)
-        }
-        let current = tableView.sortDescriptors
-        guard current.count != descriptors.count
-            || zip(current, descriptors).contains(where: { $0.key != $1.key || $0.ascending != $1.ascending })
-        else { return }
-        tableView.sortDescriptors = descriptors
-    }
-
-    /// The sorted-column chrome, and the only place the grid tells an assistive client what is sorted.
-    ///
-    /// `tableView.sortDescriptors` reaches no accessibility client (measured: the header cell's
-    /// direction stays `.unknown` through every change to it). `setAccessibilitySortDirection` is the
-    /// attribute VoiceOver actually reads, so it is set here per column and cleared on the rest.
-    private func applySortIndicators(
-        state: SortState,
-        schema: ColumnIdentitySchema,
-        in tableView: NSTableView
-    ) {
-        var priorityByIdentifier: [NSUserInterfaceItemIdentifier: (direction: SortDirection, priority: Int)] = [:]
-        for (priority, entry) in Self.presentedColumns(of: state, in: schema).enumerated() {
-            guard let identifier = schema.identifier(for: entry.dataIndex) else { continue }
-            priorityByIdentifier[identifier] = (entry.direction, priority + 1)
-        }
-        let isDefaultSort = state.source == .defaultSort
-
-        for (columnIndex, column) in tableView.tableColumns.enumerated() {
-            guard let cell = column.headerCell as? SortableHeaderCell else { continue }
-            let entry = priorityByIdentifier[column.identifier]
-            let newDirection = entry?.direction
-            let newPriority = isDefaultSort ? nil : entry?.priority
-            let newIsDefault = entry != nil && isDefaultSort
-            cell.setAccessibilitySortDirection(Self.accessibilitySortDirection(for: newDirection))
-            if cell.sortDirection != newDirection
-                || cell.sortPriority != newPriority
-                || cell.isDefaultSort != newIsDefault {
-                cell.sortDirection = newDirection
-                cell.sortPriority = newPriority
-                cell.isDefaultSort = newIsDefault
-                setNeedsDisplay(headerRect(ofColumn: columnIndex))
-            }
-        }
-    }
-
-    /// The sort entries the current result actually carries a column for, resolved by name.
-    ///
-    /// A sort keeps its entry when its column leaves the result, so that re-running a query that
-    /// brings the column back restores the order. Its `columnIndex` is stale while it is away, and
-    /// painting from that index put the chevron and the sort descriptor on whichever column had
-    /// moved into the slot: `SELECT id, name, email` sorted on `email`, re-run as
-    /// `SELECT id, name, phone`, marked `phone` as sorted over rows `phone` never ordered.
-    private static func presentedColumns(
-        of state: SortState,
-        in schema: ColumnIdentitySchema
-    ) -> [(name: String, dataIndex: Int, direction: SortDirection)] {
-        state.columns.compactMap { sortColumn in
-            guard let name = SortColumnResolver.columnName(for: sortColumn, displayColumns: schema.columnNames) else {
-                return nil
-            }
-            /// The slot the entry already names wins whenever it still carries that name, because
-            /// `dataIndex(forColumnName:)` answers a duplicate name with its last occurrence and
-            /// `SELECT a.id, b.id` would otherwise mark and order the wrong one.
-            if schema.columnName(for: sortColumn.columnIndex) == name {
-                return (name, sortColumn.columnIndex, sortColumn.direction)
-            }
-            guard let dataIndex = schema.dataIndex(forColumnName: name) else { return nil }
-            return (name, dataIndex, sortColumn.direction)
-        }
-    }
-
-    private static func presentedState(of state: SortState, in schema: ColumnIdentitySchema) -> SortState {
-        SortState(
-            columns: presentedColumns(of: state, in: schema).map {
-                SortColumn(columnIndex: $0.dataIndex, direction: $0.direction, columnName: $0.name)
-            },
-            source: state.source
-        )
-    }
-
-    private static func accessibilitySortDirection(for direction: SortDirection?) -> NSAccessibilitySortDirection {
-        switch direction {
-        case .ascending: return .ascending
-        case .descending: return .descending
-        case nil: return .unknown
-        }
-    }
-
-    /// Did the gesture `super.mouseDown` just consumed end as a click, or as a drag the user aborted?
-    ///
-    /// A `mouseDragged` override cannot answer this: `NSTableHeaderView.mouseDown` runs its own
-    /// modal tracking loop and dequeues the drags itself, so the override is never called (measured,
-    /// zero calls, including on a real reorder). An aborted drag also leaves column order and widths
-    /// untouched, so those two comparisons cannot answer it either.
-    ///
-    /// On an unmodified click AppKit has already decided, because every data column carries a
-    /// `sortDescriptorPrototype`: it rewrites `sortDescriptors` for a click and leaves them alone
-    /// for a drag. Under a modifier AppKit does nothing at all (measured), so there is no signal to
-    /// borrow and the distance between the press and the release is what is left.
-    private static func gestureWasClick(
-        modifierFlags: NSEvent.ModifierFlags,
-        downLocationInWindow: NSPoint,
-        descriptorsBeforeClick: [NSSortDescriptor],
-        descriptorsAfterClick: [NSSortDescriptor]
-    ) -> Bool {
-        guard modifierFlags.isEmpty else {
-            return releaseWasInPlace(downLocationInWindow: downLocationInWindow)
-        }
-        return descriptorsAfterClick != descriptorsBeforeClick
-    }
-
-    /// The release AppKit's tracking loop consumed. `NSApp.currentEvent` is that `leftMouseUp` by the
-    /// time `super.mouseDown` returns, measured, so the press-to-release distance is available even
-    /// though no `mouseDragged` was ever dispatched.
-    private static func releaseWasInPlace(downLocationInWindow: NSPoint) -> Bool {
-        guard let release = NSApp.currentEvent, release.type == .leftMouseUp else { return true }
-        let up = release.locationInWindow
-        return abs(up.x - downLocationInWindow.x) <= clickDragThreshold
-            && abs(up.y - downLocationInWindow.y) <= clickDragThreshold
-    }
-
-    override func mouseDown(with event: NSEvent) {
-        guard let tableView = tableView,
-              let coordinator = coordinator else {
-            super.mouseDown(with: event)
-            return
-        }
-
-        let pointInHeader = convert(event.locationInWindow, from: nil)
-        /// A press on the pinned heading is a press on the row-number heading, which sorts, reorders
-        /// and resizes nothing. Handed to AppKit it would track the column scrolled underneath.
-        guard !isInPinnedRowNumberHeading(pointInHeader) else { return }
-        if visibleRect.minX != 0, let frozen = frozenHeadingColumn(at: pointInHeader) {
-            pressFrozenHeading(frozen, at: pointInHeader, event: event)
-            return
-        }
-        if isInResizeZone(point: pointInHeader) {
-            super.mouseDown(with: event)
-            return
-        }
-
-        let columnIndex = column(at: pointInHeader)
-        guard columnIndex >= 0, columnIndex < tableView.numberOfColumns else {
-            super.mouseDown(with: event)
-            return
-        }
-
-        let column = tableView.tableColumns[columnIndex]
-        guard column.identifier != ColumnIdentitySchema.rowNumberIdentifier,
-              let dataIndex = coordinator.dataColumnIndex(from: column.identifier) else {
-            super.mouseDown(with: event)
-            return
-        }
-
-        let modifierFlags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-        if modifierFlags.isEmpty,
-           let cell = column.headerCell as? SortableHeaderCell {
-            let funnelRect = cell.funnelRect(forBounds: headerRect(ofColumn: columnIndex))
-            if funnelRect.insetBy(dx: -2, dy: -4).contains(pointInHeader) {
-                coordinator.presentValueFilterPopover(forColumn: dataIndex, anchor: funnelRect, in: self)
-                return
-            }
-        }
-
-        let originalColumnOrder = tableView.tableColumns.map { $0.identifier }
-        let originalColumnWidths = tableView.tableColumns.map { $0.width }
-        let descriptorsBeforeClick = tableView.sortDescriptors
-
-        super.mouseDown(with: event)
-
-        let columnOrderChanged = tableView.tableColumns.map { $0.identifier } != originalColumnOrder
-        let columnWidthsChanged = tableView.tableColumns.map { $0.width } != originalColumnWidths
-        if columnOrderChanged || columnWidthsChanged {
-            return
-        }
-        guard Self.gestureWasClick(
-            modifierFlags: modifierFlags,
-            downLocationInWindow: event.locationInWindow,
-            descriptorsBeforeClick: descriptorsBeforeClick,
-            descriptorsAfterClick: tableView.sortDescriptors
-        ) else { return }
-
-        performHeadingClick(dataIndex: dataIndex, modifierFlags: modifierFlags)
-    }
-
-    // AppKit would track the column scrolled underneath, so the band tracks its own; no drag reorders.
-    private func pressFrozenHeading(_ columnIndex: Int, at point: NSPoint, event: NSEvent) {
-        guard let tableView, let coordinator else { return }
-        if let resizing = resizableColumn(at: point) {
-            trackFrozenResize(columnIndex: resizing, event: event)
-            return
-        }
-        let column = tableView.tableColumns[columnIndex]
-        guard let dataIndex = coordinator.dataColumnIndex(from: column.identifier) else { return }
-        let modifierFlags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-        let heading = headerRect(ofColumn: columnIndex)
-        if modifierFlags.isEmpty, let cell = column.headerCell as? SortableHeaderCell {
-            let funnelRect = cell.funnelRect(forBounds: heading).offsetBy(dx: visibleRect.minX, dy: 0)
-            if funnelRect.insetBy(dx: -2, dy: -4).contains(point) {
-                coordinator.presentValueFilterPopover(forColumn: dataIndex, anchor: funnelRect, in: self)
-                return
-            }
-        }
-        guard trackClick(from: event) else { return }
-        performHeadingClick(dataIndex: dataIndex, modifierFlags: modifierFlags)
-    }
-
-    private func trackClick(from event: NSEvent) -> Bool {
-        guard let window else { return false }
-        while let next = window.nextEvent(matching: [.leftMouseDragged, .leftMouseUp]) {
-            guard next.type == .leftMouseUp else { continue }
-            return abs(next.locationInWindow.x - event.locationInWindow.x) <= Self.clickDragThreshold
-                && abs(next.locationInWindow.y - event.locationInWindow.y) <= Self.clickDragThreshold
-        }
-        return false
-    }
-
-    private func trackFrozenResize(columnIndex: Int, event: NSEvent) {
-        guard let tableView, let coordinator, let window else { return }
-        let column = tableView.tableColumns[columnIndex]
-        if event.clickCount == 2 {
-            column.width = coordinator.tableView(tableView, sizeToFitWidthOfColumn: columnIndex)
-            return
-        }
-        let startWidth = column.width
-        Self.columnResizeCursor.set()
-        while let next = window.nextEvent(matching: [.leftMouseDragged, .leftMouseUp]) {
-            let width = min(max(startWidth + next.locationInWindow.x - event.locationInWindow.x, column.minWidth), column.maxWidth)
-            if column.width != width {
-                column.width = width
-                needsDisplay = true
-            }
-            if next.type == .leftMouseUp { return }
-        }
-    }
-
-    private func performHeadingClick(dataIndex: Int, modifierFlags: NSEvent.ModifierFlags) {
-        guard let coordinator else { return }
-        let isMultiSort = modifierFlags.contains(.shift)
-        if modifierFlags.contains(.command) && !modifierFlags.contains(.shift) {
-            coordinator.extendColumnSelection(dataIndex)
-            return
-        }
-        guard coordinator.supportsColumnSort else { return }
-
-        let schema = coordinator.identitySchema
-        /// The cycle runs over the sort the current result can actually show. An entry whose column
-        /// left the result keeps its slot in the model so that bringing the column back restores its
-        /// order, but feeding that latent slot to the cycle made a click on the unsorted column now
-        /// sitting there advance the vanished column's cycle instead of starting a new one.
-        let transition = HeaderSortCycle.nextTransition(
-            state: Self.presentedState(of: coordinator.currentSortState, in: schema),
-            clickedColumn: dataIndex,
-            isMultiSort: isMultiSort,
-            firstClickDirection: coordinator.firstClickSortDirection
-        )
-        let newState = SortColumnResolver.stamped(transition.newState, displayColumns: schema.columnNames)
-
-        /// Announced, not painted. The header is drawn from whatever the model ends up holding, via
-        /// `DataGridView.syncSortState`. Painting here first meant a click the model then refused,
-        /// which "Discard Unsaved Changes?" does on Cancel, left the chevron and the click cycle
-        /// describing a sort that never ran.
-        coordinator.delegate?.dataGridSortStateChanged(newState)
-    }
-}
diff --git a/apple/TablePro/Views/Results/TableSelection.swift b/apple/TablePro/Views/Results/TableSelection.swift
deleted file mode 100644
index 545dccd8cf..0000000000
--- a/apple/TablePro/Views/Results/TableSelection.swift
+++ /dev/null
@@ -1,23 +0,0 @@
-import Foundation
-
-struct TableSelection: Equatable {
-    var focusedRow: Int = -1
-    var focusedColumn: Int = -1
-
-    func reloadIndexes(from previous: TableSelection) -> (rows: IndexSet, columns: IndexSet)? {
-        guard previous.focusedRow != focusedRow || previous.focusedColumn != focusedColumn else {
-            return nil
-        }
-
-        var rows = IndexSet()
-        var columns = IndexSet()
-
-        if previous.focusedRow >= 0 { rows.insert(previous.focusedRow) }
-        if previous.focusedColumn >= 0 { columns.insert(previous.focusedColumn) }
-        if focusedRow >= 0 { rows.insert(focusedRow) }
-        if focusedColumn >= 0 { columns.insert(focusedColumn) }
-
-        guard !rows.isEmpty, !columns.isEmpty else { return nil }
-        return (rows, columns)
-    }
-}
diff --git a/apple/TablePro/Views/ServerDashboard/DashboardTileView.swift b/apple/TablePro/Views/ServerDashboard/DashboardTileView.swift
index f1124a0b53..540a3af189 100644
--- a/apple/TablePro/Views/ServerDashboard/DashboardTileView.swift
+++ b/apple/TablePro/Views/ServerDashboard/DashboardTileView.swift
@@ -1,8 +1,3 @@
-//
-//  DashboardTileView.swift
-//  TablePro
-//
-
 import SwiftUI
 import TableProTheme
 
@@ -51,7 +46,7 @@ struct DashboardTileView: View {
         .accessibilityIdentifier("server-dashboard-tile")
     }
 
-    /// The drag handle is the title row alone: a drag on a chart moves its selection, not the tile.
+    // The drag handle is the title row alone: a drag on a chart moves its selection, not the tile.
     private var header: some View {
         HStack(spacing: 6) {
             Text(title)
@@ -201,7 +196,7 @@ private struct DashboardTileContentView: View {
                             ForEach(Array(table.columns.enumerated()), id: \.offset) { _, column in
                                 Text(verbatim: column)
                                     .fontWeight(.semibold)
-                                    .themeForeground(.gridHeaderText, native: HierarchicalShapeStyle.secondary)
+                                    .themeForeground(.gridText, native: HierarchicalShapeStyle.secondary)
                             }
                         }
                         ForEach(Array(table.rows.enumerated()), id: \.offset) { _, row in
diff --git a/apple/TablePro/Views/ServerDashboard/SessionsTableView.swift b/apple/TablePro/Views/ServerDashboard/SessionsTableView.swift
index bdb789cb09..f054023658 100644
--- a/apple/TablePro/Views/ServerDashboard/SessionsTableView.swift
+++ b/apple/TablePro/Views/ServerDashboard/SessionsTableView.swift
@@ -1,7 +1,5 @@
 import SwiftUI
 
-/// Sessions are server records, so they draw in the data grid and take its theme. The grid has no
-/// per-row buttons, so Cancel and Terminate act on the selected session from the header.
 internal struct SessionsTableView: View {
     @ObservedObject internal var viewModel: ServerDashboardViewModel
     @ObservedObject private var selection: StructureListSelection<String>
@@ -9,7 +7,6 @@ internal struct SessionsTableView: View {
         accessibilityLabel: String(localized: "Active Sessions")
     )
     @State private var sortState = SessionGridColumns.defaultSort
-    @State private var columnLayout = ColumnLayoutState()
 
     internal init(viewModel: ServerDashboardViewModel) {
         _viewModel = ObservedObject(wrappedValue: viewModel)
@@ -86,20 +83,16 @@ internal struct SessionsTableView: View {
     private var table: some View {
         let rows = SessionGridColumns.sorted(viewModel.sessions, by: sortState).map(SessionGridColumns.row(for:))
         let selection = selection
-        var hasher = Hasher()
-        hasher.combine(rows)
         return StructureListGrid(
             model: grid,
             columns: SessionGridColumns.titles,
             defaultWidths: SessionGridColumns.widths,
             minimumWidths: SessionGridColumns.minimumWidths,
-            contentKey: hasher.finalize(),
-            rows: { rows },
+            rows: rows,
             databaseType: viewModel.databaseType,
-            selectedIDs: { selection.ids },
+            selectedIDs: selection.ids,
             select: { selection.ids = $0 },
-            sortState: $sortState,
-            columnLayout: $columnLayout
+            sortState: $sortState
         )
     }
 }
diff --git a/apple/TablePro/Views/ServerDashboard/SlowQueryListView.swift b/apple/TablePro/Views/ServerDashboard/SlowQueryListView.swift
index c5e2b850e5..eb9f91a1fd 100644
--- a/apple/TablePro/Views/ServerDashboard/SlowQueryListView.swift
+++ b/apple/TablePro/Views/ServerDashboard/SlowQueryListView.swift
@@ -1,7 +1,5 @@
 import SwiftUI
 
-/// Slow queries are server records, so they draw in the data grid and take its theme. The server's
-/// order, slowest first, is kept: the drawn duration is a formatted span that would not sort.
 internal struct SlowQueryListView: View {
     internal let queries: [DashboardSlowQuery]
     internal let error: String?
@@ -11,7 +9,6 @@ internal struct SlowQueryListView: View {
         accessibilityLabel: String(localized: "Slow Queries")
     )
     @StateObject private var selection = StructureListSelection<SlowQueryGridRows.RowID>()
-    @State private var columnLayout = ColumnLayoutState()
 
     internal var body: some View {
         VStack(alignment: .leading, spacing: 0) {
@@ -47,22 +44,17 @@ internal struct SlowQueryListView: View {
     }
 
     private var table: some View {
-        let rows = SlowQueryGridRows.rows(for: queries)
         let selection = selection
-        var hasher = Hasher()
-        hasher.combine(rows)
         return StructureListGrid(
             model: grid,
             columns: SlowQueryGridRows.titles,
             defaultWidths: SlowQueryGridRows.widths,
             minimumWidths: SlowQueryGridRows.minimumWidths,
-            contentKey: hasher.finalize(),
-            rows: { rows },
+            rows: SlowQueryGridRows.rows(for: queries),
             databaseType: databaseType,
-            selectedIDs: { selection.ids },
+            selectedIDs: selection.ids,
             select: { selection.ids = $0 },
-            sortState: nil,
-            columnLayout: $columnLayout
+            sortState: nil
         )
     }
 }
diff --git a/apple/TablePro/Views/Settings/Appearance/ThemeEditorPreview.swift b/apple/TablePro/Views/Settings/Appearance/ThemeEditorPreview.swift
index e151fff60b..6ec1478d9c 100644
--- a/apple/TablePro/Views/Settings/Appearance/ThemeEditorPreview.swift
+++ b/apple/TablePro/Views/Settings/Appearance/ThemeEditorPreview.swift
@@ -33,8 +33,7 @@ internal struct ThemeEditorPreview: View {
     }
 }
 
-/// A view inside the preview, which never takes clicks or keyboard focus: a focused preview editor
-/// would answer Undo with its own empty history instead of the window's.
+// Never takes clicks or keyboard focus: a focused preview would answer Undo with its own empty history.
 internal protocol ThemePreviewSurface: AnyObject {}
 
 internal extension NSView {
@@ -54,8 +53,6 @@ private final class ThemePreviewHostingView<Content: View>: NSHostingView<Conten
     }
 }
 
-/// Draws its content in the theme's appearance whatever the window's is, so a dark theme previews as
-/// dark from a light Mac.
 private struct ThemePreviewAppearanceHost<Content: View>: NSViewRepresentable {
     let appearance: ThemeAppearance
     @ViewBuilder let content: () -> Content
@@ -75,7 +72,6 @@ private struct ThemePreviewAppearanceHost<Content: View>: NSViewRepresentable {
         }
     }
 
-    /// Increase Contrast is a system setting AppKit applies to these by itself.
     private static func drawingAppearance(for appearance: ThemeAppearance) -> NSAppearance? {
         NSAppearance(named: appearance == .dark ? .darkAqua : .aqua)
     }
@@ -97,14 +93,12 @@ internal enum ThemePreviewSample {
 
     private static var text: NSString { sql as NSString }
 
-    /// The first statement, as the editor bands the statement under the caret.
     internal static var statementRange: NSRange {
         let start = text.range(of: "SELECT").location
         let end = text.range(of: ";").location
         return NSRange(location: start, length: end + 1 - start)
     }
 
-    /// A caret on one line for the current-line band and a selection on another.
     internal static var cursorPositions: [CursorPosition] {
         let caretLine = text.range(of: "FROM orders")
         let selection = text.range(of: "'paid'")
@@ -155,7 +149,6 @@ private struct ThemePreviewEditor: View {
     }
 }
 
-/// The statement band is a decoration the host sets, so a read-only listing gets it from here.
 @MainActor
 private final class ThemePreviewStatementBand: TextViewCoordinator {
     func prepareCoordinator(controller: TextViewController) {
@@ -169,8 +162,8 @@ private final class ThemePreviewStatementBand: TextViewCoordinator {
 
 // MARK: - Grid
 
-/// Five rows that put every grid slot on screen: header and row numbers, both stripes, NULL, both
-/// booleans, an unfocused selection, and a modified, a deleted and an inserted row.
+// Five rows that put every grid slot on screen: row numbers, both stripes, NULL, both booleans, an
+// unfocused selection, and a modified, a deleted and an inserted row.
 internal enum ThemePreviewGridSample {
     internal static let selectedRow = 1
     internal static let modifiedRow = 2
@@ -205,6 +198,15 @@ internal enum ThemePreviewGridSample {
         )
     }()
 
+    // A preview: nothing to sort, filter or edit.
+    internal static var configuration: DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.showRowNumbers = true
+        configuration.supportsValueFilter = false
+        configuration.supportsColumnSort = false
+        return configuration
+    }
+
     internal static func visualState(forRow row: Int) -> RowVisualState? {
         switch row {
         case modifiedRow:
@@ -219,38 +221,39 @@ internal enum ThemePreviewGridSample {
     }
 }
 
-@MainActor
-private final class ThemePreviewGridDelegate: DataGridViewDelegate {
-    func dataGridVisualState(forRow row: Int) -> RowVisualState? {
-        ThemePreviewGridSample.visualState(forRow: row)
-    }
-}
-
 private struct ThemePreviewGrid: View {
     let scope: ThemeScope
 
-    @State private var changeManager = AnyChangeManager(DataChangeManager())
-    @State private var delegate = ThemePreviewGridDelegate()
-    @State private var selectedRows: Set<Int> = [ThemePreviewGridSample.selectedRow]
-    @State private var sortState = SortState()
-    @State private var columnLayout = ColumnLayoutState()
+    @StateObject private var grid: HeldRowsGridAdapter
 
-    var body: some View {
-        DataGridView(
-            tableRowsProvider: { ThemePreviewGridSample.tableRows },
-            changeManager: changeManager,
-            isEditable: false,
-            configuration: DataGridConfiguration(
-                showRowNumbers: true,
-                supportsColumnCommands: false,
-                supportsValueFilter: false,
-                supportsColumnSort: false
-            ),
-            delegate: delegate,
-            selectedRowIndices: $selectedRows,
-            sortState: $sortState,
-            columnLayout: $columnLayout,
+    init(scope: ThemeScope) {
+        self.scope = scope
+        _grid = StateObject(wrappedValue: HeldRowsGridAdapter(
+            configuration: ThemePreviewGridSample.configuration,
             themeScope: scope
-        )
+        ))
+    }
+
+    // task(id:) runs with this body's scope; onChange(of:) would hand the grid the previous one (measured).
+    var body: some View {
+        DataGridView(model: grid.model)
+            .task(id: ObjectIdentifier(scope)) { load() }
+    }
+
+    private func load() {
+        if grid.model.themeScope !== scope {
+            grid.model.themeScope = scope
+        }
+        guard grid.heldRows.rows.isEmpty else { return }
+        let rows = ThemePreviewGridSample.tableRows
+        var states: [RowID: RowVisualState] = [:]
+        for (index, row) in rows.rows.enumerated() {
+            states[row.id] = ThemePreviewGridSample.visualState(forRow: index)
+        }
+        grid.visualStates = states
+        grid.setRows(rows)
+        if rows.rows.indices.contains(ThemePreviewGridSample.selectedRow) {
+            grid.model.selectRows([rows.rows[ThemePreviewGridSample.selectedRow].id])
+        }
     }
 }
diff --git a/apple/TablePro/Views/Settings/Appearance/ThemeSlotPresentation.swift b/apple/TablePro/Views/Settings/Appearance/ThemeSlotPresentation.swift
index 5cd35554e5..42a46d3dc2 100644
--- a/apple/TablePro/Views/Settings/Appearance/ThemeSlotPresentation.swift
+++ b/apple/TablePro/Views/Settings/Appearance/ThemeSlotPresentation.swift
@@ -1,9 +1,7 @@
 import AppKit
 import TableProTheme
 
-/// What one slot row says about the theme: the color the well shows, a line naming where that color
-/// comes from, and what a reset would return to. Text, not color alone, tells a set slot from one
-/// that follows the system.
+// Text, not color alone, tells a set slot from one that follows the system.
 internal struct ThemeSlotPresentation: Equatable {
     internal let slot: ThemeSlot
     internal let hasExplicitColor: Bool
@@ -23,8 +21,7 @@ internal struct ThemeSlotPresentation: Equatable {
             : String(format: String(localized: "Use Default Color for %@"), slot.accessibilityLabel)
     }
 
-    /// An unset slot shows the system color resolved in the theme's own appearance, not the one the
-    /// editor window happens to be in.
+    // An unset slot shows the system color in the theme's own appearance, not the editor window's.
     internal static func displayColor(for slot: ThemeSlot, in theme: ThemeDefinition) -> ThemeColor {
         switch theme.value(for: slot) {
         case let .themed(color):
@@ -82,7 +79,6 @@ internal struct ThemeSlotPresentation: Equatable {
     }
 }
 
-/// Text on its background, for the note under a section whose pair reads below the HIG's 4.5:1.
 internal enum ThemeContrastNote {
     internal static let minimumRatio = 4.5
 
@@ -90,7 +86,7 @@ internal enum ThemeContrastNote {
         switch section {
         case .editor: return (.editorText, .editorBackground)
         case .dataGrid: return (.gridText, .gridBackground)
-        case .window, .syntax, .selection, .changes: return nil
+        case .window, .syntax, .changes: return nil
         }
     }
 
@@ -109,13 +105,11 @@ internal enum ThemeContrastNote {
 }
 
 private extension ThemeSlot {
-    /// The slot an unset one takes its color from, when that is a theme color.
     var fallbackSource: ThemeSlot? {
         switch fallback {
         case .system, .defaultSyntax: return nil
         case let .slot(source): return source
         case let .derived(base, _): return base
-        case let .paired(_, fallback): return fallback
         }
     }
 }
diff --git a/apple/TablePro/Views/Structure/ClickHousePartsView.swift b/apple/TablePro/Views/Structure/ClickHousePartsView.swift
index f60f93a11e..0e9e2e5f2e 100644
--- a/apple/TablePro/Views/Structure/ClickHousePartsView.swift
+++ b/apple/TablePro/Views/Structure/ClickHousePartsView.swift
@@ -13,9 +13,6 @@ struct ClickHousePartsView: View {
 
     let tableName: String
 
-    /// The tab's own scope, not the connection alone. ClickHouse switches database by writing one
-    /// field on the shared driver and nothing puts it back, so a statement built from that driver
-    /// names whichever database the sidebar last reached rather than the table on screen.
     let scope: DatabaseScope
     let connection: DatabaseConnection
     let reloadToken: Int
@@ -23,7 +20,6 @@ struct ClickHousePartsView: View {
     @State private var parts: [ClickHousePartInfo] = []
     @State private var isLoading = true
     @State private var errorMessage: String?
-    @State private var columnLayout = ColumnLayoutState()
     @State private var loadedToken: Int?
     @StateObject private var grid = StructureListGridModel<UUID>(accessibilityLabel: StructureTab.parts.displayName)
     @StateObject private var selection = StructureListSelection<UUID>()
@@ -90,24 +86,17 @@ struct ClickHousePartsView: View {
     }
 
     private var partsTable: some View {
-        let parts = parts
         let selection = selection
-        var hasher = Hasher()
-        for part in parts {
-            hasher.combine(part.id)
-        }
         return StructureListGrid(
             model: grid,
             columns: Self.columnTitles,
             defaultWidths: Self.columnWidths,
             minimumWidths: Self.columnMinimumWidths,
-            contentKey: hasher.finalize(),
-            rows: { parts.map(Self.gridRow(for:)) },
+            rows: parts.map(Self.gridRow(for:)),
             databaseType: connection.type,
-            selectedIDs: { selection.ids },
+            selectedIDs: selection.ids,
             select: { selection.ids = $0 },
-            sortState: nil,
-            columnLayout: $columnLayout
+            sortState: nil
         )
     }
 
@@ -212,12 +201,6 @@ struct ClickHousePartsView: View {
         }
     }
 
-    /// Every statement here names the tab's own database and runs on a driver leased to it, and goes
-    /// through the gate first: a partition drop is data loss, and a connection set to confirm those
-    /// was dropping one on the strength of this view's own alert alone.
-    /// Answers whether the statement actually ran. A denial, a cancelled confirmation or a failure
-    /// leaves the partition where it was, so the caller keeps the user's selection rather than
-    /// clearing it as though the action had gone through.
     @MainActor
     @discardableResult
     private func run(_ sql: String, description: String, kind: OperationKind) async -> Bool {
@@ -273,14 +256,11 @@ struct ClickHousePartsView: View {
 
     // MARK: - Data Loading
 
-    /// A connection switch re-parents the pane and SwiftUI re-runs `task(id:)` with the same token,
-    /// so only a new token, which Refresh issues, fetches the parts again.
     private func loadPartsIfNeeded() async {
         guard loadedToken != reloadToken else { return }
         await loadParts()
     }
 
-    /// A cancelled load commits nothing and records no token, so the next appearance retries it.
     private func loadParts() async {
         let token = reloadToken
         isLoading = true
diff --git a/apple/TablePro/Views/Structure/CreateTableDraft.swift b/apple/TablePro/Views/Structure/CreateTableDraft.swift
index 7bde2e373b..f13d0189b7 100644
--- a/apple/TablePro/Views/Structure/CreateTableDraft.swift
+++ b/apple/TablePro/Views/Structure/CreateTableDraft.swift
@@ -16,17 +16,10 @@ internal struct CreateTableCompositionKey: Hashable {
     let foreignKeys: [EditableForeignKeyDefinition]
 }
 
-/// A table definition in progress, held outside the view that edits it.
-///
-/// A Create Table tab's whole content is unsaved by definition: nothing exists on the server until
-/// the user presses Create. `MainEditorContentView` builds only the selected tab, so leaving the
-/// definition in the view's `@State` meant switching to any other tab and back threw away the table
-/// name, the options and every column the user had defined, with no prompt and nothing in Undo.
 @MainActor
 internal final class CreateTableDraft: ObservableObject {
     internal let changeManager = StructureChangeManager()
 
-    /// A new name answers whatever the driver said about the last one, so its error goes with it.
     @Published internal var tableName = "" {
         didSet {
             guard tableName != oldValue else { return }
@@ -46,6 +39,9 @@ internal final class CreateTableDraft: ObservableObject {
     @Published internal private(set) var composed: CreateTableStatements?
     @Published internal private(set) var compositionFailure: String?
 
+    // Made on the first mount, which knows the connection; held here so the grid outlives the view.
+    internal private(set) var gridAdapter: CreateTableGridAdapter?
+
     private var composedKey: CreateTableCompositionKey?
     private var compositionGeneration = 0
     private var changeManagerForwarding: AnyCancellable?
@@ -55,8 +51,6 @@ internal final class CreateTableDraft: ObservableObject {
             .sink { [weak self] in self?.objectWillChange.send() }
     }
 
-    /// A tab that has only just opened holds no work: the editor seeds one blank column so the grid
-    /// has a row to show, which registers as a pending change without the user having typed anything.
     internal var holdsWork: Bool {
         !tableName.isEmpty
             || ObjectCommentDraft.normalized(tableOptions.comment) != nil
@@ -68,6 +62,13 @@ internal final class CreateTableDraft: ObservableObject {
             }
     }
 
+    internal func gridAdapter(for connection: DatabaseConnection) -> CreateTableGridAdapter {
+        if let gridAdapter { return gridAdapter }
+        let adapter = CreateTableGridAdapter(structureChangeManager: changeManager, connection: connection)
+        gridAdapter = adapter
+        return adapter
+    }
+
     internal static func offersEngineOptions(for databaseType: DatabaseType) -> Bool {
         databaseType == .mysql || databaseType == .mariadb
     }
@@ -119,3 +120,11 @@ internal final class CreateTableDraft: ObservableObject {
         }
     }
 }
+
+extension CreateTableDraft: ActiveGridModelProviding {
+    // The definition grid, unless the driver supplied a form of its own.
+    var activeGridModel: DataGridModel? {
+        guard hasResolvedForm, form == nil else { return nil }
+        return gridAdapter?.model
+    }
+}
diff --git a/apple/TablePro/Views/Structure/CreateTableGridAdapter.swift b/apple/TablePro/Views/Structure/CreateTableGridAdapter.swift
new file mode 100644
index 0000000000..24d07eb1b0
--- /dev/null
+++ b/apple/TablePro/Views/Structure/CreateTableGridAdapter.swift
@@ -0,0 +1,275 @@
+//
+//  CreateTableGridAdapter.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+// The Create Table grid: every row is a definition the draft holds, edited by the definition a row
+// names. Held by the draft, so the grid's state survives the tab being switched away and back.
+@MainActor
+final class CreateTableGridAdapter {
+    let model: DataGridModel
+    let store: StructureGridStateStore
+    let structureChangeManager: StructureChangeManager
+    let connection: DatabaseConnection
+    let referenceMenus: ForeignKeyReferenceMenus
+
+    weak var coordinator: MainContentCoordinator?
+    var serverSupport = StructureServerSupport.unrestricted
+    private(set) var structureTab: StructureTab = .columns
+
+    var schemaName: String? {
+        get { referenceMenus.schemaName }
+        set { referenceMenus.schemaName = newValue }
+    }
+
+    private(set) var provider: StructureRowProvider
+    private var sortDescriptor: StructureSortDescriptor?
+    private var snapshot = StructureGridSnapshot()
+    private let changeTracking: StructureGridChangeState
+    private let changeState: AnyChangeManager
+
+    init(structureChangeManager: StructureChangeManager, connection: DatabaseConnection) {
+        self.structureChangeManager = structureChangeManager
+        self.connection = connection
+        let store = StructureGridStateStore()
+        self.store = store
+        self.model = DataGridModel(store: store)
+        self.referenceMenus = ForeignKeyReferenceMenus(connectionId: connection.id, databaseType: connection.type)
+        self.changeTracking = StructureGridChangeState(manager: structureChangeManager)
+        self.changeState = AnyChangeManager(changeTracking)
+        self.provider = StructureRowProvider(
+            changeManager: structureChangeManager,
+            tab: .columns,
+            databaseType: connection.type,
+            additionalFields: [.primaryKey],
+            serverSupport: .unrestricted
+        )
+        referenceMenus.onListsChanged = { [weak self] in
+            self?.coordinator?.inspectorRowSourceRevision += 1
+        }
+        model.dataSource = self
+        model.actions = self
+    }
+
+    func select(_ tab: StructureTab) {
+        guard tab != structureTab else { return }
+        model.commitEditing()
+        structureTab = tab
+        sortDescriptor = nil
+        store.switchSubTab(to: tab)
+        store.sortState = SortState()
+        refresh()
+    }
+
+    func refresh() {
+        changeTracking.tab = structureTab
+        changeTracking.rowCount = StructureGridEdits.rowCount(on: structureTab, manager: structureChangeManager)
+        let provider = StructureRowProvider(
+            changeManager: structureChangeManager,
+            tab: structureTab,
+            databaseType: connection.type,
+            additionalFields: [.primaryKey],
+            serverSupport: serverSupport,
+            sortDescriptor: sortDescriptor
+        )
+        self.provider = provider
+        let rows = provider.asTableRows()
+        let states = rows.rows.map { row in
+            StructureGridEdits.visualState(
+                sourceIndex: StructureRowProvider.sourceIndex(of: row.id) ?? -1,
+                tab: structureTab,
+                manager: structureChangeManager,
+                orderedFields: provider.orderedColumnFields,
+                tintsModifiedFields: false
+            )
+        }
+        model.configuration = makeConfiguration(provider: provider)
+        let previous = snapshot
+        snapshot = StructureGridSnapshot(rows: rows, states: states)
+        model.applyHeldSnapshot(from: previous, to: snapshot)
+        if previous.rows.rows != rows.rows || previous.states != states || previous.rows.columns != rows.columns {
+            coordinator?.inspectorRowSourceRevision += 1
+        }
+    }
+
+    private func makeConfiguration(provider: StructureRowProvider) -> DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.dropdownColumns = provider.dropdownColumns
+        configuration.typePickerColumns = provider.typePickerColumns
+        configuration.customDropdownOptions = provider.customDropdownOptions
+        configuration.isEditable = true
+        configuration.traits = DataGridEngineTraits(
+            databaseType: connection.type,
+            connectionScope: DatabaseScope(
+                connectionId: connection.id,
+                database: DatabaseManager.shared.browseDatabaseName(for: connection),
+                schema: schemaName
+            ),
+            looksUpUserDefinedTypes: true
+        )
+        configuration.commands = [.addRow, .deleteRows, .valueFilter, .freezeColumns]
+        return configuration
+    }
+
+    // MARK: - Commands
+
+    func menuOptions(sourceIndex: Int, field: Int) -> [GridMenuOption]? {
+        switch structureTab {
+        case .indexes:
+            guard structureChangeManager.workingIndexes.indices.contains(sourceIndex) else { return nil }
+            return StructureRowProvider.indexMenuOptions(
+                columnIndex: field,
+                index: structureChangeManager.workingIndexes[sourceIndex],
+                serverSupport: serverSupport
+            )
+        case .foreignKeys:
+            guard structureChangeManager.workingForeignKeys.indices.contains(sourceIndex) else { return nil }
+            return referenceMenus.options(
+                columnIndex: field,
+                foreignKey: structureChangeManager.workingForeignKeys[sourceIndex],
+                tableColumns: structureChangeManager.workingColumns.map(\.name)
+            )
+        case .columns, .checkConstraints, .ddl, .parts, .triggers:
+            return nil
+        }
+    }
+
+    @discardableResult
+    func applyEdit(rowID: RowID, field: Int, text: String) -> Bool {
+        guard let sourceIndex = StructureRowProvider.sourceIndex(of: rowID) else { return false }
+        write(text, field: field, sourceIndex: sourceIndex)
+        refresh()
+        return true
+    }
+
+    private func write(_ text: String, field: Int, sourceIndex: Int) {
+        guard field >= 0 else { return }
+        let changedReference = StructureGridEdits.apply(
+            text,
+            field: field,
+            sourceIndex: sourceIndex,
+            tab: structureTab,
+            manager: structureChangeManager,
+            orderedFields: provider.orderedColumnFields,
+            connection: connection
+        )
+        if let changedReference {
+            referenceMenus.prefetchReferencedColumns(
+                of: changedReference.referencedTable, schema: changedReference.referencedSchema
+            )
+        }
+    }
+
+    func addRow() {
+        StructureGridEdits.addRow(on: structureTab, manager: structureChangeManager)
+        refresh()
+    }
+
+    func deleteRows(_ rowIDs: [RowID]) {
+        let indices = rowIDs.compactMap(StructureRowProvider.sourceIndex(of:))
+        guard !indices.isEmpty else { return }
+        let displayRows = IndexSet(rowIDs.compactMap { model.displayIndex(of: $0) })
+        StructureGridEdits.delete(sourceIndices: indices, tab: structureTab, manager: structureChangeManager)
+        refresh()
+        let remaining = model.rowCount
+        guard remaining > 0, let minRow = displayRows.first, let maxRow = displayRows.last else {
+            model.clearSelection()
+            return
+        }
+        let target = maxRow < remaining ? maxRow : (minRow > 0 ? minRow - 1 : 0)
+        if let rowID = model.rowID(at: target) {
+            model.selectRows([rowID])
+        } else {
+            model.clearSelection()
+        }
+    }
+
+    func undo() {
+        model.commitEditing()
+        structureChangeManager.undo()
+        refresh()
+    }
+
+    func redo() {
+        model.commitEditing()
+        structureChangeManager.redo()
+        refresh()
+    }
+}
+
+extension CreateTableGridAdapter: DataGridDataSource {
+    var gridRows: TableRows { snapshot.rows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridVisualState(for rowID: RowID) -> RowVisualState? {
+        snapshot.state(for: rowID)
+    }
+
+    func gridMenuOptions(for rowID: RowID, column: DataGridColumn) -> [GridMenuOption]? {
+        guard let sourceIndex = StructureRowProvider.sourceIndex(of: rowID) else { return nil }
+        return menuOptions(sourceIndex: sourceIndex, field: column.dataIndex)
+    }
+}
+
+extension CreateTableGridAdapter: DataGridActions {
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        let writes = edits.compactMap { edit -> (Int, Int, String)? in
+            StructureRowProvider.sourceIndex(of: edit.rowID).map { ($0, edit.dataIndex, edit.newValue.asText ?? "") }
+        }
+        guard !writes.isEmpty else { return false }
+        let writeAll = {
+            for (sourceIndex, field, text) in writes {
+                self.write(text, field: field, sourceIndex: sourceIndex)
+            }
+        }
+        if writes.count > 1 {
+            structureChangeManager.performAsOneUndoStep(writeAll)
+        } else {
+            writeAll()
+        }
+        refresh()
+        return true
+    }
+
+    func gridDeleteRows(_ rowIDs: [RowID]) {
+        deleteRows(rowIDs)
+    }
+
+    func gridAddRow() {
+        addRow()
+    }
+
+    func gridSortDidChange(_ sort: SortState) {
+        if let primary = sort.columns.first {
+            sortDescriptor = StructureSortDescriptor(column: primary.columnIndex, ascending: primary.direction == .ascending)
+            store.sortState = SortState(columns: [primary], source: .user)
+        } else {
+            sortDescriptor = nil
+            store.sortState = SortState(columns: [], source: .user)
+        }
+        refresh()
+    }
+}
+
+extension CreateTableGridAdapter: InspectorRowSource {
+    func inspectorRow(atDisplayRow displayRow: Int) -> InspectorRow? {
+        guard let rowID = model.rowID(at: displayRow),
+              let sourceIndex = StructureRowProvider.sourceIndex(of: rowID),
+              let providerRow = provider.displayRow(ofSourceIndex: sourceIndex) else { return nil }
+        return StructureInspectorRowBuilder.row(
+            atDisplayRow: providerRow,
+            tab: structureTab,
+            provider: provider,
+            canEditSchema: true,
+            rowOptions: { menuOptions(sourceIndex: sourceIndex, field: $0) }
+        )
+    }
+
+    func commitInspectorField(displayRow: Int, fieldIndex: Int, value: String?) {
+        guard let rowID = model.rowID(at: displayRow) else { return }
+        applyEdit(rowID: rowID, field: fieldIndex, text: value ?? "")
+    }
+}
diff --git a/apple/TablePro/Views/Structure/CreateTableGridDelegate+Inspector.swift b/apple/TablePro/Views/Structure/CreateTableGridDelegate+Inspector.swift
deleted file mode 100644
index bb238635e0..0000000000
--- a/apple/TablePro/Views/Structure/CreateTableGridDelegate+Inspector.swift
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-//  CreateTableGridDelegate+Inspector.swift
-//  TablePro
-//
-//  Supplies the right inspector with the selected new-table row and routes
-//  its edits back through the same commit path as an inline grid edit.
-//
-
-import Foundation
-import TableProPluginKit
-
-extension CreateTableGridDelegate: InspectorRowSource {
-    func inspectorRow(atDisplayRow displayRow: Int) -> InspectorRow? {
-        StructureInspectorRowBuilder.row(
-            atDisplayRow: displayRow,
-            tab: structureTab,
-            provider: StructureRowProvider(
-                changeManager: structureChangeManager,
-                tab: structureTab,
-                databaseType: connection.type,
-                additionalFields: [.primaryKey],
-                serverSupport: serverSupport
-            ),
-            canEditSchema: true,
-            rowOptions: { dataGridMenuOptions(forRow: displayRow, columnIndex: $0) }
-        )
-    }
-
-    func commitInspectorField(displayRow: Int, fieldIndex: Int, value: String?) {
-        dataGridDidEditCell(row: displayRow, column: fieldIndex, newValue: value)
-    }
-}
diff --git a/apple/TablePro/Views/Structure/CreateTableGridDelegate+References.swift b/apple/TablePro/Views/Structure/CreateTableGridDelegate+References.swift
deleted file mode 100644
index 88dd4ac072..0000000000
--- a/apple/TablePro/Views/Structure/CreateTableGridDelegate+References.swift
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-//  CreateTableGridDelegate+References.swift
-//  TablePro
-//
-
-import Foundation
-import TableProPluginKit
-
-/// The Foreign Keys grid's three reference cells offer what the database actually holds.
-///
-/// They were free text, so the only way to point a key at a table was to spell its name and its
-/// columns from memory, and a typo produced a server error at Create time rather than a list that
-/// could not be wrong. `StructureGridDelegate` answers the same question for an existing table, and
-/// both go through `ForeignKeyReferenceMenus` so the two grids cannot drift. The Indexes grid's Type
-/// cell goes through `StructureRowProvider.indexMenuOptions` for the same reason.
-extension CreateTableGridDelegate {
-    func dataGridMenuOptions(forRow row: Int, columnIndex: Int) -> [GridMenuOption]? {
-        if structureTab == .indexes {
-            guard structureChangeManager.workingIndexes.indices.contains(row) else { return nil }
-            return StructureRowProvider.indexMenuOptions(
-                columnIndex: columnIndex,
-                index: structureChangeManager.workingIndexes[row],
-                serverSupport: serverSupport
-            )
-        }
-        guard structureTab == .foreignKeys,
-              row >= 0, row < structureChangeManager.workingForeignKeys.count else { return nil }
-        return referenceMenus.options(
-            columnIndex: columnIndex,
-            foreignKey: structureChangeManager.workingForeignKeys[row],
-            tableColumns: structureChangeManager.workingColumns.map(\.name)
-        )
-    }
-}
diff --git a/apple/TablePro/Views/Structure/CreateTableGridDelegate.swift b/apple/TablePro/Views/Structure/CreateTableGridDelegate.swift
deleted file mode 100644
index 32c9344c22..0000000000
--- a/apple/TablePro/Views/Structure/CreateTableGridDelegate.swift
+++ /dev/null
@@ -1,187 +0,0 @@
-//
-//  CreateTableGridDelegate.swift
-//  TablePro
-//
-//  DataGridViewDelegate implementation for CreateTableView.
-//  Differs from StructureGridDelegate in column mapping (includes PrimaryKey field).
-//
-
-import AppKit
-import TableProPluginKit
-
-@MainActor
-final class CreateTableGridDelegate: DataGridViewDelegate {
-    let structureChangeManager: StructureChangeManager
-    var structureTab: StructureTab
-    let connection: DatabaseConnection
-    var onSelectedRowsChanged: ((Set<Int>) -> Void)?
-    var orderedFields: [StructureColumnField] = []
-    var serverSupport = StructureServerSupport.unrestricted
-    /// The lists behind the Foreign Keys grid's reference cells. Held per delegate, so the column
-    /// cache dies with the tab rather than outliving every connection.
-    let referenceMenus: ForeignKeyReferenceMenus
-
-    /// The schema the draft is being created in, so the reference menus offer that schema's tables.
-    var schemaName: String? {
-        get { referenceMenus.schemaName }
-        set { referenceMenus.schemaName = newValue }
-    }
-
-    var onReferenceListsChanged: (() -> Void)? {
-        get { referenceMenus.onListsChanged }
-        set { referenceMenus.onListsChanged = newValue }
-    }
-
-    /// Captured from `DataGridView.updateNSView` so we can ask `NSTableView` to
-    /// reload affected rows after a state mutation. Required because the
-    /// SwiftUI re-render driven by `reloadVersion` only triggers a full
-    /// `reloadData` when row count or column schema changes; cell-content edits
-    /// alone won't redraw without this targeted reload.
-    private weak var attachedCoordinator: TableViewCoordinator?
-
-    init(
-        structureChangeManager: StructureChangeManager,
-        structureTab: StructureTab,
-        connection: DatabaseConnection
-    ) {
-        self.structureChangeManager = structureChangeManager
-        self.structureTab = structureTab
-        self.connection = connection
-        self.referenceMenus = ForeignKeyReferenceMenus(
-            connectionId: connection.id, databaseType: connection.type
-        )
-    }
-
-    // MARK: - DataGridViewDelegate
-
-    func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        attachedCoordinator = tableViewCoordinator
-    }
-
-    func dataGridDidEditCell(row: Int, column: Int, newValue: String?) {
-        guard column >= 0 else { return }
-
-        switch structureTab {
-        case .columns:
-            guard row < structureChangeManager.workingColumns.count else { return }
-            var col = structureChangeManager.workingColumns[row]
-            StructureEditingSupport.updateColumn(&col, at: column, with: newValue ?? "", orderedFields: orderedFields)
-            structureChangeManager.updateColumn(id: col.id, with: col)
-
-        case .indexes:
-            guard row < structureChangeManager.workingIndexes.count else { return }
-            var idx = structureChangeManager.workingIndexes[row]
-            StructureEditingSupport.updateIndex(
-                &idx,
-                at: column,
-                with: newValue ?? "",
-                keys: StructureEditingSupport.indexKeyContext(for: structureChangeManager, on: connection)
-            )
-            structureChangeManager.updateIndex(id: idx.id, with: idx)
-
-        case .foreignKeys:
-            guard row < structureChangeManager.workingForeignKeys.count else { return }
-            var fk = structureChangeManager.workingForeignKeys[row]
-            StructureEditingSupport.updateForeignKey(&fk, at: column, with: newValue ?? "")
-            structureChangeManager.updateForeignKey(id: fk.id, with: fk)
-            if column == 2 {
-                referenceMenus.prefetchReferencedColumns(
-                    of: fk.referencedTable, schema: fk.referencedSchema
-                )
-            }
-
-        default:
-            break
-        }
-
-        reloadDisplayRow(row)
-    }
-
-    private func reloadDisplayRow(_ displayRow: Int) {
-        attachedCoordinator?.reloadRowAndState(at: displayRow)
-    }
-
-    private func reloadAllVisibleRows() {
-        attachedCoordinator?.reloadVisibleRowsAndStates()
-    }
-
-    func dataGridVisualState(forRow row: Int) -> RowVisualState? {
-        let (isDeleted, isInserted) = structureChangeManager.deleteInsertState(for: row, tab: structureTab)
-        return RowVisualState(isDeleted: isDeleted, isInserted: isInserted, modifiedColumns: [])
-    }
-
-    func dataGridDeleteRows(_ rows: Set<Int>) {
-        /// One Cmd+Z brings the whole selection back. The manager registers an undo per
-        /// deleted row, so the batch states that it is one step; without that a five-row
-        /// delete takes five undos.
-        structureChangeManager.performAsOneUndoStep {
-            switch structureTab {
-            case .columns:
-                for row in rows.sorted(by: >) {
-                    guard row < structureChangeManager.workingColumns.count else { continue }
-                    let column = structureChangeManager.workingColumns[row]
-                    structureChangeManager.deleteColumn(id: column.id)
-                }
-            case .indexes:
-                for row in rows.sorted(by: >) {
-                    guard row < structureChangeManager.workingIndexes.count else { continue }
-                    let index = structureChangeManager.workingIndexes[row]
-                    structureChangeManager.deleteIndex(id: index.id)
-                }
-            case .foreignKeys:
-                for row in rows.sorted(by: >) {
-                    guard row < structureChangeManager.workingForeignKeys.count else { continue }
-                    let fk = structureChangeManager.workingForeignKeys[row]
-                    structureChangeManager.deleteForeignKey(id: fk.id)
-                }
-            default:
-                break
-            }
-        }
-
-        let newCount: Int
-        switch structureTab {
-        case .columns: newCount = structureChangeManager.workingColumns.count
-        case .indexes: newCount = structureChangeManager.workingIndexes.count
-        case .foreignKeys: newCount = structureChangeManager.workingForeignKeys.count
-        default: newCount = 0
-        }
-
-        if newCount > 0 {
-            let maxRow = rows.max() ?? 0
-            let minRow = rows.min() ?? 0
-            if maxRow < newCount {
-                onSelectedRowsChanged?([maxRow])
-            } else if minRow > 0 {
-                onSelectedRowsChanged?([minRow - 1])
-            } else {
-                onSelectedRowsChanged?([0])
-            }
-        } else {
-            onSelectedRowsChanged?([])
-        }
-    }
-
-    func dataGridUndo() {
-        structureChangeManager.undo()
-        reloadAllVisibleRows()
-    }
-
-    func dataGridRedo() {
-        structureChangeManager.redo()
-        reloadAllVisibleRows()
-    }
-
-    func dataGridAddRow() {
-        switch structureTab {
-        case .columns:
-            structureChangeManager.addNewColumn()
-        case .indexes:
-            structureChangeManager.addNewIndex()
-        case .foreignKeys:
-            structureChangeManager.addNewForeignKey()
-        default:
-            break
-        }
-    }
-}
diff --git a/apple/TablePro/Views/Structure/CreateTableView.swift b/apple/TablePro/Views/Structure/CreateTableView.swift
index 1c6916cf98..24f6604657 100644
--- a/apple/TablePro/Views/Structure/CreateTableView.swift
+++ b/apple/TablePro/Views/Structure/CreateTableView.swift
@@ -2,9 +2,6 @@
 //  CreateTableView.swift
 //  TablePro
 //
-//  Self-contained view for creating a new database table.
-//  Uses StructureChangeManager and DataGridView for column/index/FK editing.
-//
 
 import AppKit
 import Combine
@@ -33,20 +30,14 @@ struct CreateTableView: View {
 
     let connection: DatabaseConnection
 
-    /// The tab's own scope, which is where the table is created. The browse cursor moves when the
-    /// user clicks another database in the sidebar and the open Create Table tab does not follow it,
-    /// so taking the cursor created the table somewhere the tab never named.
     let scope: DatabaseScope?
     var coordinator: MainContentCoordinator?
-    @ObservedObject var selectionState: GridSelectionState
 
     @Environment(\.appServices) private var services
 
-    /// The definition in progress. Held outside this view because the view is destroyed the moment
-    /// the tab is deselected, and nothing in a Create Table tab exists anywhere else yet.
     @ObservedObject var draft: CreateTableDraft
-
-    @StateObject private var wrappedChangeManager: AnyChangeManager
+    @ObservedObject private var gridModel: DataGridModel
+    private let gridAdapter: CreateTableGridAdapter
 
     private var structureChangeManager: StructureChangeManager { draft.changeManager }
 
@@ -54,35 +45,21 @@ struct CreateTableView: View {
     @State private var isCreating = false
     @State private var errorMessage: String?
     @State private var showError = false
-    @State private var gridDelegate: CreateTableGridDelegate
     @State private var actionHandler = CreateTableActionHandler()
 
-    // DataGridView state
-    @State private var selectedRows: Set<Int> = []
-    @State private var sortState = SortState()
-    @State private var columnLayout = ColumnLayoutState()
-    @State private var serverSupport = StructureServerSupport.unrestricted
-
     init(
         connection: DatabaseConnection,
         scope: DatabaseScope?,
         coordinator: MainContentCoordinator?,
-        selectionState: GridSelectionState,
         draft: CreateTableDraft
     ) {
         self.connection = connection
         self.scope = scope
         self.coordinator = coordinator
-        self.selectionState = selectionState
         self.draft = draft
-
-        let manager = draft.changeManager
-        _wrappedChangeManager = StateObject(wrappedValue: AnyChangeManager(manager))
-        _gridDelegate = State(wrappedValue: CreateTableGridDelegate(
-            structureChangeManager: manager,
-            structureTab: .columns,
-            connection: connection
-        ))
+        let adapter = draft.gridAdapter(for: connection)
+        self.gridAdapter = adapter
+        self.gridModel = adapter.model
     }
 
     var body: some View {
@@ -93,9 +70,6 @@ struct CreateTableView: View {
         }
         .navigationTitle(String(localized: "Create Table"))
         .onAppear {
-            /// A workspace switch remounts this view with `selectedRows` intact and the grid still
-            /// highlighting them, so the channel `onDisappear` cleared gets them back, not nothing.
-            selectionState.indices = selectedRows
             draft.resolveForm(
                 from: DatabaseManager.shared.driver(for: connection.id)?.createTableFormSpec(schema: scope?.schema)
             )
@@ -107,30 +81,18 @@ struct CreateTableView: View {
             coordinator?.toolbarState.hasCreateTablePending = isReadyToCreate
         }
         .onDisappear {
-            /// Guarded by identity, like the `inspectorRowSource` clear below it. SwiftUI does not
-            /// order the outgoing view's `onDisappear` before the incoming view's `onAppear`, so an
-            /// unguarded clear that lands second nils the wiring the incoming Create Table tab has
-            /// already installed, leaving its Create button and its close prompt dead.
-            ///
-            /// The shared selection channel gets a second guard, because a data grid mounting in
-            /// this tab's place restores its own rows into it and this clear landing afterwards
-            /// would wipe them.
+            // Guarded by identity: the outgoing view's onDisappear can land after the incoming one's onAppear.
             if coordinator?.createTableActions === actionHandler {
-                if GridSelectionOwner.resolve(
-                    tabType: coordinator?.tabManager.selectedTab?.tabType,
-                    resultsViewMode: coordinator?.tabManager.selectedTab?.display.resultsViewMode
-                ) != .dataGrid {
-                    selectionState.indices = []
-                }
                 coordinator?.createTableActions = nil
                 coordinator?.toolbarState.hasCreateTablePending = false
             }
-            if coordinator?.inspectorRowSource === gridDelegate {
+            if coordinator?.inspectorRowSource === gridAdapter {
                 coordinator?.inspectorRowSource = nil
             }
         }
-        .onChange(of: selectedRows) { newRows in selectionState.indices = newRows }
-        .onChange(of: selectedTab) { _ in updateGridDelegate() }
+        .onChange(of: selectedTab) { _ in gridAdapter.select(structureTab) }
+        .onChange(of: structureChangeManager.reloadVersion) { _ in gridAdapter.refresh() }
+        .onChange(of: structureChangeManager.hasChanges) { _ in gridAdapter.refresh() }
         .onChange(of: isReadyToCreate) { _ in updateCreateTablePendingState() }
         .task(id: compositionKey) { await recomposeAfterPause() }
         .alert(String(localized: "Create Table Failed"), isPresented: $showError) {
@@ -160,16 +122,17 @@ struct CreateTableView: View {
     }
 
     private func attachStructureGrid() {
-        coordinator?.inspectorRowSource = gridDelegate
-        gridDelegate.onSelectedRowsChanged = { self.selectedRows = $0 }
-        gridDelegate.onReferenceListsChanged = { coordinator?.inspectorRowSourceRevision += 1 }
-        serverSupport = StructureServerSupport.forConnection(connection.id)
-        updateGridDelegate()
+        coordinator?.inspectorRowSource = gridAdapter
+        gridAdapter.coordinator = coordinator
+        gridAdapter.serverSupport = StructureServerSupport.forConnection(connection.id)
+        gridAdapter.schemaName = coordinator?.toolbarState.currentSchema
         if structureChangeManager.workingColumns.isEmpty {
             structureChangeManager.addNewColumn()
         }
-        actionHandler.undo = { gridDelegate.dataGridUndo() }
-        actionHandler.redo = { gridDelegate.dataGridRedo() }
+        gridAdapter.select(structureTab)
+        gridAdapter.refresh()
+        actionHandler.undo = { gridAdapter.undo() }
+        actionHandler.redo = { gridAdapter.redo() }
     }
 
     // MARK: - Config Bar
@@ -238,7 +201,6 @@ struct CreateTableView: View {
         CreateTableDraft.offersEngineOptions(for: connection.type)
     }
 
-    /// The form path builds its own statements and has no place for a comment.
     private var offersTableComment: Bool {
         guard draft.hasResolvedForm, draft.form == nil else { return false }
         let support = DatabaseObjectToolEligibility.Support.of(DatabaseManager.shared.driver(for: connection.id))
@@ -260,13 +222,10 @@ struct CreateTableView: View {
     }
 
     private var toolbar: some View {
-        /// The composed issues, not the plan's. A driver that cannot spell one of the statements,
-        /// as Snowflake and Trino cannot spell `CREATE INDEX`, reports it only here, and reading the
-        /// plan alone left Create Table enabled over a preview the app would then refuse to run.
         let issues = draft.composed?.issues ?? draft.plan(for: connection.type).issues
 
         return HStack(spacing: 8) {
-            Button(action: { gridDelegate.dataGridAddRow() }) {
+            Button(action: { gridAdapter.addRow() }) {
                 Image(systemName: "plus")
                     .frame(width: 24, height: 24)
             }
@@ -274,13 +233,13 @@ struct CreateTableView: View {
             .accessibilityLabel(String(localized: "Add Row"))
             .disabled(!isGridTab)
 
-            Button(action: { gridDelegate.dataGridDeleteRows(selectedRows) }) {
+            Button(action: { gridAdapter.deleteRows(gridModel.selectedRowIDs) }) {
                 Image(systemName: "minus")
                     .frame(width: 24, height: 24)
             }
             .help(String(localized: "Delete Selected"))
             .accessibilityLabel(String(localized: "Delete Selected"))
-            .disabled(!isGridTab || selectedRows.isEmpty)
+            .disabled(!isGridTab || gridModel.selection.isEmpty)
 
             issueMessage(issues)
 
@@ -308,12 +267,6 @@ struct CreateTableView: View {
         .padding()
     }
 
-    /// The reason Create Table is unavailable, beside the row it is about.
-    ///
-    /// A row the user began and did not finish used to be deleted from the generated statement with
-    /// no message, which is how a filled-in foreign key came to vanish between the grid and the SQL
-    /// Preview. Naming the segment matters as much as naming the problem, because the offending row
-    /// is usually on a segment the user is not looking at.
     @ViewBuilder
     private func issueMessage(_ issues: [SchemaDraftIssue]) -> some View {
         if let first = issues.first {
@@ -354,65 +307,8 @@ struct CreateTableView: View {
         }
     }
 
-    private func updateGridDelegate() {
-        let provider = StructureRowProvider(
-            changeManager: structureChangeManager,
-            tab: structureTab,
-            databaseType: connection.type,
-            additionalFields: [.primaryKey],
-            serverSupport: serverSupport
-        )
-        gridDelegate.structureTab = structureTab
-        gridDelegate.serverSupport = serverSupport
-        gridDelegate.orderedFields = provider.orderedColumnFields
-        gridDelegate.schemaName = coordinator?.toolbarState.currentSchema
-        coordinator?.inspectorRowSourceRevision += 1
-    }
-
     private var structureGrid: some View {
-        let provider = StructureRowProvider(
-            changeManager: structureChangeManager,
-            tab: structureTab,
-            databaseType: connection.type,
-            additionalFields: [.primaryKey],
-            serverSupport: serverSupport
-        )
-
-        // Rebuild the row snapshot fresh on every call so cell edits made
-        // through the delegate are visible to the next reloadData. Capturing
-        // a snapshot here would let the cell view re-render with the pre-edit
-        // value. Same rationale as `TableStructureView.structureGrid`.
-        let manager = structureChangeManager
-        let tab = structureTab
-        let dbType = connection.type
-        let support = serverSupport
-        return DataGridView(
-            tableRowsProvider: {
-                StructureRowProvider(
-                    changeManager: manager,
-                    tab: tab,
-                    databaseType: dbType,
-                    additionalFields: [.primaryKey],
-                    serverSupport: support
-                ).asTableRows()
-            },
-            changeManager: wrappedChangeManager,
-            isEditable: true,
-            configuration: DataGridConfiguration(
-                dropdownColumns: provider.dropdownColumns,
-                typePickerColumns: provider.typePickerColumns,
-                customDropdownOptions: provider.customDropdownOptions,
-                connectionId: connection.id,
-                databaseType: connection.type,
-                databaseName: DatabaseManager.shared.browseDatabaseName(for: connection),
-                schemaName: coordinator?.toolbarState.currentSchema,
-                tabType: .createTable
-            ),
-            delegate: gridDelegate,
-            selectedRowIndices: $selectedRows,
-            sortState: $sortState,
-            columnLayout: $columnLayout
-        )
+        DataGridView(model: gridModel)
     }
 
     // MARK: - SQL Preview
@@ -438,8 +334,6 @@ struct CreateTableView: View {
         )
     }
 
-    // Cell editing, row operations, undo/redo handled by CreateTableGridDelegate
-
     // MARK: - SQL Generation
 
     private static let compositionPause: Duration = .milliseconds(150)
@@ -477,13 +371,6 @@ struct CreateTableView: View {
         coordinator?.toolbarState.hasCreateTablePending = isReadyToCreate
     }
 
-    /// Routed through `DatabaseManager.executeCreateTable`, which owns the authorization, the
-    /// isolated connection, the transaction and the history records.
-    ///
-    /// The view used to do all four itself against `driver(for:)`, which is the session driver. A
-    /// `BEGIN` there joins whatever transaction a query tab left open, and the `COMMIT` after the
-    /// last `CREATE INDEX` takes that tab's uncommitted work with it. `schemaChangeRoute` exists to
-    /// keep the app's own DDL off the user's connection.
     private func createTable() {
         guard draft.form != nil else {
             createTableFromStructureGrid()
diff --git a/apple/TablePro/Views/Structure/HeldRowsGridAdapter.swift b/apple/TablePro/Views/Structure/HeldRowsGridAdapter.swift
new file mode 100644
index 0000000000..5f4b3217c1
--- /dev/null
+++ b/apple/TablePro/Views/Structure/HeldRowsGridAdapter.swift
@@ -0,0 +1,130 @@
+//
+//  HeldRowsGridAdapter.swift
+//  TablePro
+//
+
+import AppKit
+import Combine
+import TableProTheme
+
+// A read-only grid over rows its owner holds in full: the Structure lists, agent results, table
+// listings, both comparisons and the theme preview. Nothing here can reach a table's saved layout.
+@MainActor
+final class HeldRowsGridAdapter: ObservableObject {
+    let model: DataGridModel
+
+    // Sorts the held rows itself when no owner re-orders them.
+    var sortsHeldRows: Bool
+    var onSortChange: ((SortState) -> Void)?
+    var onSelectionChange: (([RowID]) -> Void)?
+
+    var visualStates: [RowID: RowVisualState] = [:]
+    var textTones: [RowID: [Int: NSColor]] = [:]
+    var spokenTexts: [RowID: [Int: String]] = [:]
+    var checkboxState: ((RowID, DataGridColumn) -> Bool?)?
+    var checkboxChange: ((Bool, [RowID], DataGridColumn) -> Void)?
+
+    private(set) var heldRows = TableRows()
+    private var displayedRows = TableRows()
+    private let changeState = AnyChangeManager(DataChangeManager())
+    private var selectionSubscription: AnyCancellable?
+
+    init(
+        configuration: DataGridConfiguration,
+        sortsHeldRows: Bool = false,
+        columnLayout: ColumnLayoutState = ColumnLayoutState(),
+        sortState: SortState = SortState(),
+        themeScope: ThemeScope = .live
+    ) {
+        self.sortsHeldRows = sortsHeldRows
+        self.model = DataGridModel(
+            store: InMemoryDataGridStateStore(columnLayout: columnLayout, sortState: sortState),
+            configuration: configuration,
+            themeScope: themeScope
+        )
+        model.dataSource = self
+        model.actions = self
+        selectionSubscription = model.$selectionRevision
+            .dropFirst()
+            .sink { [weak self] _ in
+                guard let self else { return }
+                self.onSelectionChange?(self.model.selectedRowIDs)
+            }
+    }
+
+    // The rows were replaced.
+    func setRows(_ rows: TableRows) {
+        let previousColumns = displayedRows.columns
+        heldRows = rows
+        displayedRows = sortsHeldRows ? TableRowsSorting.sorted(rows, by: model.store.sortState) : rows
+        model.reloadHeldRows(columnsChanged: previousColumns != rows.columns || model.columns.isEmpty)
+    }
+
+    // The same rows with some cells drawn differently, as a checkbox after a toggle.
+    func redrawCells(_ cells: Set<CellPosition>) {
+        guard !cells.isEmpty else { return }
+        model.apply(.cellsChanged(cells))
+    }
+
+    // An owner that sorts its rows itself reports the sort it applied, so the header shows it.
+    func showSort(_ sort: SortState) {
+        guard model.store.sortState != sort else { return }
+        model.store.sortState = sort
+        guard sortsHeldRows else { return }
+        displayedRows = TableRowsSorting.sorted(heldRows, by: sort)
+        model.reloadRows()
+    }
+
+    func storageIndex(of rowID: RowID) -> Int? {
+        displayedRows.index(of: rowID)
+    }
+}
+
+extension HeldRowsGridAdapter: DataGridDataSource {
+    var gridRows: TableRows { displayedRows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridVisualState(for rowID: RowID) -> RowVisualState? {
+        visualStates[rowID]
+    }
+
+    func gridTextTone(for rowID: RowID, column: DataGridColumn) -> NSColor? {
+        textTones[rowID]?[column.dataIndex]
+    }
+
+    func gridAccessibilityText(for rowID: RowID, column: DataGridColumn) -> String? {
+        spokenTexts[rowID]?[column.dataIndex]
+    }
+
+    func gridCheckboxState(for rowID: RowID, column: DataGridColumn) -> Bool? {
+        checkboxState?(rowID, column)
+    }
+}
+
+extension HeldRowsGridAdapter: DataGridActions {
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        false
+    }
+
+    func gridSortDidChange(_ sort: SortState) {
+        if sortsHeldRows {
+            displayedRows = TableRowsSorting.sorted(heldRows, by: sort)
+            model.reloadRows()
+        }
+        onSortChange?(sort)
+    }
+
+    func gridSetCheckbox(_ isOn: Bool, rowIDs: [RowID], column: DataGridColumn) {
+        checkboxChange?(isOn, rowIDs, column)
+    }
+}
+
+extension DataGridModel {
+    // Rows an owner holds were replaced; another column set rebuilds the view's columns before the reload.
+    func reloadHeldRows(columnsChanged: Bool) {
+        if columnsChanged {
+            apply(.columnsReplaced)
+        }
+        reloadRows()
+    }
+}
diff --git a/apple/TablePro/Views/Structure/StructureEditingSession.swift b/apple/TablePro/Views/Structure/StructureEditingSession.swift
index 80be406d47..4cddaf324f 100644
--- a/apple/TablePro/Views/Structure/StructureEditingSession.swift
+++ b/apple/TablePro/Views/Structure/StructureEditingSession.swift
@@ -8,36 +8,10 @@ import Foundation
 import os
 import TableProPluginKit
 
-/// Everything one tab's structure editor is, held outside the view that presents it.
-///
-/// `MainEditorContentView` builds only the selected tab's content, and the results view mode is a
-/// `switch` inside that, so switching tabs and switching a tab between Data and Structure both tear
-/// the view down and take its `@State` with it. The user's staged ALTERs, where they were in the
-/// editor, and the ability to apply them all have to outlive that.
-///
-/// Two rules follow, and both were learned the hard way.
-///
-/// First, **the session is the tab's editor, not a cache the view consults.** Anything seeded from
-/// the session into `@State` is frozen at the moment SwiftUI first creates that view identity, so it
-/// silently keeps answering for whichever tab got there first. `TableStructureView` therefore holds
-/// no editor state of its own; it reads and writes this object.
-///
-/// Second, **applying the staged edits cannot require a mounted view.** The close prompt asks about
-/// staged ALTERs by reading this session, so a background tab can raise it; if Save then dispatched
-/// through the view, it would save nothing and the close would destroy the work anyway.
-/// `applyStagedChanges` lives here for that reason.
-///
-/// The loaded schema travels with the edits, and not as an optimisation. `StructureChangeManager`
-/// adopts a new baseline through `loadSchema`, which clears every pending change, the validation
-/// errors and the undo stack, so a rebuild that refetched the schema would discard the edits on its
-/// way back in. Holding the baseline here is what lets the rebuild skip the fetch, and skipping the
-/// fetch is the only version of this that keeps the edits.
 @MainActor
 internal final class StructureEditingSession: ObservableObject {
     static let logger = Logger(subsystem: "com.TablePro", category: "StructureEditingSession")
 
-    /// The scope and table this session was opened against. A tab retargeted to another table gets
-    /// a new session rather than inheriting edits staged against the old one.
     internal let identity: String
 
     internal let connection: DatabaseConnection
@@ -46,19 +20,15 @@ internal final class StructureEditingSession: ObservableObject {
     internal let isSessionBound: Bool
     internal let tableName: String
 
-    /// What kind of object this session edits, which decides which edits it may offer at all. A tab
-    /// retargeted to another object gets a new session, so this never has to change under a session.
     internal let objectKind: TableInfo.TableType
 
     internal let changeManager = StructureChangeManager()
 
-    /// Built here, not seeded into the view's `@State`. `State(wrappedValue:)` runs only the first
-    /// time SwiftUI creates a given view identity, and `StructureGridDelegate` holds its change
-    /// manager in a `let`, so a delegate seeded from a session went on writing into that session
-    /// after the view had been handed a different one. Owning both here means the grid the user
-    /// types into and the edits the close prompt reports are the same object by construction.
-    internal let gridDelegate: StructureGridDelegate
-    internal let wrappedChangeManager: AnyChangeManager
+    // Owned here, not by the view, so the grid the user types into and the edits the close prompt
+    // reports are one object, and its model outlives every remount.
+    internal let gridAdapter: StructureGridAdapter
+
+    internal var gridModel: DataGridModel { gridAdapter.model }
 
     internal var scope: DatabaseScope {
         DatabaseScope(
@@ -81,17 +51,12 @@ internal final class StructureEditingSession: ObservableObject {
 
     internal var loadedTableComment: String? { tableComment.value ?? nil }
 
-    /// Where the user was. Held here rather than in the view because two tabs on one table are two
-    /// editors: one being on Indexes must not move the other, and neither should lose its place to
-    /// a trip through the Data view.
     @Published internal var selectedTab: StructureTab = .columns
     @Published internal var searchText = ""
     @Published internal var sortState = SortState()
     @Published internal var sortDescriptor: StructureSortDescriptor?
     @Published internal var columnLayouts: [StructureTab: ColumnLayoutState] = [:]
 
-    /// A tab the server withdraws cannot stay selected, or the editor shows a grid for something
-    /// the server has none of and no segment matches the selection.
     @Published internal var serverSupport = StructureServerSupport.unrestricted {
         didSet {
             guard !availableTabs.contains(selectedTab) else { return }
@@ -103,9 +68,6 @@ internal final class StructureEditingSession: ObservableObject {
         StructureTabAvailability.tabs(for: connection.type, serverSupport: serverSupport)
     }
 
-    /// What a mount fetches: the sub-tabs the change manager is baselined from, then the one the
-    /// user left selected. A mount does not change the selection, so nothing else fetches that one,
-    /// and after `markStructureStale` or an apply it would go on showing the object as it was.
     internal var tabsFetchedOnMount: [StructureTab] {
         var tabs: [StructureTab] = [.columns, .indexes, .foreignKeys]
         if availableTabs.contains(.checkConstraints) {
@@ -117,34 +79,16 @@ internal final class StructureEditingSession: ObservableObject {
         return tabs
     }
 
-    /// What the bottom bar offers while this tab is showing its structure.
-    ///
-    /// Keyed by tab through the session, so two structure tabs cannot answer for each other. The
-    /// shape this replaces was one app-wide object with a `currentOwner` guard, and the guard
-    /// existed only to work out which structure view the buttons currently belonged to.
     @Published internal var footer = StructureFooterCapability()
 
-    /// Whether the opening fetch has already run. True only after a real load, so a rebuild adopts
-    /// what is here instead of refetching, while a genuine refresh still goes through
-    /// `onRefreshData`, which asks before discarding.
     @Published internal var hasLoaded = false
 
-    /// Bumped when `applyStagedChanges` has written to the database. A mounted view watches it and
-    /// refreshes what it is showing; an unmounted one does not need to, because the apply already
-    /// marked the tab data stale and cleared `hasLoaded`.
     @Published internal private(set) var appliedVersion = 0
 
-    /// Raised across a save so the `onChange` handlers watching `columns`, `indexes` and
-    /// `foreignKeys` do not mistake the post-save reload for the user editing.
     @Published internal var isApplying = false
 
-    /// When the last apply landed, used to keep an incoming refresh notification from re-fetching
-    /// what the save has just re-fetched.
     @Published internal var lastAppliedAt: Date?
 
-    /// What every save from this tab is authorized through. A test supplies one whose prompts
-    /// answer themselves, because the real gate raises an application-modal alert that nothing on
-    /// a CI runner can dismiss.
     internal var executionGate: any ExecutionGate = ExecutionGateProvider.shared
 
     internal init(
@@ -165,31 +109,25 @@ internal final class StructureEditingSession: ObservableObject {
         self.tableName = tableName
         self.objectKind = objectKind
         self.serverSupport = serverSupport
-        gridDelegate = StructureGridDelegate(
+        gridAdapter = StructureGridAdapter(
             structureChangeManager: changeManager,
-            selectedTab: .columns,
             connection: connection,
             tableName: tableName,
+            databaseName: databaseName,
+            schemaName: schemaName,
             objectKind: objectKind,
-            coordinator: nil
+            isSessionBound: isSessionBound
         )
-        gridDelegate.referenceMenus.schemaName = schemaName
-        gridDelegate.schemaName = schemaName
-        gridDelegate.isSessionBound = isSessionBound
-        wrappedChangeManager = AnyChangeManager(changeManager)
+        gridAdapter.session = self
+        gridAdapter.store.session = self
     }
 
     internal func markApplied() {
         appliedVersion += 1
     }
 
-    /// A change made elsewhere while edits were staged here. Fetching it would re-baseline the change
-    /// manager and discard the edits without asking, so it waits for them to go. An apply fetches
-    /// everything again, which answers it; an undo or a discard leaves it to `settleOwedRefetch`.
     internal private(set) var owesRefetch = false
 
-    /// The object changed outside this editor, so the next mount fetches it again. A session holding
-    /// staged edits keeps them and the baseline they were made against, and owes the fetch instead.
     internal func markStructureStale() {
         guard !changeManager.hasChanges else {
             owesRefetch = true
@@ -199,8 +137,6 @@ internal final class StructureEditingSession: ObservableObject {
         hasLoaded = false
     }
 
-    /// Answers a change owed from while edits were staged, once they are gone. True when it did, and
-    /// the structure on screen, if any, has to be fetched again now.
     @discardableResult
     internal func settleOwedRefetch() -> Bool {
         guard owesRefetch, !changeManager.hasChanges else { return false }
@@ -208,7 +144,6 @@ internal final class StructureEditingSession: ObservableObject {
         return true
     }
 
-    /// Every sub-tab is fetched again from here, which answers an owed change too.
     internal func markEveryTabStale() {
         tabData.markAllStale()
         owesRefetch = false
@@ -218,8 +153,6 @@ internal final class StructureEditingSession: ObservableObject {
         tableComment = tableComment.enteringLoad
     }
 
-    /// A saved comment is the loaded one from the moment the save lands, so a refetch that fails
-    /// afterwards keeps it rather than the text the save replaced.
     internal func adoptWrittenTableComment(from changes: [SchemaChange]) {
         for case .modifyTableComment(_, let new) in changes {
             tableComment = .loaded(new)
@@ -253,19 +186,22 @@ internal final class StructureEditingSession: ObservableObject {
         concurrentRefresh = concurrentRefresh.settled(by: outcome, discardingValue: true)
     }
 
-    /// Breaks the cycle the mounted view's wiring creates.
-    ///
-    /// `TableStructureView.onAppear` installs closures on `gridDelegate`, and each captures the view
-    /// struct, which holds this session and the coordinator. So session owns delegate owns closure
-    /// owns session: dropping the session from `structureSessions` would not release it, its change
-    /// manager, or the connection it names. Called wherever a session is dropped, never from
-    /// `onDisappear`, because appearance is not lifetime.
+    // The mounted view installs closures that capture it, and it holds this session; called wherever a
+    // session is dropped, never from `onDisappear`.
     internal func releaseViewWiring() {
-        gridDelegate.onSelectedRowsChanged = nil
-        gridDelegate.sortHandler = nil
-        gridDelegate.moveRowHandler = nil
-        gridDelegate.currentProvider = nil
-        gridDelegate.coordinator = nil
+        gridAdapter.releaseViewWiring()
+    }
+}
+
+extension StructureEditingSession: ActiveGridModelProviding {
+    // The schema grid while a sub-tab shows one; Parts and Triggers draw lists of their own.
+    var activeGridModel: DataGridModel? {
+        switch selectedTab {
+        case .columns, .indexes, .foreignKeys, .checkConstraints:
+            return gridModel
+        case .ddl, .parts, .triggers:
+            return nil
+        }
     }
 }
 
@@ -275,7 +211,6 @@ internal struct StructureFooterCapability: Equatable {
     internal var addLabel = ""
     internal var removeLabel = ""
 
-    /// Why the pair is dimmed, for the tooltip. Empty when it is not.
     internal var unavailableReason: String?
 
     internal var isActive: Bool {
diff --git a/apple/TablePro/Views/Structure/StructureGridAdapter+Inspector.swift b/apple/TablePro/Views/Structure/StructureGridAdapter+Inspector.swift
new file mode 100644
index 0000000000..e2cf87bc85
--- /dev/null
+++ b/apple/TablePro/Views/Structure/StructureGridAdapter+Inspector.swift
@@ -0,0 +1,28 @@
+//
+//  StructureGridAdapter+Inspector.swift
+//  TablePro
+//
+
+import Foundation
+
+// The inspector names a row by its position in the grid, the same position the grid's selection uses.
+extension StructureGridAdapter: InspectorRowSource {
+    func inspectorRow(atDisplayRow displayRow: Int) -> InspectorRow? {
+        guard let rowID = model.rowID(at: displayRow),
+              let sourceIndex = StructureRowProvider.sourceIndex(of: rowID),
+              let providerRow = provider.displayRow(ofSourceIndex: sourceIndex) else { return nil }
+        return StructureInspectorRowBuilder.row(
+            atDisplayRow: providerRow,
+            tab: selectedTab,
+            provider: provider,
+            canEditSchema: canEdit,
+            lockedFieldIndices: lockedFieldIndices,
+            rowOptions: { menuOptions(sourceIndex: sourceIndex, field: $0) }
+        )
+    }
+
+    func commitInspectorField(displayRow: Int, fieldIndex: Int, value: String?) {
+        guard let rowID = model.rowID(at: displayRow) else { return }
+        applyEdit(rowID: rowID, field: fieldIndex, text: value ?? "")
+    }
+}
diff --git a/apple/TablePro/Views/Structure/StructureGridAdapter+Menus.swift b/apple/TablePro/Views/Structure/StructureGridAdapter+Menus.swift
new file mode 100644
index 0000000000..2e2db334ba
--- /dev/null
+++ b/apple/TablePro/Views/Structure/StructureGridAdapter+Menus.swift
@@ -0,0 +1,299 @@
+//
+//  StructureGridAdapter+Menus.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+extension StructureGridAdapter {
+    // The grid adds Copy, Duplicate, Delete and Undo Delete from its commands; these are the schema's own.
+    // The copies act on every targeted row, Open and the moves on the clicked one; nil when that is not known.
+    func structureRowMenuItems(for rowIDs: [RowID], clickedRow: RowID?) -> [NSMenuItem] {
+        guard showsGrid, !rowIDs.isEmpty else { return [] }
+        let indices = sourceIndices(of: rowIDs)
+        let tab = selectedTab
+        let clicked = clickedRow.flatMap(StructureRowProvider.sourceIndex(of:))
+        if let clicked, structureChangeManager.deleteInsertState(for: clicked, tab: tab).isDeleted {
+            return []
+        }
+
+        var items = [
+            menuItem(String(localized: "Copy Name")) { [weak self] in self?.copyNames(indices) },
+            menuItem(String(localized: "Copy Definition")) { [weak self] in self?.copyDefinitions(indices) },
+            copyAsItem(indices),
+        ]
+
+        if tab == .foreignKeys, let clicked, structureChangeManager.workingForeignKeys.indices.contains(clicked) {
+            let referenced = structureChangeManager.workingForeignKeys[clicked].referencedTable
+            if !referenced.isEmpty {
+                items.append(.separator())
+                items.append(menuItem(String(format: String(localized: "Open %@"), referenced)) { [weak self] in
+                    self?.navigateToForeignKey(sourceIndex: clicked)
+                })
+            }
+        }
+
+        let moves = columnMoveItems(movingRow: clicked)
+        if !moves.isEmpty {
+            items.append(.separator())
+            items.append(contentsOf: moves)
+        }
+        return items
+    }
+
+    // Moving by menu gives the keyboard and VoiceOver the reorder a drag gives the pointer.
+    private func columnMoveItems(movingRow row: Int?) -> [NSMenuItem] {
+        guard selectedTab == .columns else { return [] }
+        let reorder = model.configuration.rowReorder
+        guard reorder.isEnabled || reorder.unavailableReason != nil else { return [] }
+        let count = structureChangeManager.workingColumns.count
+        var items = [
+            columnMoveItem(String(localized: "Move Column Up"), row: row, .up, count: count, isEnabled: reorder.isEnabled),
+            columnMoveItem(String(localized: "Move Column Down"), row: row, .down, count: count, isEnabled: reorder.isEnabled),
+        ]
+        guard let reason = reorder.unavailableReason else { return items }
+        let explanation = NSMenuItem(title: reason, action: nil, keyEquivalent: "")
+        explanation.isEnabled = false
+        items.append(explanation)
+        return items
+    }
+
+    private func columnMoveItem(
+        _ title: String,
+        row: Int?,
+        _ direction: ColumnMove.Direction,
+        count: Int,
+        isEnabled: Bool
+    ) -> NSMenuItem {
+        guard isEnabled, let row, ColumnMove.isPossible(movingRow: row, direction, columnCount: count) else {
+            return NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        }
+        return menuItem(title) { [weak self] in
+            self?.moveRowHandler?(row, ColumnMove.dropIndex(movingRow: row, direction))
+        }
+    }
+
+    private func copyAsItem(_ indices: [Int]) -> NSMenuItem {
+        let submenu = NSMenu()
+        submenu.addItem(menuItem("CSV") { [weak self] in self?.copyAsCSV(indices) })
+        submenu.addItem(menuItem("JSON") { [weak self] in self?.copyAsJSON(indices) })
+        submenu.addItem(menuItem("SQL") { [weak self] in self?.copyDefinitions(indices) })
+        let item = NSMenuItem(title: String(localized: "Copy As"), action: nil, keyEquivalent: "")
+        item.submenu = submenu
+        return item
+    }
+
+    func makeEmptySpaceMenu() -> NSMenu? {
+        guard showsGrid, editGate.canEditSchema else { return nil }
+        let label: String
+        switch selectedTab {
+        case .columns:
+            guard editGate.allows(.addColumn) else { return nil }
+            label = String(localized: "Add Column")
+        case .indexes:
+            guard editGate.allows(.addIndex) else { return nil }
+            label = String(localized: "Add Index")
+        case .foreignKeys:
+            guard canEditForeignKeys else { return nil }
+            label = String(localized: "Add Foreign Key")
+        case .checkConstraints:
+            guard editGate.allows(.addCheckConstraint) else { return nil }
+            label = String(localized: "Add Check Constraint")
+        case .ddl, .parts, .triggers:
+            return nil
+        }
+        let menu = NSMenu()
+        menu.addItem(menuItem(label) { [weak self] in self?.addRow() })
+        return menu
+    }
+
+    private func menuItem(_ title: String, action: @escaping () -> Void) -> NSMenuItem {
+        let target = StructureMenuTarget(action: action)
+        let item = NSMenuItem(title: title, action: #selector(StructureMenuTarget.runAction), keyEquivalent: "")
+        item.target = target
+        item.representedObject = target
+        return item
+    }
+
+    // MARK: - Copy
+
+    private func unsortedProvider(includingPrimaryKey: Bool) -> StructureRowProvider {
+        StructureRowProvider(
+            changeManager: structureChangeManager,
+            tab: selectedTab,
+            databaseType: connection.type,
+            additionalFields: includingPrimaryKey ? [.primaryKey] : [],
+            serverSupport: session?.serverSupport ?? .unrestricted
+        )
+    }
+
+    func copyNames(_ indices: [Int]) {
+        let provider = unsortedProvider(includingPrimaryKey: false)
+        let names = indices.sorted().compactMap { provider.row(at: $0)?.first ?? nil }
+        guard !names.isEmpty else { return }
+        ClipboardService.shared.writeText(names.joined(separator: "\n"))
+    }
+
+    func copyDefinitions(_ indices: [Int]) {
+        guard let driver = DatabaseManager.shared.driver(for: connection.id) else { return }
+        var definitions: [String] = []
+        for index in indices.sorted() {
+            switch selectedTab {
+            case .columns:
+                guard structureChangeManager.workingColumns.indices.contains(index),
+                      let sql = driver.generateColumnDefinitionSQL(column: structureChangeManager.workingColumns[index].toPlugin())
+                else { continue }
+                definitions.append(sql)
+            case .indexes:
+                guard structureChangeManager.workingIndexes.indices.contains(index),
+                      let sql = driver.generateIndexDefinitionSQL(
+                          index: structureChangeManager.workingIndexes[index].toPlugin(), tableName: tableName
+                      )
+                else { continue }
+                definitions.append(sql)
+            case .foreignKeys:
+                guard structureChangeManager.workingForeignKeys.indices.contains(index),
+                      let sql = driver.generateForeignKeyDefinitionSQL(fk: structureChangeManager.workingForeignKeys[index].toPlugin())
+                else { continue }
+                definitions.append(sql)
+            case .checkConstraints:
+                guard structureChangeManager.workingCheckConstraints.indices.contains(index) else { continue }
+                let constraint = structureChangeManager.workingCheckConstraints[index]
+                definitions.append("CONSTRAINT \(driver.quoteIdentifier(constraint.name)) CHECK (\(constraint.expression))")
+            case .ddl, .parts, .triggers:
+                break
+            }
+        }
+        guard !definitions.isEmpty else { return }
+        ClipboardService.shared.writeText(definitions.joined(separator: "\n"))
+    }
+
+    func copyAsCSV(_ indices: [Int]) {
+        let provider = unsortedProvider(includingPrimaryKey: true)
+        let headers = provider.columns
+        guard !headers.isEmpty else { return }
+        var lines = [headers.map(CsvRowConverter.encode).joined(separator: ",")]
+        for index in indices.sorted() {
+            guard let row = provider.row(at: index) else { continue }
+            lines.append(row.map { CsvRowConverter.encode($0 ?? "") }.joined(separator: ","))
+        }
+        ClipboardService.shared.writeText(lines.joined(separator: "\n"))
+    }
+
+    func copyAsJSON(_ indices: [Int]) {
+        let provider = unsortedProvider(includingPrimaryKey: true)
+        let headers = provider.columns
+        guard !headers.isEmpty else { return }
+        var objects: [[String: String]] = []
+        for index in indices.sorted() {
+            guard let row = provider.row(at: index) else { continue }
+            var object: [String: String] = [:]
+            for (position, header) in headers.enumerated() where position < row.count {
+                object[header] = row[position] ?? ""
+            }
+            objects.append(object)
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: objects, options: [.prettyPrinted, .sortedKeys]),
+              let json = String(data: data, encoding: .utf8) else { return }
+        ClipboardService.shared.writeText(json)
+    }
+
+    // The grid's own Copy reaches the definitions too, so a paste in this tab stages them again.
+    func gridCopyRows(_ rowIDs: [RowID]) -> Bool {
+        guard showsGrid, !rowIDs.isEmpty else { return false }
+        copyRows(rowIDs)
+        return true
+    }
+
+    // The definitions ride on the structure pasteboard type, so Paste can stage them again.
+    func copyRows(_ rowIDs: [RowID]) {
+        guard showsGrid, !rowIDs.isEmpty else { return }
+        let ordered = rowIDs.sorted { (model.displayIndex(of: $0) ?? .max) < (model.displayIndex(of: $1) ?? .max) }
+        let indices = sourceIndices(of: ordered)
+        let manager = structureChangeManager
+        let encoder = JSONEncoder()
+        let encoded: Data?
+        switch selectedTab {
+        case .columns:
+            encoded = try? encoder.encode(indices.sorted().compactMap { manager.workingColumns.indices.contains($0) ? manager.workingColumns[$0] : nil })
+        case .indexes:
+            encoded = try? encoder.encode(indices.sorted().compactMap { manager.workingIndexes.indices.contains($0) ? manager.workingIndexes[$0] : nil })
+        case .foreignKeys:
+            encoded = try? encoder.encode(indices.sorted().compactMap {
+                manager.workingForeignKeys.indices.contains($0) ? manager.workingForeignKeys[$0] : nil
+            })
+        case .checkConstraints:
+            encoded = try? encoder.encode(indices.sorted().compactMap {
+                manager.workingCheckConstraints.indices.contains($0) ? manager.workingCheckConstraints[$0] : nil
+            })
+        case .ddl, .parts, .triggers:
+            encoded = nil
+        }
+
+        let rows = model.rows
+        let lines = ordered.compactMap { rowID -> String? in
+            rows.row(withID: rowID)?.values.map { $0.asText ?? "NULL" }.joined(separator: "\t")
+        }
+
+        let item = NSPasteboardItem()
+        if let encoded, let json = String(data: encoded, encoding: .utf8) {
+            item.setString(json, forType: TableStructureView.structurePasteboardType)
+            item.setString(connection.type.rawValue, forType: TableStructureView.structureSourceTypePasteboardType)
+        }
+        if !lines.isEmpty {
+            item.setString(lines.joined(separator: "\n"), forType: .string)
+        }
+        guard !item.types.isEmpty else { return }
+        NSPasteboard.general.clearContents()
+        NSPasteboard.general.writeObjects([item])
+    }
+
+    func pasteRows() {
+        guard canStageAddForSelectedTab,
+              let data = NSPasteboard.general.data(forType: TableStructureView.structurePasteboardType) else { return }
+        let decoder = JSONDecoder()
+        let manager = structureChangeManager
+        switch selectedTab {
+        case .columns:
+            guard let columns = try? decoder.decode([EditableColumnDefinition].self, from: data) else { return }
+            for column in columns {
+                manager.addColumn(column.withNewIdentity())
+            }
+        case .indexes:
+            guard let indexes = try? decoder.decode([EditableIndexDefinition].self, from: data) else { return }
+            let source = NSPasteboard.general
+                .string(forType: TableStructureView.structureSourceTypePasteboardType)
+                .map(DatabaseType.init(rawValue:))
+            for index in indexes {
+                manager.addIndex(index.pasted(from: source, into: connection.type))
+            }
+        case .foreignKeys:
+            guard let foreignKeys = try? decoder.decode([EditableForeignKeyDefinition].self, from: data) else { return }
+            for foreignKey in foreignKeys {
+                manager.addForeignKey(foreignKey.withNewIdentity())
+            }
+        case .checkConstraints:
+            guard let constraints = try? decoder.decode([EditableCheckConstraintDefinition].self, from: data) else { return }
+            for constraint in constraints {
+                manager.addCheckConstraint(constraint.withNewIdentity())
+            }
+        case .ddl, .parts, .triggers:
+            return
+        }
+        refresh()
+    }
+}
+
+// Held by the item's `representedObject`, so it outlives the menu that shows it.
+final class StructureMenuTarget: NSObject {
+    private let action: () -> Void
+
+    init(action: @escaping () -> Void) {
+        self.action = action
+    }
+
+    @objc func runAction() {
+        action()
+    }
+}
diff --git a/apple/TablePro/Views/Structure/StructureGridAdapter.swift b/apple/TablePro/Views/Structure/StructureGridAdapter.swift
new file mode 100644
index 0000000000..4363434788
--- /dev/null
+++ b/apple/TablePro/Views/Structure/StructureGridAdapter.swift
@@ -0,0 +1,482 @@
+//
+//  StructureGridAdapter.swift
+//  TablePro
+//
+
+import AppKit
+import TableProPluginKit
+
+// Feeds the Structure tab's grid from the session's working definitions and writes its edits back,
+// always by the definition a row names, never by where the row sits on screen.
+@MainActor
+final class StructureGridAdapter {
+    let model: DataGridModel
+    let store: StructureGridStateStore
+    let structureChangeManager: StructureChangeManager
+    let connection: DatabaseConnection
+    let tableName: String
+    let databaseName: String
+    let schemaName: String?
+    let objectKind: TableInfo.TableType
+    let isSessionBound: Bool
+    let referenceMenus: ForeignKeyReferenceMenus
+
+    weak var session: StructureEditingSession?
+    weak var coordinator: MainContentCoordinator?
+    // Installed by the mounted view while a column may be moved; it owns the reorder flow and its sheets.
+    var moveRowHandler: ((Int, Int) -> Void)?
+
+    private(set) var provider: StructureRowProvider
+    private var snapshot = StructureGridSnapshot()
+    private let changeTracking: StructureGridChangeState
+    private let changeState: AnyChangeManager
+
+    init(
+        structureChangeManager: StructureChangeManager,
+        connection: DatabaseConnection,
+        tableName: String,
+        databaseName: String,
+        schemaName: String?,
+        objectKind: TableInfo.TableType,
+        isSessionBound: Bool
+    ) {
+        self.structureChangeManager = structureChangeManager
+        self.connection = connection
+        self.tableName = tableName
+        self.databaseName = databaseName
+        self.schemaName = schemaName
+        self.objectKind = objectKind
+        self.isSessionBound = isSessionBound
+        let store = StructureGridStateStore()
+        self.store = store
+        self.model = DataGridModel(store: store)
+        self.referenceMenus = ForeignKeyReferenceMenus(connectionId: connection.id, databaseType: connection.type)
+        self.changeTracking = StructureGridChangeState(manager: structureChangeManager)
+        self.changeState = AnyChangeManager(changeTracking)
+        self.provider = StructureRowProvider(
+            changeManager: structureChangeManager,
+            tab: .columns,
+            databaseType: connection.type,
+            additionalFields: [.primaryKey],
+            serverSupport: .unrestricted
+        )
+        referenceMenus.schemaName = schemaName
+        // Read when a list lands, not captured: the view hands the coordinator over on every appearance.
+        referenceMenus.onListsChanged = { [weak self] in
+            self?.coordinator?.inspectorRowSourceRevision += 1
+        }
+        model.dataSource = self
+        model.actions = self
+    }
+
+    // MARK: - State
+
+    // The sub-tab whose rows the grid shows. The session's selection moves first and refresh() follows, so every
+    // write, menu and command reads this, never the incoming sub-tab (an open edit commits into the rows it was on).
+    var selectedTab: StructureTab { store.subTab }
+    private var serverSupport: StructureServerSupport { session?.serverSupport ?? .unrestricted }
+    private var searchText: String { session?.searchText ?? "" }
+    private var sortDescriptor: StructureSortDescriptor? { session?.sortDescriptor }
+
+    var editGate: StructureEditGate {
+        StructureEditGate(
+            databaseType: connection.type, objectKind: objectKind, schema: schemaName, isSessionBound: isSessionBound
+        )
+    }
+
+    var canEditForeignKeys: Bool {
+        editGate.allows(.addForeignKey)
+    }
+
+    var canStageAddForSelectedTab: Bool {
+        guard let adding = StructureFooterPolicy.operation(forAdding: selectedTab) else { return false }
+        return editGate.allows(adding)
+    }
+
+    var canStageRemoveForSelectedTab: Bool {
+        guard let removing = StructureFooterPolicy.operation(forRemoving: selectedTab) else { return false }
+        return editGate.allows(removing)
+    }
+
+    var canEdit: Bool {
+        editGate.allowsAnyEdit && !structureChangeManager.isHeldForSave
+    }
+
+    var lockedFieldIndices: Set<Int> {
+        editGate.lockedFieldIndices(
+            on: selectedTab,
+            orderedFields: provider.orderedColumnFields,
+            fieldCount: provider.columns.count
+        )
+    }
+
+    var editRefusal: String? {
+        if structureChangeManager.isHeldForSave { return StructureFooterPolicy.savingReason }
+        guard !editGate.allowsAnyEdit else { return nil }
+        return editGate.resolve(.renameColumn).unavailableReason
+    }
+
+    var columnReorderAvailability: ColumnReorderAvailability {
+        ColumnReorderPolicy.resolve(
+            support: PluginManager.shared.columnReorderSupport(for: connection.type),
+            engineName: connection.type.displayName,
+            isColumnsTab: selectedTab == .columns,
+            kindRefusal: editGate.kindRefusal(.reorderColumns),
+            canEditSchema: editGate.canEditSchema,
+            hasStagedChanges: structureChangeManager.hasChanges,
+            isRearranged: !searchText.isEmpty || sortDescriptor != nil || store.valueFilter.isActive
+        )
+    }
+
+    var showsGrid: Bool {
+        selectedTab != .ddl && selectedTab != .triggers && selectedTab != .parts
+    }
+
+    // MARK: - Refresh
+
+    // Called whenever the working definitions, the sub-tab, the search, the sort or the edit gate moved.
+    func refresh() {
+        let tab = session?.selectedTab ?? store.subTab
+        if store.subTab != tab {
+            model.commitEditing()
+            store.switchSubTab(to: tab)
+        }
+        changeTracking.tab = tab
+        changeTracking.rowCount = StructureGridEdits.rowCount(on: tab, manager: structureChangeManager)
+
+        let provider = StructureRowProvider(
+            changeManager: structureChangeManager,
+            tab: tab,
+            databaseType: connection.type,
+            additionalFields: [.primaryKey],
+            serverSupport: serverSupport,
+            filterText: searchText.isEmpty ? nil : searchText,
+            sortDescriptor: sortDescriptor
+        )
+        self.provider = provider
+        let rows = provider.asTableRows()
+        let states = rows.rows.map { row in
+            StructureGridEdits.visualState(
+                sourceIndex: StructureRowProvider.sourceIndex(of: row.id) ?? -1,
+                tab: tab,
+                manager: structureChangeManager,
+                orderedFields: provider.orderedColumnFields,
+                tintsModifiedFields: true
+            )
+        }
+        let wasEditable = model.configuration.isEditable
+        model.configuration = makeConfiguration(provider: provider)
+        let previous = snapshot
+        snapshot = StructureGridSnapshot(rows: rows, states: states)
+        model.applyHeldSnapshot(from: previous, to: snapshot)
+        // A save hold changes only the editability, and the inspector's fields have to follow it.
+        if previous.rows.rows != rows.rows || previous.states != states || previous.rows.columns != rows.columns
+            || wasEditable != model.configuration.isEditable {
+            coordinator?.inspectorRowSourceRevision += 1
+        }
+    }
+
+    private func makeConfiguration(provider: StructureRowProvider) -> DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        let options = provider.customDropdownOptions
+        configuration.dropdownColumns = provider.dropdownColumns
+        configuration.typePickerColumns = provider.typePickerColumns
+        configuration.customDropdownOptions = options.isEmpty ? nil : options
+        configuration.lockedColumns = lockedColumns(provider: provider)
+        configuration.editRefusalMessage = editRefusal
+        configuration.isEditable = canEdit
+        configuration.traits = DataGridEngineTraits(
+            databaseType: connection.type,
+            connectionScope: DatabaseScope(connectionId: connection.id, database: databaseName, schema: schemaName),
+            looksUpUserDefinedTypes: true
+        )
+        let reorder = columnReorderAvailability
+        configuration.rowReorder = DataGridRowReorder(
+            isEnabled: reorder.isAvailable,
+            unavailableReason: reorder.unavailableReason
+        )
+        configuration.commands = commands(reorderAvailable: reorder.isAvailable)
+        return configuration
+    }
+
+    private func commands(reorderAvailable: Bool) -> Set<DataGridCommand> {
+        var commands: Set<DataGridCommand> = [.valueFilter, .freezeColumns]
+        guard showsGrid, !structureChangeManager.isHeldForSave else { return commands }
+        if canStageAddForSelectedTab {
+            commands.formUnion([.addRow, .duplicateRows, .pasteRows])
+        }
+        if canStageRemoveForSelectedTab {
+            commands.formUnion([.deleteRows, .undoDelete])
+        }
+        if reorderAvailable {
+            commands.insert(.moveRows)
+        }
+        return commands
+    }
+
+    private func lockedColumns(provider: StructureRowProvider) -> Set<String> {
+        let headings = provider.columns
+        let locked = editGate.lockedFieldIndices(
+            on: selectedTab,
+            orderedFields: provider.orderedColumnFields,
+            fieldCount: headings.count
+        )
+        return Set(locked.compactMap { headings.indices.contains($0) ? headings[$0] : nil })
+    }
+
+    // MARK: - Rows
+
+    func sourceIndices(of rowIDs: [RowID]) -> [Int] {
+        rowIDs.compactMap(StructureRowProvider.sourceIndex(of:))
+    }
+
+    func menuOptions(sourceIndex: Int, field: Int) -> [GridMenuOption]? {
+        switch selectedTab {
+        case .indexes:
+            guard structureChangeManager.workingIndexes.indices.contains(sourceIndex) else { return nil }
+            return StructureRowProvider.indexMenuOptions(
+                columnIndex: field,
+                index: structureChangeManager.workingIndexes[sourceIndex],
+                serverSupport: serverSupport
+            )
+        case .foreignKeys:
+            guard canEditForeignKeys,
+                  structureChangeManager.workingForeignKeys.indices.contains(sourceIndex) else { return nil }
+            referenceMenus.origin = coordinator?.selectedTabScope
+            return referenceMenus.options(
+                columnIndex: field,
+                foreignKey: structureChangeManager.workingForeignKeys[sourceIndex],
+                tableColumns: structureChangeManager.workingColumns.map(\.name)
+            )
+        case .columns, .checkConstraints, .ddl, .parts, .triggers:
+            return nil
+        }
+    }
+
+    // MARK: - Commands
+
+    @discardableResult
+    func applyEdit(rowID: RowID, field: Int, text: String) -> Bool {
+        guard canEdit, let sourceIndex = StructureRowProvider.sourceIndex(of: rowID) else { return false }
+        let applied = write(text, field: field, sourceIndex: sourceIndex)
+        refresh()
+        return applied
+    }
+
+    private func write(_ text: String, field: Int, sourceIndex: Int) -> Bool {
+        let tab = selectedTab
+        guard field >= 0,
+              !editGate.locksField(at: field, on: tab, orderedFields: provider.orderedColumnFields),
+              !structureChangeManager.deleteInsertState(for: sourceIndex, tab: tab).isDeleted else { return false }
+        let changedReference = StructureGridEdits.apply(
+            text,
+            field: field,
+            sourceIndex: sourceIndex,
+            tab: tab,
+            manager: structureChangeManager,
+            orderedFields: provider.orderedColumnFields,
+            connection: connection
+        )
+        if let changedReference {
+            referenceMenus.origin = coordinator?.selectedTabScope
+            referenceMenus.prefetchReferencedColumns(
+                of: changedReference.referencedTable, schema: changedReference.referencedSchema
+            )
+        }
+        return true
+    }
+
+    func deleteRows(_ rowIDs: [RowID]) {
+        guard !rowIDs.isEmpty, showsGrid else {
+            model.clearSelection()
+            return
+        }
+        let allowed: Bool
+        switch selectedTab {
+        case .columns: allowed = editGate.allows(.dropColumn)
+        case .indexes: allowed = editGate.allows(.dropIndex)
+        case .foreignKeys: allowed = canEditForeignKeys
+        case .checkConstraints: allowed = editGate.allows(.dropCheckConstraint)
+        case .ddl, .parts, .triggers: allowed = false
+        }
+        guard allowed else { return }
+        let displayRows = IndexSet(rowIDs.compactMap { model.displayIndex(of: $0) })
+        let countBefore = model.rowCount
+        StructureGridEdits.delete(
+            sourceIndices: sourceIndices(of: rowIDs), tab: selectedTab, manager: structureChangeManager
+        )
+        refresh()
+        selectAfterDeleting(displayRows, countBefore: countBefore)
+    }
+
+    private func selectAfterDeleting(_ displayRows: IndexSet, countBefore: Int) {
+        let remaining = countBefore - displayRows.count
+        guard remaining > 0, let minRow = displayRows.first, let maxRow = displayRows.last else {
+            model.clearSelection()
+            return
+        }
+        let target = maxRow < remaining ? maxRow : (minRow > 0 ? minRow - 1 : 0)
+        guard let rowID = model.rowID(at: target) else {
+            model.clearSelection()
+            return
+        }
+        model.selectRows([rowID])
+    }
+
+    func addRow() {
+        guard canStageAddForSelectedTab else { return }
+        StructureGridEdits.addRow(on: selectedTab, manager: structureChangeManager)
+        refresh()
+    }
+
+    func duplicateRows(_ rowIDs: [RowID]) {
+        guard canStageAddForSelectedTab else { return }
+        StructureGridEdits.duplicate(
+            sourceIndices: sourceIndices(of: rowIDs), tab: selectedTab, manager: structureChangeManager
+        )
+        refresh()
+    }
+
+    func undoDelete(_ rowIDs: [RowID]) {
+        for index in sourceIndices(of: rowIDs) {
+            structureChangeManager.undoDelete(for: selectedTab, at: index)
+        }
+        refresh()
+    }
+
+    private var undoesStructureEdits: Bool {
+        selectedTab != .ddl && selectedTab != .triggers
+    }
+
+    // The comment bar shows on every sub-tab, so its step undoes even where no grid is on screen.
+    func undo() {
+        guard undoesStructureEdits || structureChangeManager.undoesTableCommentNext else { return }
+        model.commitEditing()
+        structureChangeManager.undo()
+        refresh()
+    }
+
+    func redo() {
+        guard undoesStructureEdits || structureChangeManager.redoesTableCommentNext else { return }
+        model.commitEditing()
+        structureChangeManager.redo()
+        refresh()
+    }
+
+    func navigateToForeignKey(sourceIndex: Int) {
+        guard structureChangeManager.workingForeignKeys.indices.contains(sourceIndex), let coordinator else { return }
+        let foreignKey = structureChangeManager.workingForeignKeys[sourceIndex]
+        guard let origin = coordinator.selectedTabScope else {
+            coordinator.openTableTab(foreignKey.referencedTable, schema: foreignKey.referencedSchema)
+            return
+        }
+        let target = ForeignKeyTargetScope.resolve(
+            origin: origin, referencedSchema: foreignKey.referencedSchema, databaseType: connection.type
+        )
+        coordinator.openTableTab(foreignKey.referencedTable, schema: target.schema, database: target.database)
+    }
+
+    func releaseViewWiring() {
+        moveRowHandler = nil
+        coordinator = nil
+    }
+}
+
+// MARK: - DataGridDataSource
+
+extension StructureGridAdapter: DataGridDataSource {
+    var gridRows: TableRows { snapshot.rows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridVisualState(for rowID: RowID) -> RowVisualState? {
+        snapshot.state(for: rowID)
+    }
+
+    func gridMenuOptions(for rowID: RowID, column: DataGridColumn) -> [GridMenuOption]? {
+        guard let sourceIndex = StructureRowProvider.sourceIndex(of: rowID) else { return nil }
+        return menuOptions(sourceIndex: sourceIndex, field: column.dataIndex)
+    }
+}
+
+// MARK: - DataGridActions
+
+extension StructureGridAdapter: DataGridActions {
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        guard canEdit, !edits.isEmpty else { return false }
+        var applied = false
+        let writeAll = {
+            for edit in edits {
+                guard let sourceIndex = StructureRowProvider.sourceIndex(of: edit.rowID) else { continue }
+                if self.write(edit.newValue.asText ?? "", field: edit.dataIndex, sourceIndex: sourceIndex) {
+                    applied = true
+                }
+            }
+        }
+        if edits.count > 1 {
+            structureChangeManager.performAsOneUndoStep(writeAll)
+        } else {
+            writeAll()
+        }
+        refresh()
+        return applied
+    }
+
+    func gridDeleteRows(_ rowIDs: [RowID]) {
+        deleteRows(rowIDs)
+    }
+
+    func gridUndoDelete(_ rowIDs: [RowID]) {
+        undoDelete(rowIDs)
+    }
+
+    func gridAddRow() {
+        addRow()
+    }
+
+    func gridDuplicateRows(_ rowIDs: [RowID]) {
+        duplicateRows(rowIDs)
+    }
+
+    func gridCanPasteRows() -> Bool {
+        canStageAddForSelectedTab && TableStructureView.canPasteStructureRows
+    }
+
+    func gridPasteRows() {
+        pasteRows()
+    }
+
+    // A move is offered only while nothing filters or sorts the list, so the drop index is a working index.
+    func gridMoveRow(from source: RowID, toDisplayIndex destination: Int) {
+        guard let sourceIndex = StructureRowProvider.sourceIndex(of: source) else { return }
+        moveRowHandler?(sourceIndex, destination)
+    }
+
+    // The provider sorts by one column, so a secondary key the header appended is dropped.
+    func gridSortDidChange(_ sort: SortState) {
+        guard let session else { return }
+        if let primary = sort.columns.first {
+            session.sortDescriptor = StructureSortDescriptor(
+                column: primary.columnIndex, ascending: primary.direction == .ascending
+            )
+            store.sortState = SortState(columns: [primary], source: .user)
+        } else {
+            session.sortDescriptor = nil
+            store.sortState = SortState(columns: [], source: .user)
+        }
+        refresh()
+    }
+
+    // A value filter rearranges the list, which withdraws the column move.
+    func gridConfirmDisplayOrderChange(then apply: @escaping @MainActor () -> Void) {
+        apply()
+        model.configuration = makeConfiguration(provider: provider)
+    }
+
+    func gridRowMenuItems(for rowIDs: [RowID], clickedRow: RowID) -> [NSMenuItem] {
+        structureRowMenuItems(for: rowIDs, clickedRow: clickedRow)
+    }
+
+    func gridEmptySpaceMenu() -> NSMenu? {
+        makeEmptySpaceMenu()
+    }
+}
diff --git a/apple/TablePro/Views/Structure/StructureGridDelegate+Inspector.swift b/apple/TablePro/Views/Structure/StructureGridDelegate+Inspector.swift
deleted file mode 100644
index 97768b3333..0000000000
--- a/apple/TablePro/Views/Structure/StructureGridDelegate+Inspector.swift
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-//  StructureGridDelegate+Inspector.swift
-//  TablePro
-//
-//  Supplies the right inspector with the selected structure row and routes
-//  its edits back through the same commit path as an inline grid edit.
-//
-
-import Foundation
-
-extension StructureGridDelegate: InspectorRowSource {
-    func inspectorRow(atDisplayRow displayRow: Int) -> InspectorRow? {
-        guard let provider = currentProvider else { return nil }
-        return StructureInspectorRowBuilder.row(
-            atDisplayRow: displayRow,
-            tab: selectedTab,
-            provider: provider,
-            canEditSchema: editGate.allowsAnyEdit && !structureChangeManager.isHeldForSave,
-            lockedFieldIndices: lockedFieldIndices,
-            rowOptions: { dataGridMenuOptions(forRow: displayRow, columnIndex: $0) }
-        )
-    }
-
-    func commitInspectorField(displayRow: Int, fieldIndex: Int, value: String?) {
-        dataGridDidEditCell(row: displayRow, column: fieldIndex, newValue: value)
-    }
-}
diff --git a/apple/TablePro/Views/Structure/StructureGridDelegate.swift b/apple/TablePro/Views/Structure/StructureGridDelegate.swift
deleted file mode 100644
index 1577cb3dc1..0000000000
--- a/apple/TablePro/Views/Structure/StructureGridDelegate.swift
+++ /dev/null
@@ -1,821 +0,0 @@
-//
-//  StructureGridDelegate.swift
-//  TablePro
-//
-//  DataGridViewDelegate implementation for TableStructureView and CreateTableView.
-//
-
-import AppKit
-import TableProPluginKit
-
-@MainActor
-final class StructureGridDelegate: DataGridViewDelegate {
-    let structureChangeManager: StructureChangeManager
-    var selectedTab: StructureTab
-    let connection: DatabaseConnection
-
-    /// What kind of object this grid is editing. The footer pair is not the only way in: the Edit
-    /// menu's Add Row, the grid's own shortcut, the row context menu and the empty-space menu all
-    /// reach the methods below directly, so each of them asks the same gate rather than trusting a
-    /// button to have been dimmed. (#2726)
-    let objectKind: TableInfo.TableType
-    var schemaName: String?
-    var isSessionBound = false
-
-    /// The single answer to "may this edit be offered", shared with the view that presents this grid.
-    var editGate: StructureEditGate {
-        StructureEditGate(
-            databaseType: connection.type, objectKind: objectKind, schema: schemaName, isSessionBound: isSessionBound
-        )
-    }
-
-    /// Whether this engine can add and remove foreign keys on this object, which is not the same
-    /// question as whether the engine has them. `supportsForeignKeys` answers the second, and reading
-    /// it as the first is what offered an enabled "+" on SQLite over a driver with no statement
-    /// behind it. Every path that stages a foreign key change reads this, not just the button under
-    /// the list: a context-menu Delete that stages one with no way to apply it only fails at Save.
-    var canEditForeignKeys: Bool {
-        editGate.allows(.addForeignKey)
-    }
-
-    /// Whether a new row may be staged on the list the user is looking at. Paste and Duplicate stage
-    /// the same add the "+" does, so they answer to the same gate rather than to the pasteboard alone.
-    var canStageAddForSelectedTab: Bool {
-        guard let adding = StructureFooterPolicy.operation(forAdding: selectedTab) else { return false }
-        return editGate.allows(adding)
-    }
-
-    var canStageRemoveForSelectedTab: Bool {
-        guard let removing = StructureFooterPolicy.operation(forRemoving: selectedTab) else { return false }
-        return editGate.allows(removing)
-    }
-
-    var lockedFieldIndices: Set<Int> {
-        editGate.lockedFieldIndices(
-            on: selectedTab,
-            orderedFields: orderedFields,
-            fieldCount: currentProvider?.columns.count ?? 0
-        )
-    }
-    let tableName: String
-    /// The lists behind the Foreign Keys grid's reference cells, shared with the Create Table tab.
-    let referenceMenus: ForeignKeyReferenceMenus
-    weak var coordinator: MainContentCoordinator?
-    var onSelectedRowsChanged: ((Set<Int>) -> Void)?
-
-    // Column reorder callback (set externally by the view when conditions allow)
-    var moveRowHandler: ((Int, Int) -> Void)?
-
-    /// Whether a column may be moved right now, and why not when it may not. Carried so the row's
-    /// contextual menu can offer the same reorder the drag offers, and name the same reason.
-    var columnReorder: DataGridRowReorder = .disabled
-
-    // Sort callback (set by TableStructureView to update its @State)
-    var sortHandler: ((Int, Bool) -> Void)?
-
-    // Current provider for index translation (set each render by the view)
-    var currentProvider: StructureRowProvider?
-
-    // Ordered fields for column editing (updated when currentProvider is set)
-    var orderedFields: [StructureColumnField] = []
-    var serverSupport = StructureServerSupport.unrestricted
-
-    // Stored when DataGridView calls `dataGridAttach(tableViewCoordinator:)` on
-    // every updateNSView. Lets us tell `NSTableView` which rows to reload after
-    // an edit / soft-delete / undo so the displayed cell value and visual-state
-    // tint stay in sync with the change manager. Without this, edits inside a
-    // row that does not change the row count never trigger `reloadData` because
-    // the SwiftUI re-render only invalidates layout-affecting properties.
-    private weak var attachedCoordinator: TableViewCoordinator?
-
-    init(
-        structureChangeManager: StructureChangeManager,
-        selectedTab: StructureTab,
-        connection: DatabaseConnection,
-        tableName: String,
-        objectKind: TableInfo.TableType = .table,
-        coordinator: MainContentCoordinator?
-    ) {
-        self.structureChangeManager = structureChangeManager
-        self.selectedTab = selectedTab
-        self.connection = connection
-        self.tableName = tableName
-        self.objectKind = objectKind
-        self.coordinator = coordinator
-        self.referenceMenus = ForeignKeyReferenceMenus(
-            connectionId: connection.id, databaseType: connection.type
-        )
-        /// The inspector builds its reference pickers from the same menus the grid opens, once per
-        /// revision, so one built while a list was still loading offers only `Loading…` until the
-        /// revision moves. The coordinator is read when the list lands, not captured here, because
-        /// the view hands it over again on every appearance.
-        referenceMenus.onListsChanged = { [weak self] in
-            self?.coordinator?.inspectorRowSourceRevision += 1
-        }
-    }
-
-    // MARK: - Index Translation
-
-    private func sourceRow(for displayRow: Int) -> Int {
-        guard let provider = currentProvider,
-              provider.filteredToSourceMap.indices.contains(displayRow) else {
-            return displayRow
-        }
-        return provider.filteredToSourceMap[displayRow]
-    }
-
-    private func sourceRows(for displayRows: Set<Int>) -> Set<Int> {
-        Set(displayRows.map { sourceRow(for: $0) })
-    }
-
-    /// The Foreign Keys grid's Columns, Ref Table and Ref Columns cells offer the database's own
-    /// names, exactly as the Create Table tab does, and the Indexes grid's Type cell offers the
-    /// row's own type beside the known ones.
-    ///
-    /// `StructureRowProvider` marks those columns as carrying a chevron for every grid it serves, so
-    /// without this the chevron here would reach the data grid's boolean fallback and offer to write
-    /// `1` into Ref Table. The row is translated first: this grid filters and sorts, so a display
-    /// position is not an index into the working rows.
-    func dataGridMenuOptions(forRow row: Int, columnIndex: Int) -> [GridMenuOption]? {
-        if selectedTab == .indexes {
-            return indexMenuOptions(forSourceRow: sourceRow(for: row), columnIndex: columnIndex)
-        }
-        guard selectedTab == .foreignKeys, canEditForeignKeys else { return nil }
-        let sourceRowIndex = sourceRow(for: row)
-        guard sourceRowIndex >= 0, sourceRowIndex < structureChangeManager.workingForeignKeys.count else {
-            return nil
-        }
-        referenceMenus.origin = coordinator?.selectedTabScope
-        return referenceMenus.options(
-            columnIndex: columnIndex,
-            foreignKey: structureChangeManager.workingForeignKeys[sourceRowIndex],
-            tableColumns: structureChangeManager.workingColumns.map(\.name)
-        )
-    }
-
-    private func indexMenuOptions(forSourceRow sourceRowIndex: Int, columnIndex: Int) -> [GridMenuOption]? {
-        guard structureChangeManager.workingIndexes.indices.contains(sourceRowIndex) else { return nil }
-        return StructureRowProvider.indexMenuOptions(
-            columnIndex: columnIndex,
-            index: structureChangeManager.workingIndexes[sourceRowIndex],
-            serverSupport: serverSupport
-        )
-    }
-
-    // MARK: - DataGridViewDelegate
-
-    func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        attachedCoordinator = tableViewCoordinator
-    }
-
-    func dataGridDidEditCell(row displayRow: Int, column: Int, newValue: String?) {
-        guard column >= 0,
-              !editGate.locksField(at: column, on: selectedTab, orderedFields: orderedFields) else { return }
-        let sourceRowIndex = sourceRow(for: displayRow)
-
-        switch selectedTab {
-        case .columns:
-            guard sourceRowIndex < structureChangeManager.workingColumns.count else { return }
-            var col = structureChangeManager.workingColumns[sourceRowIndex]
-            StructureEditingSupport.updateColumn(&col, at: column, with: newValue ?? "", orderedFields: orderedFields)
-            structureChangeManager.updateColumn(id: col.id, with: col)
-
-        case .indexes:
-            guard sourceRowIndex < structureChangeManager.workingIndexes.count else { return }
-            var idx = structureChangeManager.workingIndexes[sourceRowIndex]
-            StructureEditingSupport.updateIndex(
-                &idx,
-                at: column,
-                with: newValue ?? "",
-                keys: StructureEditingSupport.indexKeyContext(for: structureChangeManager, on: connection)
-            )
-            structureChangeManager.updateIndex(id: idx.id, with: idx)
-
-        case .foreignKeys:
-            guard sourceRowIndex < structureChangeManager.workingForeignKeys.count else { return }
-            var fk = structureChangeManager.workingForeignKeys[sourceRowIndex]
-            StructureEditingSupport.updateForeignKey(&fk, at: column, with: newValue ?? "")
-            structureChangeManager.updateForeignKey(id: fk.id, with: fk)
-            if column == 2 {
-                referenceMenus.origin = coordinator?.selectedTabScope
-                referenceMenus.prefetchReferencedColumns(
-                    of: fk.referencedTable, schema: fk.referencedSchema
-                )
-            }
-
-        case .checkConstraints:
-            guard sourceRowIndex < structureChangeManager.workingCheckConstraints.count else { return }
-            var constraint = structureChangeManager.workingCheckConstraints[sourceRowIndex]
-            StructureEditingSupport.updateCheckConstraint(&constraint, at: column, with: newValue ?? "")
-            structureChangeManager.updateCheckConstraint(id: constraint.id, with: constraint)
-
-        case .ddl, .parts, .triggers:
-            break
-        }
-
-        // Standard NSTableView contract after a data-source mutation: tell the
-        // table view which row to redraw so the cell shows the new value AND
-        // the modified-row visual state tint takes effect. The SwiftUI re-render
-        // alone is not enough because `updateNSView` only triggers `reloadData`
-        // when the row count or column schema changes.
-        reloadDisplayRow(displayRow)
-    }
-
-    private func reloadDisplayRow(_ displayRow: Int) {
-        attachedCoordinator?.reloadRowAndState(at: displayRow)
-    }
-
-    /// Repaint every visible cell + row view from the current change-manager
-    /// state. `TableStructureView` calls this after save/discard, since those
-    /// reset working state outside the delegate without changing row count, so
-    /// `DataGridView.updateNSView` would otherwise leave cells and tints stale.
-    /// Forwards to the shared `TableViewCoordinator` primitive so data tab and
-    /// structure tab use the same Apple-blessed two-layer refresh
-    /// (`reloadData(forRowIndexes:)` + `enumerateAvailableRowViews`).
-    func reloadAllVisibleRows() {
-        attachedCoordinator?.reloadVisibleRowsAndStates()
-    }
-
-    func dataGridDeleteRows(_ rows: Set<Int>) {
-        let translated = sourceRows(for: rows)
-        let minRow = rows.min() ?? 0
-        let maxRow = rows.max() ?? 0
-
-        switch selectedTab {
-        case .columns:
-            guard editGate.allows(.dropColumn) else { return }
-            structureChangeManager.performAsOneUndoStep {
-                for row in translated.sorted(by: >) {
-                    guard row < structureChangeManager.workingColumns.count else { continue }
-                    let column = structureChangeManager.workingColumns[row]
-                    structureChangeManager.deleteColumn(id: column.id)
-                }
-            }
-        case .indexes:
-            guard editGate.allows(.dropIndex) else { return }
-            structureChangeManager.performAsOneUndoStep {
-                for row in translated.sorted(by: >) {
-                    guard row < structureChangeManager.workingIndexes.count else { continue }
-                    let index = structureChangeManager.workingIndexes[row]
-                    structureChangeManager.deleteIndex(id: index.id)
-                }
-            }
-        case .foreignKeys:
-            guard canEditForeignKeys else { return }
-            structureChangeManager.performAsOneUndoStep {
-                for row in translated.sorted(by: >) {
-                    guard row < structureChangeManager.workingForeignKeys.count else { continue }
-                    let fk = structureChangeManager.workingForeignKeys[row]
-                    structureChangeManager.deleteForeignKey(id: fk.id)
-                }
-            }
-        case .checkConstraints:
-            guard editGate.allows(.dropCheckConstraint) else { return }
-            structureChangeManager.performAsOneUndoStep {
-                for row in translated.sorted(by: >) {
-                    guard row < structureChangeManager.workingCheckConstraints.count else { continue }
-                    let constraint = structureChangeManager.workingCheckConstraints[row]
-                    structureChangeManager.deleteCheckConstraint(id: constraint.id)
-                }
-            }
-        case .parts, .ddl, .triggers:
-            onSelectedRowsChanged?([])
-            return
-        }
-
-        let displayCount = (currentProvider?.totalRowCount ?? 0) - rows.count
-        if displayCount > 0 {
-            if maxRow < displayCount {
-                onSelectedRowsChanged?([maxRow])
-            } else if minRow > 0 {
-                onSelectedRowsChanged?([minRow - 1])
-            } else {
-                onSelectedRowsChanged?([0])
-            }
-        } else {
-            onSelectedRowsChanged?([])
-        }
-
-        // Existing-column deletes leave the row in `workingColumns` and only
-        // mark it as `pendingChanges[.deleteColumn]`, so the row count is
-        // unchanged. Without a forced reload the row's deleted-state tint and
-        // text color never paint on the live row view.
-        reloadAllVisibleRows()
-    }
-
-    func dataGridCopyRows(_ indices: Set<Int>) {
-        guard selectedTab != .ddl, selectedTab != .parts, selectedTab != .triggers, !indices.isEmpty else { return }
-        let translated = sourceRows(for: indices)
-
-        var copiedItems: [Any] = []
-
-        switch selectedTab {
-        case .columns:
-            for row in translated.sorted() {
-                guard row < structureChangeManager.workingColumns.count else { continue }
-                copiedItems.append(structureChangeManager.workingColumns[row])
-            }
-        case .indexes:
-            for row in translated.sorted() {
-                guard row < structureChangeManager.workingIndexes.count else { continue }
-                copiedItems.append(structureChangeManager.workingIndexes[row])
-            }
-        case .foreignKeys:
-            for row in translated.sorted() {
-                guard row < structureChangeManager.workingForeignKeys.count else { continue }
-                copiedItems.append(structureChangeManager.workingForeignKeys[row])
-            }
-        case .checkConstraints:
-            for row in translated.sorted() {
-                guard row < structureChangeManager.workingCheckConstraints.count else { continue }
-                copiedItems.append(structureChangeManager.workingCheckConstraints[row])
-            }
-        case .ddl, .parts, .triggers:
-            break
-        }
-
-        guard !copiedItems.isEmpty else { return }
-
-        var jsonString: String?
-        if let columns = copiedItems as? [EditableColumnDefinition],
-           let encoded = try? JSONEncoder().encode(columns) {
-            jsonString = String(data: encoded, encoding: .utf8)
-        } else if let indexes = copiedItems as? [EditableIndexDefinition],
-                  let encoded = try? JSONEncoder().encode(indexes) {
-            jsonString = String(data: encoded, encoding: .utf8)
-        } else if let fks = copiedItems as? [EditableForeignKeyDefinition],
-                  let encoded = try? JSONEncoder().encode(fks) {
-            jsonString = String(data: encoded, encoding: .utf8)
-        } else if let constraints = copiedItems as? [EditableCheckConstraintDefinition],
-                  let encoded = try? JSONEncoder().encode(constraints) {
-            jsonString = String(data: encoded, encoding: .utf8)
-        }
-
-        let displayProvider = currentProvider ?? StructureRowProvider(
-            changeManager: structureChangeManager, tab: selectedTab, databaseType: connection.type,
-            serverSupport: serverSupport
-        )
-        var lines: [String] = []
-        for row in indices.sorted() {
-            guard let rowData = displayProvider.row(at: row) else { continue }
-            let line = rowData.map { $0 ?? "NULL" }.joined(separator: "\t")
-            lines.append(line)
-        }
-        let tsvString = lines.joined(separator: "\n")
-
-        let item = NSPasteboardItem()
-        if let json = jsonString {
-            item.setString(json, forType: TableStructureView.structurePasteboardType)
-            item.setString(connection.type.rawValue, forType: TableStructureView.structureSourceTypePasteboardType)
-        }
-        if !tsvString.isEmpty {
-            item.setString(tsvString, forType: .string)
-        }
-
-        let pasteboard = NSPasteboard.general
-        pasteboard.clearContents()
-        pasteboard.writeObjects([item])
-    }
-
-    func dataGridCanPasteRows() -> Bool {
-        TableStructureView.canPasteStructureRows
-    }
-
-    func dataGridPasteRows() {
-        guard canStageAddForSelectedTab else { return }
-        guard let data = NSPasteboard.general.data(forType: TableStructureView.structurePasteboardType),
-              let jsonString = String(data: data, encoding: .utf8) else {
-            return
-        }
-
-        let decoder = JSONDecoder()
-
-        switch selectedTab {
-        case .columns:
-            guard let columns = try? decoder.decode([EditableColumnDefinition].self, from: Data(jsonString.utf8)) else {
-                return
-            }
-            for item in columns {
-                structureChangeManager.addColumn(item.withNewIdentity())
-            }
-
-        case .indexes:
-            guard let indexes = try? decoder.decode([EditableIndexDefinition].self, from: Data(jsonString.utf8)) else {
-                return
-            }
-            let source = NSPasteboard.general
-                .string(forType: TableStructureView.structureSourceTypePasteboardType)
-                .map(DatabaseType.init(rawValue:))
-            for item in indexes {
-                structureChangeManager.addIndex(item.pasted(from: source, into: connection.type))
-            }
-
-        case .foreignKeys:
-            guard let fks = try? decoder.decode([EditableForeignKeyDefinition].self, from: Data(jsonString.utf8)) else {
-                return
-            }
-            for item in fks {
-                structureChangeManager.addForeignKey(item.withNewIdentity())
-            }
-
-        case .checkConstraints:
-            guard let constraints = try? decoder.decode(
-                [EditableCheckConstraintDefinition].self, from: Data(jsonString.utf8)
-            ) else {
-                return
-            }
-            for item in constraints {
-                structureChangeManager.addCheckConstraint(item.withNewIdentity())
-            }
-
-        case .ddl, .parts, .triggers:
-            break
-        }
-    }
-
-    /// The comment bar shows on every sub-tab, so its step undoes even where no grid is on screen.
-    func dataGridUndo() {
-        guard showsGrid || structureChangeManager.undoesTableCommentNext else { return }
-        structureChangeManager.undo()
-        // The `reloadVersion` re-render only invalidates the snapshot; the visible cells need a redraw.
-        reloadAllVisibleRows()
-    }
-
-    func dataGridRedo() {
-        guard showsGrid || structureChangeManager.redoesTableCommentNext else { return }
-        structureChangeManager.redo()
-        reloadAllVisibleRows()
-    }
-
-    private var showsGrid: Bool {
-        selectedTab != .ddl && selectedTab != .triggers
-    }
-
-    func dataGridAddRow() {
-        guard canStageAddForSelectedTab else { return }
-        switch selectedTab {
-        case .columns:
-            structureChangeManager.addNewColumn()
-        case .indexes:
-            structureChangeManager.addNewIndex()
-        case .foreignKeys:
-            structureChangeManager.addNewForeignKey()
-        case .checkConstraints:
-            structureChangeManager.addNewCheckConstraint()
-        case .ddl, .parts, .triggers:
-            break
-        }
-    }
-
-    func dataGridSortStateChanged(_ state: SortState) {
-        guard let primary = state.columns.first else {
-            sortHandler?(-1, true)
-            return
-        }
-        sortHandler?(primary.columnIndex, primary.direction == .ascending)
-    }
-
-    func dataGridMoveRow(from source: Int, to destination: Int) {
-        moveRowHandler?(source, destination)
-    }
-
-    func dataGridVisualState(forRow row: Int) -> RowVisualState? {
-        let src = sourceRow(for: row)
-        let (isDeleted, isInserted) = structureChangeManager.deleteInsertState(for: src, tab: selectedTab)
-        let modified = isDeleted || isInserted ? [] : modifiedColumns(at: src)
-        return RowVisualState(isDeleted: isDeleted, isInserted: isInserted, modifiedColumns: modified)
-    }
-
-    /// Diff the working entity against the original (`currentColumns` etc.) to
-    /// find which display columns the user actually edited. Returning a real
-    /// per-cell set lets the cell view tint only the touched cells, mirroring
-    /// the data tab's behavior, instead of flagging the whole row when one
-    /// field changed.
-    private func modifiedColumns(at sourceRow: Int) -> Set<Int> {
-        switch selectedTab {
-        case .columns:
-            guard sourceRow < structureChangeManager.workingColumns.count else { return [] }
-            let working = structureChangeManager.workingColumns[sourceRow]
-            guard let original = structureChangeManager.currentColumns.first(where: { $0.id == working.id }) else { return [] }
-            return StructureEditingSupport.columnModifiedIndices(
-                old: original, new: working, orderedFields: orderedFields
-            )
-        case .indexes:
-            guard sourceRow < structureChangeManager.workingIndexes.count else { return [] }
-            let working = structureChangeManager.workingIndexes[sourceRow]
-            guard let original = structureChangeManager.currentIndexes.first(where: { $0.id == working.id }) else { return [] }
-            return StructureEditingSupport.indexModifiedIndices(old: original, new: working)
-        case .foreignKeys:
-            guard sourceRow < structureChangeManager.workingForeignKeys.count else { return [] }
-            let working = structureChangeManager.workingForeignKeys[sourceRow]
-            guard let original = structureChangeManager.currentForeignKeys.first(where: { $0.id == working.id }) else { return [] }
-            return StructureEditingSupport.foreignKeyModifiedIndices(old: original, new: working)
-        case .checkConstraints:
-            guard sourceRow < structureChangeManager.workingCheckConstraints.count else { return [] }
-            let working = structureChangeManager.workingCheckConstraints[sourceRow]
-            guard let original = structureChangeManager.currentCheckConstraints
-                .first(where: { $0.id == working.id }) else { return [] }
-            return StructureEditingSupport.checkConstraintModifiedIndices(old: original, new: working)
-        case .ddl, .parts, .triggers:
-            return []
-        }
-    }
-
-    func dataGridRowView(for tableView: NSTableView, row: Int, coordinator: TableViewCoordinator) -> NSTableRowView? {
-        makeStructureRowView(tableView, row, coordinator)
-    }
-
-    func dataGridEmptySpaceMenu() -> NSMenu? {
-        makeEmptySpaceMenu()
-    }
-
-    // MARK: - Row View & Context Menu
-
-    private static let structureRowViewId = NSUserInterfaceItemIdentifier("StructureRowView")
-
-    private func makeStructureRowView(
-        _ tableView: NSTableView, _ row: Int, _ coordinator: TableViewCoordinator
-    ) -> NSTableRowView {
-        let rowView = (tableView.makeView(withIdentifier: Self.structureRowViewId, owner: nil)
-            as? StructureRowViewWithMenu) ?? StructureRowViewWithMenu()
-        rowView.identifier = Self.structureRowViewId
-        rowView.coordinator = coordinator
-        rowView.rowIndex = row
-        rowView.structureTab = selectedTab
-        rowView.canDuplicate = canStageAddForSelectedTab
-        rowView.canDelete = canStageRemoveForSelectedTab
-
-        let src = sourceRow(for: row)
-
-        if selectedTab == .foreignKeys, src < structureChangeManager.workingForeignKeys.count {
-            rowView.referencedTableName = structureChangeManager.workingForeignKeys[src].referencedTable
-        }
-
-        rowView.onCopyName = { [weak self] indices in
-            guard let self else { return }
-            self.handleCopyName(self.sourceRows(for: indices))
-        }
-        rowView.onCopyDefinition = { [weak self] indices in
-            guard let self else { return }
-            self.handleCopyDefinition(self.sourceRows(for: indices))
-        }
-        rowView.onCopyAsCSV = { [weak self] indices in
-            guard let self else { return }
-            self.handleCopyAsCSV(self.sourceRows(for: indices))
-        }
-        rowView.onCopyAsJSON = { [weak self] indices in
-            guard let self else { return }
-            self.handleCopyAsJSON(self.sourceRows(for: indices))
-        }
-        rowView.onNavigateFK = { [weak self] idx in
-            guard let self else { return }
-            self.handleNavigateToFK(self.sourceRow(for: idx))
-        }
-        rowView.onDuplicate = { [weak self] indices in
-            guard let self else { return }
-            self.handleDuplicateItems(self.sourceRows(for: indices))
-        }
-        rowView.onDelete = { [weak self] indices in self?.dataGridDeleteRows(indices) }
-        rowView.onUndoDelete = { [weak self] displayRow in
-            guard let self else { return }
-            let src = self.sourceRow(for: displayRow)
-            self.structureChangeManager.undoDelete(for: self.selectedTab, at: src)
-            self.attachedCoordinator?.reloadRowAndState(at: displayRow)
-        }
-        return rowView
-    }
-
-    /// Move Column Up and Move Column Down, for whichever of the grid's two contextual menus is
-    /// asking. Dragging is the usual way to move a column and it is also the only way that needs a
-    /// pointer; these give the same reorder to the keyboard and to VoiceOver, which reaches a menu
-    /// but cannot perform a drag.
-    ///
-    /// Built here rather than in the row view because a column row raises two different menus.
-    /// `KeyHandlingTableView.rightMouseDown` intercepts a click inside the selection and answers
-    /// from `DataGridRowView.contextMenu(for:)`, which is this method's caller; a click outside it
-    /// falls through to `StructureRowViewWithMenu.menu(for:)`, which asks for the same items. One
-    /// builder, so select-then-right-click and right-click-elsewhere cannot offer different
-    /// commands.
-    func dataGridRowStructureMenuItems(forRow displayRow: Int) -> [NSMenuItem] {
-        guard selectedTab == .columns else { return [] }
-        guard columnReorder.isEnabled || columnReorder.unavailableReason != nil else { return [] }
-
-        /// The working set, not the displayed rows: a reorder is withheld under a filter or a sort
-        /// precisely so that the two are the same list, and the plan names every column.
-        let count = structureChangeManager.workingColumns.count
-        var items = [
-            columnMoveItem(String(localized: "Move Column Up"), row: displayRow, .up, count: count),
-            columnMoveItem(String(localized: "Move Column Down"), row: displayRow, .down, count: count),
-        ]
-
-        /// Spelled out under the two dead commands rather than left to the help tag on the row
-        /// number. A menu the user opened because a drag did nothing is where the answer belongs.
-        guard let reason = columnReorder.unavailableReason else { return items }
-        let explanation = NSMenuItem(title: reason, action: nil, keyEquivalent: "")
-        explanation.isEnabled = false
-        items.append(explanation)
-        return items
-    }
-
-    /// A nil action is what disables the item: both menus autoenable, and neither the row view nor
-    /// this delegate is in the responder chain to answer `validateMenuItem(_:)` for itself. The
-    /// target is held by `representedObject` so it outlives the menu that is showing it.
-    private func columnMoveItem(
-        _ title: String,
-        row: Int,
-        _ direction: ColumnMove.Direction,
-        count: Int
-    ) -> NSMenuItem {
-        let isEnabled = columnReorder.isEnabled
-            && ColumnMove.isPossible(movingRow: row, direction, columnCount: count)
-        guard isEnabled else {
-            return NSMenuItem(title: title, action: nil, keyEquivalent: "")
-        }
-        let item = NSMenuItem(title: title, action: #selector(StructureMenuTarget.runAction), keyEquivalent: "")
-        let target = StructureMenuTarget { [weak self] in
-            self?.moveRowHandler?(row, ColumnMove.dropIndex(movingRow: row, direction))
-        }
-        item.target = target
-        item.representedObject = target
-        return item
-    }
-
-    private func makeEmptySpaceMenu() -> NSMenu? {
-        guard selectedTab != .ddl, selectedTab != .parts, selectedTab != .triggers else { return nil }
-        guard editGate.canEditSchema else { return nil }
-
-        let menu = NSMenu()
-        let label: String
-        switch selectedTab {
-        case .columns:
-            guard editGate.allows(.addColumn) else { return nil }
-            label = String(localized: "Add Column")
-        case .indexes:
-            guard editGate.allows(.addIndex) else { return nil }
-            label = String(localized: "Add Index")
-        case .foreignKeys:
-            guard canEditForeignKeys else { return nil }
-            label = String(localized: "Add Foreign Key")
-        case .checkConstraints:
-            guard editGate.allows(.addCheckConstraint) else { return nil }
-            label = String(localized: "Add Check Constraint")
-        case .ddl, .parts, .triggers:
-            return nil
-        }
-
-        let target = StructureMenuTarget { [weak self] in self?.dataGridAddRow() }
-        let item = NSMenuItem(title: label, action: #selector(StructureMenuTarget.runAction), keyEquivalent: "")
-        item.target = target
-        item.representedObject = target
-        menu.addItem(item)
-        return menu
-    }
-
-    // MARK: - Context Menu Helpers
-
-    private func handleCopyName(_ indices: Set<Int>) {
-        let provider = StructureRowProvider(
-            changeManager: structureChangeManager, tab: selectedTab, databaseType: connection.type,
-            serverSupport: serverSupport
-        )
-        let names = indices.sorted().compactMap { provider.row(at: $0)?.first ?? nil }
-        guard !names.isEmpty else { return }
-        NSPasteboard.general.clearContents()
-        NSPasteboard.general.setString(names.joined(separator: "\n"), forType: .string)
-    }
-
-    private func handleCopyDefinition(_ indices: Set<Int>) {
-        guard let driver = DatabaseManager.shared.driver(for: connection.id) else { return }
-        var definitions: [String] = []
-
-        for row in indices.sorted() {
-            switch selectedTab {
-            case .columns:
-                guard row < structureChangeManager.workingColumns.count else { continue }
-                let col = structureChangeManager.workingColumns[row]
-                if let sql = driver.generateColumnDefinitionSQL(column: col.toPlugin()) {
-                    definitions.append(sql)
-                }
-            case .indexes:
-                guard row < structureChangeManager.workingIndexes.count else { continue }
-                let idx = structureChangeManager.workingIndexes[row]
-                if let sql = driver.generateIndexDefinitionSQL(index: idx.toPlugin(), tableName: tableName) {
-                    definitions.append(sql)
-                }
-            case .foreignKeys:
-                guard row < structureChangeManager.workingForeignKeys.count else { continue }
-                let fk = structureChangeManager.workingForeignKeys[row]
-                if let sql = driver.generateForeignKeyDefinitionSQL(fk: fk.toPlugin()) {
-                    definitions.append(sql)
-                }
-            case .checkConstraints:
-                guard row < structureChangeManager.workingCheckConstraints.count else { continue }
-                let constraint = structureChangeManager.workingCheckConstraints[row]
-                let quoted = driver.quoteIdentifier(constraint.name)
-                definitions.append("CONSTRAINT \(quoted) CHECK (\(constraint.expression))")
-            case .ddl, .parts, .triggers:
-                break
-            }
-        }
-
-        guard !definitions.isEmpty else { return }
-        NSPasteboard.general.clearContents()
-        NSPasteboard.general.setString(definitions.joined(separator: "\n"), forType: .string)
-    }
-
-    // MARK: - Copy As CSV/JSON
-
-    private func handleCopyAsCSV(_ indices: Set<Int>) {
-        let provider = StructureRowProvider(
-            changeManager: structureChangeManager, tab: selectedTab,
-            databaseType: connection.type, additionalFields: [.primaryKey],
-            serverSupport: serverSupport
-        )
-        let headers = provider.columns
-        guard !headers.isEmpty else { return }
-
-        var lines: [String] = [headers.map(CsvRowConverter.encode).joined(separator: ",")]
-        for row in indices.sorted() {
-            guard let rowData = provider.row(at: row) else { continue }
-            let line = rowData.map { CsvRowConverter.encode($0 ?? "") }.joined(separator: ",")
-            lines.append(line)
-        }
-
-        NSPasteboard.general.clearContents()
-        NSPasteboard.general.setString(lines.joined(separator: "\n"), forType: .string)
-    }
-
-    private func handleCopyAsJSON(_ indices: Set<Int>) {
-        let provider = StructureRowProvider(
-            changeManager: structureChangeManager, tab: selectedTab,
-            databaseType: connection.type, additionalFields: [.primaryKey],
-            serverSupport: serverSupport
-        )
-        let headers = provider.columns
-        guard !headers.isEmpty else { return }
-
-        var objects: [[String: String]] = []
-        for row in indices.sorted() {
-            guard let rowData = provider.row(at: row) else { continue }
-            var obj: [String: String] = [:]
-            for (i, header) in headers.enumerated() where i < rowData.count {
-                obj[header] = rowData[i] ?? ""
-            }
-            objects.append(obj)
-        }
-
-        guard let data = try? JSONSerialization.data(
-            withJSONObject: objects,
-            options: [.prettyPrinted, .sortedKeys]
-        ), let jsonString = String(data: data, encoding: .utf8) else { return }
-
-        NSPasteboard.general.clearContents()
-        NSPasteboard.general.setString(jsonString, forType: .string)
-    }
-
-    private func handleDuplicateItems(_ indices: Set<Int>) {
-        guard canStageAddForSelectedTab else { return }
-        for row in indices.sorted() {
-            switch selectedTab {
-            case .columns:
-                guard row < structureChangeManager.workingColumns.count else { continue }
-                let copy = structureChangeManager.workingColumns[row]
-                structureChangeManager.addColumn(copy.withNewIdentity())
-            case .indexes:
-                guard row < structureChangeManager.workingIndexes.count else { continue }
-                var copy = structureChangeManager.workingIndexes[row].withNewIdentity()
-                copy.isPrimary = false
-                structureChangeManager.addIndex(copy)
-            case .foreignKeys:
-                guard row < structureChangeManager.workingForeignKeys.count else { continue }
-                let copy = structureChangeManager.workingForeignKeys[row]
-                structureChangeManager.addForeignKey(copy.withNewIdentity())
-            case .checkConstraints:
-                guard row < structureChangeManager.workingCheckConstraints.count else { continue }
-                let copy = structureChangeManager.workingCheckConstraints[row]
-                structureChangeManager.addCheckConstraint(copy.withNewIdentity())
-            case .ddl, .parts, .triggers:
-                break
-            }
-        }
-    }
-
-    /// The row names its target in whatever the engine's catalog calls a schema, which on an engine
-    /// with no schema layer is a database. Resolving it against the tab's own scope is what keeps
-    /// the tab this opens identical to the one the sidebar opens for the same table.
-    private func handleNavigateToFK(_ row: Int) {
-        guard row < structureChangeManager.workingForeignKeys.count else { return }
-        guard let coordinator else { return }
-        let fk = structureChangeManager.workingForeignKeys[row]
-        guard let origin = coordinator.selectedTabScope else {
-            coordinator.openTableTab(fk.referencedTable, schema: fk.referencedSchema)
-            return
-        }
-        let target = ForeignKeyTargetScope.resolve(
-            origin: origin, referencedSchema: fk.referencedSchema, databaseType: connection.type
-        )
-        coordinator.openTableTab(
-            fk.referencedTable, schema: target.schema, database: target.database
-        )
-    }
-}
diff --git a/apple/TablePro/Views/Structure/StructureGridStateStore.swift b/apple/TablePro/Views/Structure/StructureGridStateStore.swift
new file mode 100644
index 0000000000..26cc6933b1
--- /dev/null
+++ b/apple/TablePro/Views/Structure/StructureGridStateStore.swift
@@ -0,0 +1,57 @@
+//
+//  StructureGridStateStore.swift
+//  TablePro
+//
+
+import Foundation
+
+// The Structure grid's view state lives on the tab's session, one column layout per sub-tab, and never
+// reaches a table's saved layout.
+@MainActor
+final class StructureGridStateStore: DataGridStateStore {
+    weak var session: StructureEditingSession?
+    private(set) var subTab: StructureTab = .columns
+
+    var valueFilter = GridValueFilterState()
+    var displayFormats: [ValueDisplayFormat?] = []
+    var selectionSnapshot = GridSelectionSnapshot.empty
+    var viewportAnchor: GridViewportPlacement?
+    let layoutScope: DataGridLayoutScope = .ephemeral
+
+    private var detachedLayouts: [StructureTab: ColumnLayoutState] = [:]
+    private var detachedSort = SortState()
+
+    var sortState: SortState {
+        get { session?.sortState ?? detachedSort }
+        set {
+            guard let session else {
+                detachedSort = newValue
+                return
+            }
+            guard session.sortState != newValue else { return }
+            session.sortState = newValue
+        }
+    }
+
+    var columnLayout: ColumnLayoutState {
+        get { session?.columnLayouts[subTab] ?? detachedLayouts[subTab] ?? ColumnLayoutState() }
+        set {
+            guard let session else {
+                detachedLayouts[subTab] = newValue
+                return
+            }
+            guard session.columnLayouts[subTab] != newValue else { return }
+            session.columnLayouts[subTab] = newValue
+        }
+    }
+
+    // Search, sort, filter and selection start over on another sub-tab; the column layout is kept per sub-tab.
+    func switchSubTab(to tab: StructureTab) {
+        guard tab != subTab else { return }
+        subTab = tab
+        valueFilter = GridValueFilterState()
+        displayFormats = []
+        selectionSnapshot = .empty
+        viewportAnchor = nil
+    }
+}
diff --git a/apple/TablePro/Views/Structure/StructureGridSupport.swift b/apple/TablePro/Views/Structure/StructureGridSupport.swift
new file mode 100644
index 0000000000..51f46a0ce6
--- /dev/null
+++ b/apple/TablePro/Views/Structure/StructureGridSupport.swift
@@ -0,0 +1,266 @@
+//
+//  StructureGridSupport.swift
+//  TablePro
+//
+
+import Foundation
+import TableProPluginKit
+
+// What the Structure and Create Table grids share: writing a cell into the working definitions, the
+// row states the grid tints, and telling the model what changed.
+@MainActor
+enum StructureGridEdits {
+    static let referencedTableField = 2
+
+    @discardableResult
+    static func apply(
+        _ text: String,
+        field: Int,
+        sourceIndex: Int,
+        tab: StructureTab,
+        manager: StructureChangeManager,
+        orderedFields: [StructureColumnField],
+        connection: DatabaseConnection
+    ) -> EditableForeignKeyDefinition? {
+        switch tab {
+        case .columns:
+            guard manager.workingColumns.indices.contains(sourceIndex) else { return nil }
+            var column = manager.workingColumns[sourceIndex]
+            StructureEditingSupport.updateColumn(&column, at: field, with: text, orderedFields: orderedFields)
+            manager.updateColumn(id: column.id, with: column)
+        case .indexes:
+            guard manager.workingIndexes.indices.contains(sourceIndex) else { return nil }
+            var index = manager.workingIndexes[sourceIndex]
+            StructureEditingSupport.updateIndex(
+                &index,
+                at: field,
+                with: text,
+                keys: StructureEditingSupport.indexKeyContext(for: manager, on: connection)
+            )
+            manager.updateIndex(id: index.id, with: index)
+        case .foreignKeys:
+            guard manager.workingForeignKeys.indices.contains(sourceIndex) else { return nil }
+            var foreignKey = manager.workingForeignKeys[sourceIndex]
+            StructureEditingSupport.updateForeignKey(&foreignKey, at: field, with: text)
+            manager.updateForeignKey(id: foreignKey.id, with: foreignKey)
+            return field == referencedTableField ? foreignKey : nil
+        case .checkConstraints:
+            guard manager.workingCheckConstraints.indices.contains(sourceIndex) else { return nil }
+            var constraint = manager.workingCheckConstraints[sourceIndex]
+            StructureEditingSupport.updateCheckConstraint(&constraint, at: field, with: text)
+            manager.updateCheckConstraint(id: constraint.id, with: constraint)
+        case .ddl, .parts, .triggers:
+            break
+        }
+        return nil
+    }
+
+    // One Cmd+Z brings the whole selection back: the manager registers an undo per row.
+    static func delete(sourceIndices: [Int], tab: StructureTab, manager: StructureChangeManager) {
+        manager.performAsOneUndoStep {
+            for index in sourceIndices.sorted(by: >) {
+                switch tab {
+                case .columns:
+                    guard manager.workingColumns.indices.contains(index) else { continue }
+                    manager.deleteColumn(id: manager.workingColumns[index].id)
+                case .indexes:
+                    guard manager.workingIndexes.indices.contains(index) else { continue }
+                    manager.deleteIndex(id: manager.workingIndexes[index].id)
+                case .foreignKeys:
+                    guard manager.workingForeignKeys.indices.contains(index) else { continue }
+                    manager.deleteForeignKey(id: manager.workingForeignKeys[index].id)
+                case .checkConstraints:
+                    guard manager.workingCheckConstraints.indices.contains(index) else { continue }
+                    manager.deleteCheckConstraint(id: manager.workingCheckConstraints[index].id)
+                case .ddl, .parts, .triggers:
+                    break
+                }
+            }
+        }
+    }
+
+    static func duplicate(sourceIndices: [Int], tab: StructureTab, manager: StructureChangeManager) {
+        for index in sourceIndices.sorted() {
+            switch tab {
+            case .columns:
+                guard manager.workingColumns.indices.contains(index) else { continue }
+                manager.addColumn(manager.workingColumns[index].withNewIdentity())
+            case .indexes:
+                guard manager.workingIndexes.indices.contains(index) else { continue }
+                var copy = manager.workingIndexes[index].withNewIdentity()
+                copy.isPrimary = false
+                manager.addIndex(copy)
+            case .foreignKeys:
+                guard manager.workingForeignKeys.indices.contains(index) else { continue }
+                manager.addForeignKey(manager.workingForeignKeys[index].withNewIdentity())
+            case .checkConstraints:
+                guard manager.workingCheckConstraints.indices.contains(index) else { continue }
+                manager.addCheckConstraint(manager.workingCheckConstraints[index].withNewIdentity())
+            case .ddl, .parts, .triggers:
+                break
+            }
+        }
+    }
+
+    static func addRow(on tab: StructureTab, manager: StructureChangeManager) {
+        switch tab {
+        case .columns: manager.addNewColumn()
+        case .indexes: manager.addNewIndex()
+        case .foreignKeys: manager.addNewForeignKey()
+        case .checkConstraints: manager.addNewCheckConstraint()
+        case .ddl, .parts, .triggers: break
+        }
+    }
+
+    static func rowCount(on tab: StructureTab, manager: StructureChangeManager) -> Int {
+        switch tab {
+        case .columns: manager.workingColumns.count
+        case .indexes: manager.workingIndexes.count
+        case .foreignKeys: manager.workingForeignKeys.count
+        case .checkConstraints: manager.workingCheckConstraints.count
+        case .ddl, .parts, .triggers: 0
+        }
+    }
+
+    static func visualState(
+        sourceIndex: Int,
+        tab: StructureTab,
+        manager: StructureChangeManager,
+        orderedFields: [StructureColumnField],
+        tintsModifiedFields: Bool
+    ) -> RowVisualState {
+        guard sourceIndex >= 0 else { return .empty }
+        let (isDeleted, isInserted) = manager.deleteInsertState(for: sourceIndex, tab: tab)
+        guard tintsModifiedFields, !isDeleted, !isInserted else {
+            return RowVisualState(isDeleted: isDeleted, isInserted: isInserted, modifiedColumns: [])
+        }
+        return RowVisualState(
+            isDeleted: false,
+            isInserted: false,
+            modifiedColumns: modifiedFields(sourceIndex: sourceIndex, tab: tab, manager: manager, orderedFields: orderedFields)
+        )
+    }
+
+    private static func modifiedFields(
+        sourceIndex: Int,
+        tab: StructureTab,
+        manager: StructureChangeManager,
+        orderedFields: [StructureColumnField]
+    ) -> Set<Int> {
+        switch tab {
+        case .columns:
+            guard manager.workingColumns.indices.contains(sourceIndex) else { return [] }
+            let working = manager.workingColumns[sourceIndex]
+            guard let original = manager.currentColumns.first(where: { $0.id == working.id }) else { return [] }
+            return StructureEditingSupport.columnModifiedIndices(old: original, new: working, orderedFields: orderedFields)
+        case .indexes:
+            guard manager.workingIndexes.indices.contains(sourceIndex) else { return [] }
+            let working = manager.workingIndexes[sourceIndex]
+            guard let original = manager.currentIndexes.first(where: { $0.id == working.id }) else { return [] }
+            return StructureEditingSupport.indexModifiedIndices(old: original, new: working)
+        case .foreignKeys:
+            guard manager.workingForeignKeys.indices.contains(sourceIndex) else { return [] }
+            let working = manager.workingForeignKeys[sourceIndex]
+            guard let original = manager.currentForeignKeys.first(where: { $0.id == working.id }) else { return [] }
+            return StructureEditingSupport.foreignKeyModifiedIndices(old: original, new: working)
+        case .checkConstraints:
+            guard manager.workingCheckConstraints.indices.contains(sourceIndex) else { return [] }
+            let working = manager.workingCheckConstraints[sourceIndex]
+            guard let original = manager.currentCheckConstraints.first(where: { $0.id == working.id }) else { return [] }
+            return StructureEditingSupport.checkConstraintModifiedIndices(old: original, new: working)
+        case .ddl, .parts, .triggers:
+            return []
+        }
+    }
+}
+
+// The schema manager has no row identities of its own; this answers the grid's row questions by the
+// source-index RowIDs `StructureRowProvider` hands out.
+@MainActor
+final class StructureGridChangeState: ChangeManaging {
+    let manager: StructureChangeManager
+    var tab: StructureTab
+    var rowCount: Int = 0
+
+    init(manager: StructureChangeManager, tab: StructureTab = .columns) {
+        self.manager = manager
+        self.tab = tab
+    }
+
+    var hasChanges: Bool { manager.hasChanges }
+    var reloadVersion: Int { manager.reloadVersion }
+    var canRedo: Bool { manager.canRedo }
+    var rowChanges: [RowChange] { [] }
+
+    var insertedRowIDs: Set<RowID> {
+        Set((0..<rowCount).filter { manager.deleteInsertState(for: $0, tab: tab).isInserted }
+            .map(StructureRowProvider.rowID(forSourceIndex:)))
+    }
+
+    var deletedRowIDs: Set<RowID> {
+        Set((0..<rowCount).filter { manager.deleteInsertState(for: $0, tab: tab).isDeleted }
+            .map(StructureRowProvider.rowID(forSourceIndex:)))
+    }
+
+    func isRowDeleted(_ rowID: RowID) -> Bool {
+        guard let index = StructureRowProvider.sourceIndex(of: rowID), index >= 0 else { return false }
+        return manager.deleteInsertState(for: index, tab: tab).isDeleted
+    }
+
+    func recordCellChange(
+        rowID: RowID,
+        columnIndex: Int,
+        columnName: String,
+        oldValue: PluginCellValue,
+        newValue: PluginCellValue,
+        originalRow: [PluginCellValue]?
+    ) {}
+
+    func undoRowDeletion(rowID: RowID) {
+        guard let index = StructureRowProvider.sourceIndex(of: rowID) else { return }
+        manager.undoDelete(for: tab, at: index)
+    }
+}
+
+// The rows and row states one Structure or Create Table refresh produced.
+struct StructureGridSnapshot {
+    var rows = TableRows()
+    var states: [RowVisualState] = []
+
+    func state(for rowID: RowID) -> RowVisualState? {
+        guard let index = rows.index(of: rowID), states.indices.contains(index) else { return nil }
+        return states[index]
+    }
+
+    // Nil when the change needs a reload: other rows, other columns, or a row turning inserted or deleted.
+    func changedCells(to next: StructureGridSnapshot) -> Set<CellPosition>? {
+        guard rows.columns == next.rows.columns, rows.rows.count == next.rows.rows.count else { return nil }
+        var changed: Set<CellPosition> = []
+        for index in rows.rows.indices {
+            let before = rows.rows[index]
+            let after = next.rows.rows[index]
+            guard before.id == after.id else { return nil }
+            let oldState = states.indices.contains(index) ? states[index] : .empty
+            let newState = next.states.indices.contains(index) ? next.states[index] : .empty
+            guard oldState.isDeleted == newState.isDeleted, oldState.isInserted == newState.isInserted else { return nil }
+            for column in 0..<max(before.values.count, after.values.count)
+            where before[column] != after[column]
+                || oldState.isModified(columnIndex: column) != newState.isModified(columnIndex: column) {
+                changed.insert(CellPosition(row: index, column: column))
+            }
+        }
+        return changed
+    }
+}
+
+extension DataGridModel {
+    // An owner that rebuilds whole rows reports them here; the model reloads only when it must.
+    func applyHeldSnapshot(from previous: StructureGridSnapshot, to current: StructureGridSnapshot) {
+        guard let cells = previous.changedCells(to: current) else {
+            reloadHeldRows(columnsChanged: previous.rows.columns != current.rows.columns || columns.isEmpty)
+            return
+        }
+        guard !cells.isEmpty else { return }
+        apply(.cellsChanged(cells))
+    }
+}
diff --git a/apple/TablePro/Views/Structure/StructureListGrid.swift b/apple/TablePro/Views/Structure/StructureListGrid.swift
index 3f199c06ce..45f398f295 100644
--- a/apple/TablePro/Views/Structure/StructureListGrid.swift
+++ b/apple/TablePro/Views/Structure/StructureListGrid.swift
@@ -11,13 +11,13 @@ import TableProPluginKit
 internal struct StructureListRow<ID: Hashable>: Hashable {
     internal let id: ID
     internal let values: [String]
-    /// Keyed by column, for a cell whose drawn text reads wrong aloud, such as YES for Enabled.
+    // Keyed by column, for a cell whose drawn text reads wrong aloud, such as YES for Enabled.
     internal var spokenValues: [Int: String] = [:]
     internal var tones: [Int: StructureListTone] = [:]
 }
 
-/// A status hue on one cell's text. Status hues stay system under every theme, and the text still
-/// turns to the selection text on an emphasized selection, like the rest of the row.
+// Status hues stay system under every theme, and the text still turns to the selection text on an
+// emphasized selection, like the rest of the row.
 internal enum StructureListTone: Hashable {
     case positive
     case caution
@@ -34,139 +34,171 @@ internal enum StructureListTone: Hashable {
     }
 }
 
-/// Selected row ids held by reference: a read made during a SwiftUI update gets a `State` or `Binding` snapshot.
 @MainActor
 internal final class StructureListSelection<ID: Hashable>: ObservableObject {
     @Published internal var ids: Set<ID> = []
 }
 
-/// A read-only Structure list drawn by `DataGridView`. Its configuration names only the database type,
-/// so `columnLayoutKey` stays nil and the list never writes into the table's saved column widths.
+// The grid behind a read-only Structure or dashboard list. Each list row keeps one RowID for as long as
+// its id is listed, so a refresh or a sort keeps the selection on the same record.
 @MainActor
-internal final class StructureListGridModel<ID: Hashable>: ObservableObject, DataGridViewDelegate {
-    internal let changeManager = AnyChangeManager(DataChangeManager())
-    internal var onSortStateChanged: ((SortState) -> Void)?
-    private let accessibilityLabel: String?
+internal final class StructureListGridModel<ID: Hashable>: ObservableObject {
+    internal let grid = HeldRowsGridAdapter(configuration: DataGridConfiguration())
+    internal var onSelect: ((Set<ID>) -> Void)?
 
-    internal private(set) var tableRows = TableRows()
     internal private(set) var rowIDs: [ID] = []
-    private var spokenValues: [[Int: String]] = []
-    private var tones: [[Int: StructureListTone]] = []
-    private var loadedKey: Int?
-    private weak var coordinator: TableViewCoordinator?
+    private var rowIDByID: [ID: RowID] = [:]
+    private var idByRowID: [RowID: ID] = [:]
+    private var nextRowNumber = 0
+    private var loadedColumns: [String]?
+    private var loadedRows: [StructureListRow<ID>]?
+    private var syncedIDs: Set<ID> = []
+    private let accessibilityLabel: String?
 
     internal init(accessibilityLabel: String? = nil) {
         self.accessibilityLabel = accessibilityLabel
+        grid.onSelectionChange = { [weak self] rowIDs in
+            self?.gridSelectionDidChange(rowIDs)
+        }
     }
 
-    internal func ensureLoaded(key: Int, columns: [String], rows: () -> [StructureListRow<ID>]) -> TableRows {
-        var hasher = Hasher()
-        hasher.combine(key)
-        hasher.combine(columns)
-        let combined = hasher.finalize()
-        guard loadedKey != combined else { return tableRows }
-        loadedKey = combined
+    internal var model: DataGridModel { grid.model }
+    internal var tableRows: TableRows { grid.heldRows }
 
-        let listed = rows()
+    internal func load(
+        columns: [String],
+        rows: [StructureListRow<ID>],
+        defaultWidths: [CGFloat],
+        minimumWidths: [CGFloat],
+        databaseType: DatabaseType,
+        sortState: SortState?
+    ) {
+        var configuration = Self.configuration(
+            columns: columns,
+            minimumWidths: minimumWidths,
+            databaseType: databaseType,
+            sorts: sortState != nil
+        )
+        configuration.accessibilityLabel = accessibilityLabel
+        grid.model.configuration = configuration
+        if let sortState {
+            grid.model.store.sortState = sortState
+        }
+        guard loadedColumns != columns || loadedRows != rows else { return }
+        if loadedColumns != columns {
+            grid.model.store.columnLayout = StructureListGrid<ID>.layout(
+                grid.model.store.columnLayout, columns: columns, defaultWidths: defaultWidths
+            )
+        }
+        loadedColumns = columns
+        loadedRows = rows
+        grid.setRows(makeTableRows(for: rows, columns: columns))
+    }
+
+    private static func configuration(
+        columns: [String],
+        minimumWidths: [CGFloat],
+        databaseType: DatabaseType,
+        sorts: Bool
+    ) -> DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.traits = DataGridEngineTraits(databaseType: databaseType)
+        configuration.supportsValueFilter = false
+        configuration.appliesRowCopyFormat = true
+        configuration.supportsColumnSort = sorts
+        configuration.columnMinimumWidths = StructureListGrid<ID>.minimumWidths(minimumWidths, columns: columns)
+        configuration.commands = [.freezeColumns]
+        return configuration
+    }
+
+    private func makeTableRows(for listed: [StructureListRow<ID>], columns: [String]) -> TableRows {
+        var keptRowIDs: [ID: RowID] = [:]
+        var rows = ContiguousArray<Row>()
+        rows.reserveCapacity(listed.count)
+        var tones: [RowID: [Int: NSColor]] = [:]
+        var spoken: [RowID: [Int: String]] = [:]
+        for row in listed {
+            let rowID: RowID
+            if keptRowIDs[row.id] == nil {
+                rowID = rowIDByID[row.id] ?? mintRowID()
+                keptRowIDs[row.id] = rowID
+            } else {
+                rowID = mintRowID()
+            }
+            var values = ContiguousArray(row.values.prefix(columns.count).map(PluginCellValue.text))
+            while values.count < columns.count {
+                values.append(.text(""))
+            }
+            rows.append(Row(id: rowID, values: values))
+            if !row.tones.isEmpty {
+                tones[rowID] = row.tones.mapValues(\.color)
+            }
+            if !row.spokenValues.isEmpty {
+                spoken[rowID] = row.spokenValues
+            }
+        }
+        rowIDByID = keptRowIDs
+        idByRowID = Dictionary(keptRowIDs.map { ($0.value, $0.key) }, uniquingKeysWith: { first, _ in first })
         rowIDs = listed.map(\.id)
-        spokenValues = listed.map(\.spokenValues)
-        tones = listed.map(\.tones)
-        tableRows = TableRows.from(
-            queryRows: listed.map { $0.values.map(PluginCellValue.text) },
+        grid.textTones = tones
+        grid.spokenTexts = spoken
+        return TableRows(
+            rows: rows,
             columns: columns,
             columnTypes: Array(repeating: .text(rawType: nil), count: columns.count),
             columnNullable: Dictionary(columns.map { ($0, false) }, uniquingKeysWith: { first, _ in first })
         )
-        return tableRows
-    }
-
-    internal func rowIndex(forDisplayRow row: Int) -> Int? {
-        guard let index = DisplayRowMapping.rowIndex(forDisplay: row, displayIDs: coordinator?.displayIDs, in: tableRows),
-              rowIDs.indices.contains(index) else { return nil }
-        return index
     }
 
-    internal func id(atDisplayRow row: Int) -> ID? {
-        rowIndex(forDisplayRow: row).map { rowIDs[$0] }
+    private func mintRowID() -> RowID {
+        defer { nextRowNumber += 1 }
+        return .existing(nextRowNumber)
     }
 
-    internal func ids(atDisplayRows rows: Set<Int>) -> Set<ID> {
-        Set(rows.compactMap { id(atDisplayRow: $0) })
+    internal func id(for rowID: RowID) -> ID? {
+        idByRowID[rowID]
     }
 
-    internal func displayRows(of ids: Set<ID>) -> Set<Int> {
-        guard !ids.isEmpty else { return [] }
-        let displayIDs = coordinator?.displayIDs
-        return Set(rowIDs.indices.compactMap { index -> Int? in
-            guard ids.contains(rowIDs[index]), tableRows.rows.indices.contains(index) else { return nil }
-            return DisplayRowMapping.displayIndex(forRowID: tableRows.rows[index].id, displayIDs: displayIDs, in: tableRows)
-        })
+    internal func rowID(for id: ID) -> RowID? {
+        rowIDByID[id]
     }
 
-    /// The grid's row selection kept by row identity, so a sort, a filter or a refresh moves it with its rows.
-    /// Build it after `ensureLoaded`: the grid reads the positions it held when the binding was built.
-    internal func selection(
-        get selectedIDs: @escaping () -> Set<ID>,
-        set select: @escaping (Set<ID>) -> Void
-    ) -> Binding<Set<Int>> {
-        Binding(
-            get: { self.displayRows(of: selectedIDs()) },
-            set: { rows in
-                // Until the grid puts the selection back after a reload, what it publishes names the rows it showed before.
-                guard self.coordinator?.hasRestoredSelection != false else { return }
-                let current = selectedIDs()
-                guard rows != self.displayRows(of: current) else { return }
-                let selected = self.ids(atDisplayRows: rows)
-                guard selected != current else { return }
-                select(selected)
-            }
-        )
+    internal var selectedIDs: Set<ID> {
+        Set(grid.model.selectedRowIDs.compactMap { idByRowID[$0] })
     }
 
-    internal func dataGridAttach(tableViewCoordinator: TableViewCoordinator) {
-        coordinator = tableViewCoordinator
-        if let accessibilityLabel {
-            tableViewCoordinator.tableView?.setAccessibilityLabel(accessibilityLabel)
+    // The owner moved the selection itself.
+    internal func syncSelection(_ ids: Set<ID>) {
+        syncedIDs = ids
+        guard selectedIDs != ids else { return }
+        let rowIDs = ids.compactMap { rowIDByID[$0] }
+        if rowIDs.isEmpty {
+            grid.model.clearSelection()
+        } else {
+            grid.model.selectRows(rowIDs)
         }
-        // A reload drops the table view's selection without a notification, so the selection kept by identity is put back after each one.
-        tableViewCoordinator.hasRestoredSelection = false
-    }
-
-    internal func dataGridAccessibilityText(row: Int, column: Int) -> String? {
-        rowIndex(forDisplayRow: row).flatMap { spokenValues[$0][column] }
     }
 
-    internal func dataGridTextTone(row: Int, column: Int) -> NSColor? {
-        rowIndex(forDisplayRow: row).flatMap { tones[$0][column]?.color }
-    }
-
-    internal func dataGridSortStateChanged(_ state: SortState) {
-        onSortStateChanged?(state)
-    }
-
-    internal func dataGridCopyRows(_ indices: Set<Int>) {
-        let lines = indices.sorted().compactMap { row -> String? in
-            guard let index = rowIndex(forDisplayRow: row) else { return nil }
-            return tableRows.rows[index].values.map { $0.asText ?? "" }.joined(separator: "\t")
-        }
-        guard !lines.isEmpty else { return }
-        ClipboardService.shared.writeText(lines.joined(separator: "\n"))
+    // A filter or a reload that hides selected records shrinks the grid's selection; that is not the user's pick.
+    private func gridSelectionDidChange(_ rowIDs: [RowID]) {
+        let ids = Set(rowIDs.compactMap { idByRowID[$0] })
+        guard ids != syncedIDs.filter({ rowIDByID[$0] != nil }) else { return }
+        syncedIDs = ids
+        onSelect?(ids)
     }
 }
 
-/// A nil `sortState` turns header sorting off. `defaultWidths` and `minimumWidths` follow `columns` by index.
+// A nil `sortState` turns header sorting off. `defaultWidths` and `minimumWidths` follow `columns` by index.
 internal struct StructureListGrid<ID: Hashable>: View {
-    internal let model: StructureListGridModel<ID>
+    @ObservedObject internal var model: StructureListGridModel<ID>
     internal let columns: [String]
     internal var defaultWidths: [CGFloat] = []
     internal var minimumWidths: [CGFloat] = []
-    internal let contentKey: Int
-    internal let rows: () -> [StructureListRow<ID>]
+    internal let rows: [StructureListRow<ID>]
     internal let databaseType: DatabaseType
-    internal let selectedIDs: () -> Set<ID>
+    internal let selectedIDs: Set<ID>
     internal let select: (Set<ID>) -> Void
     internal var sortState: Binding<SortState>?
-    @Binding internal var columnLayout: ColumnLayoutState
 
     internal static func layout(
         _ layout: ColumnLayoutState,
@@ -184,38 +216,31 @@ internal struct StructureListGrid<ID: Hashable>: View {
         Dictionary(zip(columns, widths), uniquingKeysWith: { first, _ in first })
     }
 
+    private struct LoadKey: Equatable {
+        let columns: [String]
+        let rows: [StructureListRow<ID>]
+        let sortState: SortState?
+    }
+
+    // task(id:) runs with this body's values; onChange(of:) would run with the previous body's (measured).
     internal var body: some View {
-        let model = model
-        let columns = columns
-        let defaultWidths = defaultWidths
+        DataGridView(model: model.model)
+            .task(id: LoadKey(columns: columns, rows: rows, sortState: sortState?.wrappedValue)) { load() }
+            .onChange(of: selectedIDs) { model.syncSelection($0) }
+    }
+
+    private func load() {
         let sortState = sortState
-        let tableRows = model.ensureLoaded(key: contentKey, columns: columns, rows: rows)
-        let storedLayout = $columnLayout
-        let layout = Binding(
-            get: { Self.layout(storedLayout.wrappedValue, columns: columns, defaultWidths: defaultWidths) },
-            set: { storedLayout.wrappedValue = $0 }
-        )
-        return DataGridView(
-            tableRowsProvider: { tableRows },
-            changeManager: model.changeManager,
-            isEditable: false,
-            configuration: DataGridConfiguration(
-                databaseType: databaseType,
-                supportsColumnCommands: false,
-                supportsValueFilter: false,
-                appliesRowCopyFormat: true,
-                supportsColumnSort: sortState != nil,
-                columnMinimumWidths: Self.minimumWidths(minimumWidths, columns: columns)
-            ),
-            delegate: model,
-            selectedRowIndices: model.selection(get: selectedIDs, set: select),
-            sortState: sortState ?? .constant(SortState()),
-            columnLayout: layout,
-            contentRevision: contentKey
+        model.onSelect = select
+        model.grid.onSortChange = sortState.map { binding in { binding.wrappedValue = $0 } }
+        model.load(
+            columns: columns,
+            rows: rows,
+            defaultWidths: defaultWidths,
+            minimumWidths: minimumWidths,
+            databaseType: databaseType,
+            sortState: sortState?.wrappedValue
         )
-        .onAppear {
-            guard let sortState else { return }
-            model.onSortStateChanged = { sortState.wrappedValue = $0 }
-        }
+        model.syncSelection(selectedIDs)
     }
 }
diff --git a/apple/TablePro/Views/Structure/StructureRowProvider.swift b/apple/TablePro/Views/Structure/StructureRowProvider.swift
index ad5b167f13..9f06531a6f 100644
--- a/apple/TablePro/Views/Structure/StructureRowProvider.swift
+++ b/apple/TablePro/Views/Structure/StructureRowProvider.swift
@@ -1,20 +1,11 @@
-//
-//  StructureRowProvider.swift
-//  TablePro
-//
-//  Adapts structure entities (columns/indexes/FKs) to TableRows for DataGridView
-//
-
 import Foundation
 import TableProPluginKit
 
-/// Sort descriptor for structure grid columns
 struct StructureSortDescriptor {
     let column: Int
     let ascending: Bool
 }
 
-/// Provides structure entities as rows for DataGridView
 @MainActor
 final class StructureRowProvider {
     private static let canonicalFieldOrder: [StructureColumnField] = [
@@ -82,20 +73,10 @@ final class StructureRowProvider {
         Array(repeating: .text(rawType: nil), count: columns.count)
     }
 
-    /// Every column whose cell opens a menu: the ones with a fixed option list, plus the ones whose
-    /// list the delegate builds per row.
     var dropdownColumns: Set<Int> {
         Set(customDropdownOptions.keys).union(rowDependentDropdownColumns)
     }
 
-    /// Columns whose list is a function of the row, so it cannot live in `customDropdownOptions`.
-    ///
-    /// On the Foreign Keys grid these are Columns (1), Ref Table (2) and Ref Columns (3): the first
-    /// offers the table's own columns, the second the database's tables, and the third the columns
-    /// of whichever table that row names. Every list keeps a `Custom…` entry, so a table the app has
-    /// not loaded is still reachable by typing.
-    ///
-    /// On the Indexes grid it is Type, which lists the row's own type beside the known ones.
     var rowDependentDropdownColumns: Set<Int> {
         switch tab {
         case .foreignKeys: ForeignKeyReferenceMenus.rowDependentColumns
@@ -104,11 +85,8 @@ final class StructureRowProvider {
         }
     }
 
-    /// The Indexes grid's Type column.
     static let indexTypeColumn = 2
 
-    /// The menu an Indexes grid cell opens for `index`, or nil for a column whose list does not
-    /// depend on the row. Shared by the Structure tab and Create Table so the two cannot drift.
     static func indexMenuOptions(
         columnIndex: Int,
         index: EditableIndexDefinition,
@@ -118,20 +96,9 @@ final class StructureRowProvider {
         return GridMenuOption.values(serverSupport.indexTypeChoices(keeping: index.type).map(\.rawValue))
     }
 
-    /// Explicit option lists for every dropdown column, keyed by column index.
-    /// Structure flags are schema properties, not data values, so they always offer
-    /// the same YES/NO pair the grid displays and never a NULL option.
-    ///
-    /// The Default column is the one open vocabulary here: it holds the SQL that follows the
-    /// `DEFAULT` keyword, so its list ends in `Custom…` and the cell still takes typed SQL.
     var customDropdownOptions: [Int: [GridMenuOption]] {
         switch tab {
         case .foreignKeys:
-            /// Offering every action to every engine is how a DuckDB user reached
-            /// `Parser Error: FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT`
-            /// from a menu that presented CASCADE as valid. An engine with no `ON UPDATE` clause at
-            /// all, Oracle among them, still offers NO ACTION so the cell keeps a closed list rather
-            /// than falling back to free text.
             let dialect = ForeignKeyDialect.forType(databaseType)
             let deleteActions = dialect.deleteActions.isEmpty ? [.noAction] : dialect.deleteActions
             let updateActions = dialect.updateActions.isEmpty ? [.noAction] : dialect.updateActions
@@ -164,8 +131,6 @@ final class StructureRowProvider {
 
     static let notGeneratedOption = String(localized: "Not generated")
 
-    /// Every engine that offers a choice is offered both; a driver that supports only one kind
-    /// declares only the fields it can honour and the DDL generator spells the keyword it needs.
     static let generationOptions = [notGeneratedOption] + GenerationKind.allCases.map(\.rawValue)
 
     var typePickerColumns: Set<Int> {
@@ -234,9 +199,6 @@ final class StructureRowProvider {
         return cachedRows[displayRow].sourceIndex
     }
 
-    /// Fields whose working value differs from the value the schema was loaded with.
-    /// An entity that does not exist on the server yet has nothing to compare against,
-    /// so it reports no modified fields and the grid's inserted-row tint carries that state.
     func modifiedFieldIndices(atDisplay displayRow: Int) -> Set<Int> {
         guard let sourceIndex = sourceIndex(atDisplay: displayRow),
               let working = row(at: displayRow),
@@ -401,14 +363,33 @@ final class StructureRowProvider {
     }
 }
 
-// MARK: - Helper to create TableRows
-
 extension StructureRowProvider {
-    /// Creates a TableRows snapshot from structure data
+    // A row is named by its index in the working list, so a search, a sort or the grid's value filter
+    // never changes which definition an edit lands on.
+    static func rowID(forSourceIndex index: Int) -> RowID {
+        .existing(index)
+    }
+
+    static func sourceIndex(of rowID: RowID) -> Int? {
+        guard case .existing(let index) = rowID, index >= 0 else { return nil }
+        return index
+    }
+
+    func displayRow(ofSourceIndex sourceIndex: Int) -> Int? {
+        cachedRows.firstIndex { $0.sourceIndex == sourceIndex }
+    }
+
     func asTableRows() -> TableRows {
-        let typedRows = rows.map { row in row.map(PluginCellValue.fromOptional) }
-        return TableRows.from(
-            queryRows: typedRows,
+        var rows = ContiguousArray<Row>()
+        rows.reserveCapacity(cachedRows.count)
+        for indexed in cachedRows {
+            rows.append(Row(
+                id: Self.rowID(forSourceIndex: indexed.sourceIndex),
+                values: ContiguousArray(indexed.row.map(PluginCellValue.fromOptional))
+            ))
+        }
+        return TableRows(
+            rows: rows,
             columns: columns,
             columnTypes: columnTypes,
             columnNullable: Dictionary(uniqueKeysWithValues: columns.map { ($0, false) })
diff --git a/apple/TablePro/Views/Structure/StructureRowViewWithMenu.swift b/apple/TablePro/Views/Structure/StructureRowViewWithMenu.swift
deleted file mode 100644
index b97daba020..0000000000
--- a/apple/TablePro/Views/Structure/StructureRowViewWithMenu.swift
+++ /dev/null
@@ -1,217 +0,0 @@
-//
-//  StructureRowViewWithMenu.swift
-//  TablePro
-//
-//  Custom row view with structure-specific context menu.
-//  Provides Copy Name, Copy Definition, Copy As, Duplicate, Delete for structure items.
-//
-
-import AppKit
-
-/// Row view providing a context menu tailored to the Structure tab. Inherits
-/// selection/emphasis cell invalidation, deleted/inserted-row tint, and the
-/// `RowVisualState` source-of-truth from `DataGridRowView`. The context menu
-/// reads the same live `visualState` the tint is drawn from, so the two cannot
-/// disagree.
-final class StructureRowViewWithMenu: DataGridRowView {
-    var structureTab: StructureTab = .columns
-    var canDuplicate: Bool = true
-    var canDelete: Bool = true
-    var referencedTableName: String?
-
-    var onCopyName: ((Set<Int>) -> Void)?
-    var onCopyDefinition: ((Set<Int>) -> Void)?
-    var onCopyAsCSV: ((Set<Int>) -> Void)?
-    var onCopyAsJSON: ((Set<Int>) -> Void)?
-    var onNavigateFK: ((Int) -> Void)?
-    var onDuplicate: ((Set<Int>) -> Void)?
-    var onDelete: ((Set<Int>) -> Void)?
-    var onUndoDelete: ((Int) -> Void)?
-
-    /// Three routes reach a row's menu, and all of them end in `contextMenu(target:)`.
-    ///
-    /// `KeyHandlingTableView.rightMouseDown` intercepts a click that lands inside the selection and
-    /// answers from `contextMenu(for:)`; a click outside it falls through to `super`, which reaches
-    /// `menu(for:)`; and the pinned row-number strip asks with the target already resolved, because
-    /// the column under the pointer there is one scrolled out of sight. Overriding the two event
-    /// routes alone left the strip, and before it the select-then-right-click path, showing the data
-    /// grid's row commands, Copy as INSERT and Paste and Set Value and Export Results, over a schema
-    /// row, and none of Copy Name, Copy Definition or the referenced table.
-    override func menu(for event: NSEvent) -> NSMenu? {
-        contextMenu(for: event)
-    }
-
-    override func contextMenu(target: MenuTarget) -> NSMenu? {
-        structureMenu(target: target)
-    }
-
-    private func structureMenu(target: MenuTarget) -> NSMenu? {
-        guard structureTab != .ddl, structureTab != .parts, structureTab != .triggers else { return nil }
-
-        let menu = NSMenu()
-
-        if visualState.isDeleted {
-            let undoItem = NSMenuItem(
-                title: String(localized: "Undo Delete"),
-                action: #selector(handleUndoDelete),
-                keyEquivalent: ""
-            )
-            undoItem.target = self
-            menu.addItem(undoItem)
-            return menu
-        }
-
-        /// The clicked cell, so the Type or the Default is reachable from the pointer and not only
-        /// from `Cmd+C`, which has copied it all along.
-        menu.addItem(makeCopyItem(target: target))
-
-        /// No `Cmd+C` on this one. That key copies the clicked cell, which is what the item above
-        /// does; advertising it here promised a shortcut that has never copied a column's name.
-        let copyNameItem = NSMenuItem(
-            title: String(localized: "Copy Name"),
-            action: #selector(handleCopyName),
-            keyEquivalent: ""
-        )
-        copyNameItem.target = self
-        menu.addItem(copyNameItem)
-
-        let copyDefItem = NSMenuItem(
-            title: String(localized: "Copy Definition"),
-            action: #selector(handleCopyDefinition),
-            keyEquivalent: ""
-        )
-        copyDefItem.target = self
-        menu.addItem(copyDefItem)
-
-        let copyAsSubmenu = NSMenu()
-        let csvItem = NSMenuItem(
-            title: "CSV",
-            action: #selector(handleCopyAsCSV),
-            keyEquivalent: ""
-        )
-        csvItem.target = self
-        copyAsSubmenu.addItem(csvItem)
-
-        let jsonItem = NSMenuItem(
-            title: "JSON",
-            action: #selector(handleCopyAsJSON),
-            keyEquivalent: ""
-        )
-        jsonItem.target = self
-        copyAsSubmenu.addItem(jsonItem)
-
-        let sqlItem = NSMenuItem(
-            title: "SQL",
-            action: #selector(handleCopyDefinition),
-            keyEquivalent: ""
-        )
-        sqlItem.target = self
-        copyAsSubmenu.addItem(sqlItem)
-
-        let copyAsItem = NSMenuItem(
-            title: String(localized: "Copy As"),
-            action: nil,
-            keyEquivalent: ""
-        )
-        copyAsItem.submenu = copyAsSubmenu
-        menu.addItem(copyAsItem)
-
-        if structureTab == .foreignKeys,
-           let tableName = referencedTableName, !tableName.isEmpty {
-            menu.addItem(NSMenuItem.separator())
-            let navItem = NSMenuItem(
-                title: String(format: String(localized: "Open %@"), tableName),
-                action: #selector(handleNavigateFK),
-                keyEquivalent: ""
-            )
-            navItem.target = self
-            menu.addItem(navItem)
-        }
-
-        addColumnMoveItems(to: menu)
-
-        if canDuplicate || canDelete {
-            menu.addItem(NSMenuItem.separator())
-        }
-
-        if canDuplicate {
-            /// No key equivalent. This showed `Cmd+D`, which is not the binding `duplicateRow`
-            /// carries, and the real one does not reach here either: `MainContentCommandActions`
-            /// guards it on `dataGridOwnsSelection` and returns for a schema grid. There is no
-            /// keystroke that duplicates a column, so the menu stops claiming one.
-            let dupItem = NSMenuItem(
-                title: String(localized: "Duplicate"),
-                action: #selector(handleDuplicate),
-                keyEquivalent: ""
-            )
-            dupItem.target = self
-            menu.addItem(dupItem)
-        }
-
-        if canDelete {
-            /// Read from the binding rather than typed in, because this one genuinely works:
-            /// `KeyHandlingTableView.keyDown` routes it to the delegate's row delete, and it can
-            /// be rebound in Settings, at which point a literal here would start lying.
-            let delItem = NSMenuItem(
-                title: String(localized: "Delete"),
-                action: #selector(handleDelete),
-                keyEquivalent: ""
-            )
-            delItem.target = self
-            MenuItemFactory.apply(
-                shortcut: .delete, keyboard: AppSettingsManager.shared.keyboard, to: delItem
-            )
-            menu.addItem(delItem)
-        }
-
-        return menu
-    }
-
-    /// Built by the delegate rather than here, because this is not the only menu a column row can
-    /// raise. `KeyHandlingTableView.rightMouseDown` intercepts a click that lands inside the
-    /// selection and answers from `DataGridRowView.contextMenu(for:)` instead, so items added only
-    /// in this override are missing from the ordinary select-then-right-click path, which is also
-    /// the path the keyboard and assistive technology take.
-    private func addColumnMoveItems(to menu: NSMenu) {
-        let items = coordinator?.delegate?.dataGridRowStructureMenuItems(forRow: rowIndex) ?? []
-        guard !items.isEmpty else { return }
-        menu.addItem(NSMenuItem.separator())
-        for item in items {
-            menu.addItem(item)
-        }
-    }
-
-    /// The rows a row command acts on, resolved the way the data grid's own menu resolves them.
-    ///
-    /// A cell range dragged across several rows lives in `selectionController`, and the table view
-    /// keeps only its anchor in `selectedRowIndices`, so reading the latter alone shrank Delete
-    /// from every row the range covered to one. That was invisible while this menu was reachable
-    /// only from a click outside the selection; owning the in-selection route as well is exactly
-    /// the case where a range is what the user has.
-    private func effectiveIndices() -> Set<Int> {
-        coordinator?.currentRowSelection(fallbackRow: rowIndex) ?? [rowIndex]
-    }
-
-    @objc private func handleCopyName() { onCopyName?(effectiveIndices()) }
-    @objc private func handleCopyDefinition() { onCopyDefinition?(effectiveIndices()) }
-    @objc private func handleCopyAsCSV() { onCopyAsCSV?(effectiveIndices()) }
-    @objc private func handleCopyAsJSON() { onCopyAsJSON?(effectiveIndices()) }
-    @objc private func handleNavigateFK() { onNavigateFK?(rowIndex) }
-    @objc private func handleDuplicate() { onDuplicate?(effectiveIndices()) }
-    @objc private func handleDelete() { onDelete?(effectiveIndices()) }
-    @objc private func handleUndoDelete() { onUndoDelete?(rowIndex) }
-}
-
-/// Menu action target for empty-space context menu.
-/// Stored as `representedObject` on the menu item to keep it alive while the menu is shown.
-final class StructureMenuTarget: NSObject {
-    private let action: () -> Void
-
-    init(action: @escaping () -> Void) {
-        self.action = action
-    }
-
-    @objc func runAction() {
-        action()
-    }
-}
diff --git a/apple/TablePro/Views/Structure/TableStructureView+ColumnReorder.swift b/apple/TablePro/Views/Structure/TableStructureView+ColumnReorder.swift
index 1dc4a60296..8ae123566d 100644
--- a/apple/TablePro/Views/Structure/TableStructureView+ColumnReorder.swift
+++ b/apple/TablePro/Views/Structure/TableStructureView+ColumnReorder.swift
@@ -2,8 +2,6 @@
 //  TableStructureView+ColumnReorder.swift
 //  TablePro
 //
-//  Dragging a column row to a new position, and what happens when the engine cannot.
-//
 
 import Combine
 import Foundation
@@ -12,22 +10,6 @@ import TableProPluginKit
 import TableProSQLGrammar
 
 extension TableStructureView {
-    /// Whether a column may be dragged right now, and the reason shown on the row number when not.
-    ///
-    /// Read by both the grid, which decides whether to offer the drag at all, and the delegate,
-    /// which decides whether there is a handler behind it. One answer, so the two cannot disagree.
-    var columnReorderAvailability: ColumnReorderAvailability {
-        ColumnReorderPolicy.resolve(
-            support: PluginManager.shared.columnReorderSupport(for: connection.type),
-            engineName: connection.type.displayName,
-            isColumnsTab: selectedTab == .columns,
-            kindRefusal: editGate.kindRefusal(.reorderColumns),
-            canEditSchema: editGate.canEditSchema,
-            hasStagedChanges: structureChangeManager.hasChanges,
-            isRearranged: !searchText.isEmpty || structureSortDescriptor != nil
-        )
-    }
-
     func beginColumnReorder(fromIndex: Int, toIndex: Int) {
         let columnsSnapshot = structureChangeManager.workingColumns
         let clearTarget = coordinator?.selectedColumnLayoutClearTarget()
@@ -56,7 +38,7 @@ extension TableStructureView {
                 case .tableRebuild:
                     presentColumnReorderReview(prepared, clearTarget: clearTarget)
                 @unknown default:
-                    /// A cost this build does not recognise is shown before it runs, never after.
+                    // A cost this build does not recognise is shown before it runs, never after.
                     presentColumnReorderReview(prepared, clearTarget: clearTarget)
                 }
             } catch {
@@ -65,8 +47,6 @@ extension TableStructureView {
         }
     }
 
-    /// A rebuild is never run on the drop. It is shown in full, with what it cannot carry over, and
-    /// the user either runs it here or takes the script to a query tab.
     private func presentColumnReorderReview(
         _ prepared: StructureColumnReorderHandler.PreparedReorder,
         clearTarget: ColumnLayoutClearTarget?
@@ -135,7 +115,6 @@ extension TableStructureView {
         )
     }
 
-    /// A Cancel at the gate's confirmation shows nothing: the user chose it a moment ago.
     private func reportColumnReorderFailure(_ error: any Error) {
         guard let message = StructureApplyFailure(error).message else { return }
         AlertHelper.showErrorSheet(
diff --git a/apple/TablePro/Views/Structure/TableStructureView+DataLoading.swift b/apple/TablePro/Views/Structure/TableStructureView+DataLoading.swift
index 2a9e5ddfb0..aa00fed716 100644
--- a/apple/TablePro/Views/Structure/TableStructureView+DataLoading.swift
+++ b/apple/TablePro/Views/Structure/TableStructureView+DataLoading.swift
@@ -2,8 +2,6 @@
 //  TableStructureView+DataLoading.swift
 //  TablePro
 //
-//  Data loading and lifecycle callbacks for table structure
-//
 
 import AppKit
 import Combine
@@ -15,12 +13,6 @@ import UniformTypeIdentifiers
 // MARK: - Data Loading
 
 extension TableStructureView {
-    /// Runs once per session, not once per view. The view is rebuilt whenever the tab is deselected
-    /// or switched to Data and back, and `loadSchemaForEditing` re-baselines the change manager,
-    /// which clears every staged edit, its validation errors and its undo stack. So a rebuild reads
-    /// what the session already holds rather than fetching over the top of the user's work.
-    ///
-    /// A genuine refresh still refetches, through `onRefreshData`, which asks before discarding.
     @Sendable
     func loadInitialData() async {
         session.settleOwedRefetch()
@@ -35,8 +27,7 @@ extension TableStructureView {
             guard !Task.isCancelled else { break }
             await loadTabDataIfNeeded(tab)
         }
-        /// A workspace switch cancels this task and SwiftUI restarts it on return, which fetches only
-        /// for a session not yet loaded, so a load cut short here must not count as one.
+        // A workspace switch cancels this task and restarts it on return, so a cut-short load must not count.
         guard !Task.isCancelled else { return }
         await loadTableComment()
         guard !Task.isCancelled else { return }
@@ -119,15 +110,12 @@ extension TableStructureView {
         searchText = ""
         structureSortDescriptor = nil
         sortState = SortState()
-        selectedRows = []
-        displayVersion += 1
+        gridAdapter.refresh()
         Task {
             await loadTabDataIfNeeded(new)
         }
     }
 
-    /// A fetch that lands after edits were staged keeps them and the baseline they were made
-    /// against; the session owes the fetch until they are saved or discarded.
     func adoptFetchedBaseline() {
         guard !structureChangeManager.hasChanges else {
             session.markStructureStale()
@@ -163,7 +151,6 @@ extension TableStructureView {
             return
         }
 
-        // Skip warning if we just saved (within 2 seconds)
         let justSaved = lastSaveTime.map { Date().timeIntervalSince($0) < 2.0 } ?? false
 
         if structureChangeManager.hasChanges && !justSaved {
@@ -182,7 +169,6 @@ extension TableStructureView {
                     await reloadAllTabs()
                 }
             }
-            // If cancelled, do nothing
         } else {
             Task { @MainActor in
                 await reloadAllTabs()
@@ -192,7 +178,7 @@ extension TableStructureView {
 
     private func reloadAllTabs() async {
         session.markEveryTabStale()
-        session.gridDelegate.referenceMenus.invalidateTableLists()
+        gridAdapter.referenceMenus.invalidateTableLists()
         partsReloadToken += 1
         await reloadCoreTabs()
         if selectedTab == .ddl {
@@ -203,8 +189,6 @@ extension TableStructureView {
         }
     }
 
-    /// Commits in a single synchronous block, so the segmented picker re-lays out once instead of per
-    /// tab, and no columns handler re-baselines against a comment that has not landed yet.
     func reloadCoreTabs() async {
         isLoading = true
         errorMessage = nil
@@ -237,13 +221,6 @@ extension TableStructureView {
     }
 }
 
-/// How a structure fetch that did not land ends, read from the error so it can be tested without
-/// mounting the view.
-///
-/// A workspace switch takes the pane out of the window, so SwiftUI cancels the view's `.task` and
-/// starts it again on return. A fetch cut short that way has not failed, and showing it left
-/// "CancellationError" on screen with no way to retry. An error that arrives after the task was
-/// cancelled counts as cancelled too: the next appearance fetches again and shows a real one then.
 internal enum StructureFetchFailure: Equatable {
     case cancelled
     case failed(String)
@@ -256,7 +233,6 @@ internal enum StructureFetchFailure: Equatable {
         }
     }
 
-    /// What the error view says. Nil for a cancelled fetch, which shows nothing.
     internal var message: String? {
         switch self {
         case .cancelled: nil
diff --git a/apple/TablePro/Views/Structure/TableStructureView+EditGate.swift b/apple/TablePro/Views/Structure/TableStructureView+EditGate.swift
index 5bd2ff18b9..92fdacfe69 100644
--- a/apple/TablePro/Views/Structure/TableStructureView+EditGate.swift
+++ b/apple/TablePro/Views/Structure/TableStructureView+EditGate.swift
@@ -2,25 +2,17 @@
 //  TableStructureView+EditGate.swift
 //  TablePro
 //
-//  Which structure edits this tab offers, for the object it is open on.
-//
 
 import Foundation
 import TableProPluginKit
 
 extension TableStructureView {
-    /// Every "may this edit be offered" question the tab asks, answered from one place. The footer
-    /// pair, the grid's per-column lock, the reorder drag and the grid delegate's own keyboard and
-    /// context-menu paths all read this, so none of them can offer an edit another withholds.
     var editGate: StructureEditGate {
         StructureEditGate(
             databaseType: connection.type, objectKind: objectKind, schema: schemaName, isSessionBound: isSessionBound
         )
     }
 
-    /// Whether this engine can add and remove foreign keys, which is not the same question as
-    /// whether it has them. `supportsForeignKeys` answers the second, and reading it as the first
-    /// is what offered an enabled "+" on SQLite over a driver with no statement behind it.
     var foreignKeyEditAvailability: ForeignKeyEditAvailability {
         ForeignKeyEditPolicy.resolve(
             support: PluginManager.shared.foreignKeyEditSupport(for: connection.type),
@@ -30,37 +22,17 @@ extension TableStructureView {
         )
     }
 
-    /// Published to the tab's own session, which the bottom bar reads. Nothing is cleared on
-    /// disappear: the session outlives the view by design, and the bar only reads this while the
-    /// tab is showing its structure.
     func publishFooterCapability() {
         let gate = editGate
-        session.footer = StructureFooterPolicy.resolve(
+        let footer = StructureFooterPolicy.resolve(
             tab: selectedTab,
             canEditSchema: gate.canEditSchema,
-            hasSelection: !selectedRows.isEmpty,
+            hasSelection: !session.gridModel.selection.isEmpty,
             isSaving: structureChangeManager.isHeldForSave,
             resolve: { gate.resolve($0) }
         )
-    }
-
-    /// Name-keyed because that is the only handle the grid has: `isColumnWritable` is asked about a
-    /// column's heading.
-    func lockedStructureColumns(for provider: StructureRowProvider) -> Set<String> {
-        let headings = provider.columns
-        let locked = editGate.lockedFieldIndices(
-            on: selectedTab,
-            orderedFields: provider.orderedColumnFields,
-            fieldCount: headings.count
-        )
-        return Set(locked.map { headings[$0] })
-    }
-
-    /// Why the Columns grid refuses every keystroke, when it does. A grid that will not take an edit
-    /// and says nothing reads as broken, so the pointer carries this as the grid's tooltip.
-    var structureEditRefusal: String? {
-        if structureChangeManager.isHeldForSave { return StructureFooterPolicy.savingReason }
-        guard !editGate.allowsAnyEdit else { return nil }
-        return editGate.resolve(.renameColumn).unavailableReason
+        // Published on every write, and this runs on every selection change.
+        guard session.footer != footer else { return }
+        session.footer = footer
     }
 }
diff --git a/apple/TablePro/Views/Structure/TableStructureView+Schema.swift b/apple/TablePro/Views/Structure/TableStructureView+Schema.swift
index b583a973e7..e76b921e7e 100644
--- a/apple/TablePro/Views/Structure/TableStructureView+Schema.swift
+++ b/apple/TablePro/Views/Structure/TableStructureView+Schema.swift
@@ -2,8 +2,6 @@
 //  TableStructureView+Schema.swift
 //  TablePro
 //
-//  Schema operations, DDL view, and DDL actions for table structure
-//
 
 import AppKit
 import Combine
@@ -18,9 +16,7 @@ extension TableStructureView {
     func generateStructurePreviewSQL() {
         let changes = structureChangeManager.getChangesArray()
         guard !changes.isEmpty else {
-            // After undo brings the working copy back to a clean state, the popover
-            // would otherwise retain the last-generated SQL. Clear it so reopening
-            // the popover correctly shows "no changes".
+            // An undo back to a clean state would otherwise leave the last preview's SQL behind.
             toolbarState.previewStatements = []
             return
         }
@@ -34,36 +30,23 @@ extension TableStructureView {
         Task { await session.previewStagedChanges(coordinator: coordinator) }
     }
 
-    /// The part of a save only a mounted view can do: refetch the sub-tab the user is looking at
-    /// and repaint the grid. Driven by `session.appliedVersion` rather than called from the save,
-    /// so it runs exactly when there is a view to run it and never otherwise.
     func refreshAfterApply() async {
         isReloadingAfterSave = true
         await reloadCoreTabs()
         adoptFetchedBaseline()
         await loadTabDataIfNeeded(selectedTab)
 
-        /// Save resets the manager (pendingChanges cleared, working state refetched from the
-        /// database) but the row count is usually unchanged after a rename or a type change, so
-        /// `DataGridView.updateNSView` does not call `reloadData` on its own. Ask the grid to
-        /// repaint visible cells so the modified tint clears and any value the round trip changed
-        /// shows its canonical post-save form.
-        gridDelegate.reloadAllVisibleRows()
-
-        /// The apply cleared this so an unmounted tab refetches on its next mount. This view has
-        /// just done that refetch, so the session is loaded again. Leaving it false would make the
-        /// next remount run `loadInitialData`, and `loadSchemaForEditing` re-baselines the change
-        /// manager, so anything staged since the save would be discarded without a prompt.
+        gridAdapter.refresh()
+
+        // Left false, the next mount re-baselines the change manager and drops anything staged since.
         session.hasLoaded = true
         isReloadingAfterSave = false
     }
 
     func discardChanges() {
+        session.gridModel.discardEditing()
         structureChangeManager.discardChanges()
-        // Mirror the save path: discard reverts working state without changing
-        // row count, so the grid needs an explicit reload to drop the yellow
-        // modified tint and revert any displayed value.
-        gridDelegate.reloadAllVisibleRows()
+        gridAdapter.refresh()
     }
 
     // MARK: - DDL View
diff --git a/apple/TablePro/Views/Structure/TableStructureView.swift b/apple/TablePro/Views/Structure/TableStructureView.swift
index ce47fbcf7f..c7f4083ba7 100644
--- a/apple/TablePro/Views/Structure/TableStructureView.swift
+++ b/apple/TablePro/Views/Structure/TableStructureView.swift
@@ -2,9 +2,6 @@
 //  TableStructureView.swift
 //  TablePro
 //
-//  View for displaying table structure using DataGridView
-//  Complete refactor to match data grid UX
-//
 
 import AppKit
 import Combine
@@ -13,18 +10,11 @@ import SwiftUI
 import TableProPluginKit
 import UniformTypeIdentifiers
 
-/// View displaying table structure with DataGridView
 struct TableStructureView: View {
     static let logger = Logger(subsystem: "com.TablePro", category: "TableStructureView")
     static let structurePasteboardType = NSPasteboard.PasteboardType("com.TablePro.structure")
-    /// The database type of the connection the structure rows were copied from, so a paste can tell
-    /// a row said in its own engine's SQL from one said in another's.
     static let structureSourceTypePasteboardType = NSPasteboard.PasteboardType("com.TablePro.structure.database-type")
 
-    /// Whether the clipboard holds structure rows this view can paste. Structure paste reads its
-    /// own pasteboard type and nothing else, so the plain text a structure copy also writes is not
-    /// enough. Menu validation and the grid delegate both ask here rather than each spelling out
-    /// the same check.
     static var canPasteStructureRows: Bool {
         NSPasteboard.general.data(forType: structurePasteboardType) != nil
     }
@@ -35,11 +25,9 @@ struct TableStructureView: View {
 
     @ObservedObject var toolbarState: ConnectionToolbarState
     let coordinator: MainContentCoordinator?
-    @ObservedObject var selectionState: GridSelectionState
 
     @Environment(\.appServices) var services
 
-    /// Derived from the tab's own binding on every render so it can never go stale.
     var scope: DatabaseScope {
         DatabaseScope(
             connectionId: connection.id, database: databaseName, schema: schemaName, isSessionBound: isSessionBound
@@ -52,22 +40,10 @@ struct TableStructureView: View {
         TableStructureLoader(scope: scope, tableName: tableName)
     }
 
-    /// Everything the user has staged, plus the baseline it is staged against. Held outside this
-    /// view because the view is destroyed whenever the tab is deselected or switched to Data.
     @ObservedObject var session: StructureEditingSession
 
-    /// What kind of object the tab is open on, which decides every edit it may offer.
-    ///
-    /// The real `TableInfo.TableType`, read from the session rather than passed in beside it, so the
-    /// grid delegate the session owns and the footer this view publishes can never disagree about
-    /// what they are looking at. It used to be an `isView` Bool derived from `allowsRowEditing`,
-    /// which was true for a materialized view, so a matview reached here as a table and was offered
-    /// `ADD COLUMN`, `SET NOT NULL`, type changes and constraint edits the server always refuses.
-    /// (#2726)
     var objectKind: TableInfo.TableType { session.objectKind }
 
-    /// Where the user was. Two tabs on one table are two editors, and a trip through the Data view
-    /// must not lose the sub-tab, filter or sort either, so all of it lives on the session.
     var selectedTab: StructureTab {
         get { session.selectedTab }
         nonmutating set { session.selectedTab = newValue }
@@ -88,13 +64,6 @@ struct TableStructureView: View {
         nonmutating set { session.sortDescriptor = newValue }
     }
 
-    var structureColumnLayouts: [StructureTab: ColumnLayoutState] {
-        get { session.columnLayouts }
-        nonmutating set { session.columnLayouts = newValue }
-    }
-
-    /// Raised across a write and across the reload that follows it, so the handlers watching
-    /// `columns`, `indexes` and `foreignKeys` do not mistake either for the user editing.
     var isReloadingAfterSave: Bool {
         get { session.isApplying }
         nonmutating set { session.isApplying = newValue }
@@ -105,12 +74,8 @@ struct TableStructureView: View {
         nonmutating set { session.lastAppliedAt = newValue }
     }
 
-    var wrappedChangeManager: AnyChangeManager { session.wrappedChangeManager }
+    var gridAdapter: StructureGridAdapter { session.gridAdapter }
 
-    var gridDelegate: StructureGridDelegate { session.gridDelegate }
-
-    /// The loaded schema, forwarded to the session so a rebuild adopts it instead of refetching.
-    /// Refetching would re-baseline `structureChangeManager` and clear the staged edits.
     var columns: [ColumnInfo] {
         get { session.columns }
         nonmutating set { session.columns = newValue }
@@ -146,10 +111,7 @@ struct TableStructureView: View {
         nonmutating set { session.tabData = newValue }
     }
 
-    /// Observed in its own right, not reached through `session`. The session is observed, but a
-    /// change inside the manager it owns fires the manager's publisher and never the session's, so
-    /// every `onChange` below that reads the manager went deaf: staging a column, an index or a
-    /// foreign key reloaded no grid and left Save disabled, so Command+S did nothing.
+    // Observed on its own: a change inside it fires its publisher, never the session's.
     @ObservedObject var structureChangeManager: StructureChangeManager
 
     @AppStorage("structureCodeFontSize", store: AppStorageEnvironment.shared.defaults) var ddlFontSize: Double = 13
@@ -161,8 +123,6 @@ struct TableStructureView: View {
     @State var partsReloadToken = 0
     @AppStorage("skipSchemaPreview", store: AppStorageEnvironment.shared.defaults) var skipSchemaPreview = false
 
-    @State var displayVersion: Int = 0
-    @State var selectedRows: Set<Int> = []
     @State var actionHandler = StructureViewActionHandler()
     @FocusState var isTableCommentFocused: Bool
 
@@ -173,7 +133,6 @@ struct TableStructureView: View {
         schemaName: String?,
         toolbarState: ConnectionToolbarState,
         coordinator: MainContentCoordinator?,
-        selectionState: GridSelectionState,
         session: StructureEditingSession
     ) {
         self.tableName = tableName
@@ -182,7 +141,6 @@ struct TableStructureView: View {
         self.schemaName = schemaName
         self.toolbarState = toolbarState
         self.coordinator = coordinator
-        self.selectionState = selectionState
         self.session = session
         self.structureChangeManager = session.changeManager
     }
@@ -196,8 +154,7 @@ struct TableStructureView: View {
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
         }
         .task(loadInitialData)
-        .onChange(of: selectedRows) { newRows in
-            selectionState.indices = newRows
+        .onReceive(session.gridModel.$selectionRevision) { _ in
             publishFooterCapability()
         }
         .onChange(of: selectedTab) { newValue in
@@ -212,106 +169,63 @@ struct TableStructureView: View {
         .onChange(of: isTableCommentFocused) { isFocused in
             if !isFocused { structureChangeManager.endTableCommentRun() }
         }
-        .onChange(of: searchText) { _ in displayVersion += 1 }
-        .onChange(of: displayVersion) { _ in updateGridDelegate() }
+        .onChange(of: searchText) { _ in gridAdapter.refresh() }
+        .onChange(of: session.serverSupport) { _ in gridAdapter.refresh() }
         .onAppear {
             coordinator?.toolbarState.hasStructureChanges = structureChangeManager.hasChanges
+            coordinator?.inspectorRowSource = gridAdapter
 
-            /// A workspace switch remounts this view with `selectedRows` intact and the grid still
-            /// highlighting them, so the channel `onDisappear` cleared gets them back, not nothing.
-            selectionState.indices = selectedRows
-            coordinator?.inspectorRowSource = gridDelegate
-
-            gridDelegate.onSelectedRowsChanged = { self.selectedRows = $0 }
-            gridDelegate.coordinator = coordinator
-            gridDelegate.sortHandler = { [self] column, ascending in
-                /// A cleared sort arrives as column -1, which is not a column. Writing it through as
-                /// one left a descriptor that `columnReorderAvailability` reads as "the list is
-                /// sorted", so Move Column Up and Down stayed dimmed until the next reload.
-                guard column >= 0 else {
-                    structureSortDescriptor = nil
-                    sortState = SortState(columns: [], source: .user)
-                    displayVersion += 1
-                    return
-                }
-                structureSortDescriptor = StructureSortDescriptor(column: column, ascending: ascending)
-                sortState = SortState(
-                    columns: [SortColumn(columnIndex: column, direction: ascending ? .ascending : .descending)],
-                    source: .user
-                )
-                displayVersion += 1
+            gridAdapter.coordinator = coordinator
+            gridAdapter.moveRowHandler = { [self] fromIndex, toIndex in
+                beginColumnReorder(fromIndex: fromIndex, toIndex: toIndex)
             }
-            updateGridDelegate()
+            gridAdapter.refresh()
 
             actionHandler.previewSQL = { self.generateStructurePreviewSQL() }
-            actionHandler.copyRows = { self.gridDelegate.dataGridCopyRows(self.selectedRows) }
-            actionHandler.pasteRows = { self.gridDelegate.dataGridPasteRows() }
-            actionHandler.undo = { self.gridDelegate.dataGridUndo() }
-            actionHandler.redo = { self.gridDelegate.dataGridRedo() }
-            actionHandler.addRow = { self.gridDelegate.dataGridAddRow() }
-            actionHandler.removeRow = { self.gridDelegate.dataGridDeleteRows(self.selectedRows) }
+            actionHandler.copyRows = { self.gridAdapter.copyRows(self.session.gridModel.selectedRowIDs) }
+            actionHandler.pasteRows = { self.gridAdapter.pasteRows() }
+            actionHandler.undo = { self.gridAdapter.undo() }
+            actionHandler.redo = { self.gridAdapter.redo() }
+            actionHandler.addRow = { self.gridAdapter.addRow() }
+            actionHandler.removeRow = { self.gridAdapter.deleteRows(self.session.gridModel.selectedRowIDs) }
             actionHandler.refresh = { self.onRefreshData() }
             coordinator?.structureActions = actionHandler
             publishFooterCapability()
         }
         .onDisappear {
             structureChangeManager.endTableCommentRun()
-            /// Every clear is guarded by identity, because appearance is not lifetime: SwiftUI does
-            /// not order `onDisappear` on the outgoing view before `onAppear` on the incoming one,
-            /// and an unguarded clear that lands second nils the wiring the incoming structure tab
-            /// has already installed. Its Save, Refresh, Preview SQL, undo and footer buttons then
-            /// do nothing at all until something else re-runs `onAppear`.
-            ///
-            /// The shared selection channel gets a second guard on top of that one. Switching this
-            /// tab back to Data mounts the data grid, which restores its own rows into the channel,
-            /// and this clear landing afterwards would wipe them: the same unordered lifecycle, one
-            /// layer out. Ask who owns the channel now rather than assuming it is still this grid.
+            // Guarded by identity: SwiftUI does not order the outgoing view's onDisappear before the
+            // incoming one's onAppear, so an unguarded clear can nil the wiring another tab installed.
             if coordinator?.structureActions === actionHandler {
                 coordinator?.structureActions = nil
                 coordinator?.toolbarState.hasStructureChanges = false
-                if incomingSelectionOwner != .dataGrid {
-                    selectionState.indices = []
-                }
             }
-            if coordinator?.inspectorRowSource === gridDelegate {
+            if coordinator?.inspectorRowSource === gridAdapter {
                 coordinator?.inspectorRowSource = nil
             }
         }
         .onChange(of: structureChangeManager.hasChanges) { newValue in
             coordinator?.toolbarState.hasStructureChanges = newValue
-            updateGridDelegate()
+            gridAdapter.refresh()
             if !newValue, session.settleOwedRefetch() {
                 Task { await loadInitialData() }
             }
         }
         .onChange(of: structureChangeManager.isHeldForSave) { _ in
             publishFooterCapability()
-            updateGridDelegate()
+            gridAdapter.refresh()
         }
         .onChange(of: session.appliedVersion) { _ in
             Task { await refreshAfterApply() }
         }
+        // A mutation that leaves hasChanges as it was, such as a second added row, moves only this.
         .onChange(of: structureChangeManager.reloadVersion) { _ in
-            // Any mutation that does not toggle hasChanges (add row when changes
-            // already exist, undo to a still-dirty state) only bumps reloadVersion.
-            // Bump displayVersion so SwiftUI re-evaluates structureGrid with a fresh
-            // tableRows snapshot, which lets DataGridView see the new row count and
-            // call reloadData(). Without this, Cmd+Shift+N adds the row to the change
-            // manager but the grid never displays it.
-            displayVersion += 1
+            gridAdapter.refresh()
         }
     }
 
     // MARK: - Toolbar
 
-    /// Which grid owns the shared selection channel now that this view is leaving.
-    private var incomingSelectionOwner: GridSelectionOwner {
-        GridSelectionOwner.resolve(
-            tabType: coordinator?.tabManager.selectedTab?.tabType,
-            resultsViewMode: coordinator?.tabManager.selectedTab?.display.resultsViewMode
-        )
-    }
-
     private var availableTabs: [StructureTab] {
         session.availableTabs
     }
@@ -386,7 +300,7 @@ struct TableStructureView: View {
         case .indexes:
             Group {
                 if shouldShowIndexesEmptyState {
-                    EmptyStateView.indexes { gridDelegate.dataGridAddRow() }
+                    EmptyStateView.indexes { gridAdapter.addRow() }
                         .gridStandInBackground()
                 } else {
                     structureGrid
@@ -397,14 +311,14 @@ struct TableStructureView: View {
             }
         case .foreignKeys:
             if shouldShowForeignKeysEmptyState {
-                EmptyStateView.foreignKeys { gridDelegate.dataGridAddRow() }
+                EmptyStateView.foreignKeys { gridAdapter.addRow() }
                     .gridStandInBackground()
             } else {
                 structureGrid
             }
         case .checkConstraints:
             if shouldShowCheckConstraintsEmptyState {
-                EmptyStateView.checkConstraints { gridDelegate.dataGridAddRow() }
+                EmptyStateView.checkConstraints { gridAdapter.addRow() }
                     .gridStandInBackground()
             } else {
                 structureGrid
@@ -451,10 +365,6 @@ struct TableStructureView: View {
         }
     }
 
-    /// Only offered where the add behind it can actually run. An engine that lists an object but
-    /// cannot edit it shows the grid, so its real rows stay visible instead of being replaced by an
-    /// empty state whose only affordance is disabled, and a view whose kind refuses the add never
-    /// gets the empty state's button at all.
     private var shouldShowIndexesEmptyState: Bool {
         tabData.hasData(.indexes)
             && structureChangeManager.workingIndexes.isEmpty
@@ -474,99 +384,18 @@ struct TableStructureView: View {
             && editGate.allows(.addCheckConstraint)
     }
 
-    // MARK: - Structure Grid (DataGridView)
-
-    private func makeCurrentProvider() -> StructureRowProvider {
-        StructureRowProvider(
-            changeManager: structureChangeManager,
-            tab: selectedTab,
-            databaseType: connection.type,
-            additionalFields: [.primaryKey],
-            serverSupport: session.serverSupport,
-            filterText: searchText.isEmpty ? nil : searchText,
-            sortDescriptor: structureSortDescriptor
-        )
-    }
-
-    private func columnLayoutBinding(for tab: StructureTab) -> Binding<ColumnLayoutState> {
-        Binding(
-            get: { session.columnLayouts[tab] ?? ColumnLayoutState() },
-            set: { session.columnLayouts[tab] = $0 }
-        )
-    }
-
-    func updateGridDelegate() {
-        let provider = makeCurrentProvider()
-
-        gridDelegate.selectedTab = selectedTab
-        gridDelegate.serverSupport = session.serverSupport
-        gridDelegate.currentProvider = provider
-        gridDelegate.orderedFields = provider.orderedColumnFields
-        coordinator?.inspectorRowSourceRevision += 1
-
-        let availability = columnReorderAvailability
-        gridDelegate.moveRowHandler = availability.isAvailable ? { [self] fromIndex, toIndex in
-            beginColumnReorder(fromIndex: fromIndex, toIndex: toIndex)
-        } : nil
-        gridDelegate.columnReorder = DataGridRowReorder(
-            isEnabled: availability.isAvailable,
-            unavailableReason: availability.unavailableReason
-        )
-    }
+    // MARK: - Structure Grid
 
     private var structureGrid: some View {
-        let provider = makeCurrentProvider()
-        let canEdit = editGate.allowsAnyEdit && !structureChangeManager.isHeldForSave
-        let customOptions = provider.customDropdownOptions
-        let allDropdownColumns = provider.dropdownColumns
-        /// Resolved once. It reads the engine's curated capabilities and the object's own kind, and
-        /// this is a body property, so asking twice for the pair of values below doubled that work.
-        let reorder = columnReorderAvailability
-
-        // Build the row snapshot fresh on every call rather than capturing it
-        // once at body-evaluation time. After a cell edit / undo / redo the
-        // change manager's working state is updated synchronously, but a
-        // captured snapshot would still hold the pre-edit value, so the
-        // `tableView.reloadData(forRowIndexes:)` issued by the delegate would
-        // re-render the cell from a stale source. Mirror the data tab's pattern
-        // (`MainEditorContentView` rebuilds via `coordinator.tabSessionRegistry`
-        // on every call). `makeCurrentProvider` is cheap because the working
-        // arrays are small (typically <100 entries).
-        return DataGridView(
-            tableRowsProvider: { makeCurrentProvider().asTableRows() },
-            changeManager: wrappedChangeManager,
-            isEditable: canEdit,
-            configuration: DataGridConfiguration(
-                dropdownColumns: allDropdownColumns,
-                typePickerColumns: provider.typePickerColumns,
-                customDropdownOptions: customOptions.isEmpty ? nil : customOptions,
-                connectionId: connection.id,
-                databaseType: connection.type,
-                tableName: tableName,
-                databaseName: databaseName,
-                schemaName: schemaName,
-                tabType: .table,
-                lockedColumns: lockedStructureColumns(for: provider),
-                editRefusalMessage: structureEditRefusal
-            ),
-            delegate: gridDelegate,
-            rowReorder: DataGridRowReorder(
-                isEnabled: reorder.isAvailable,
-                unavailableReason: reorder.unavailableReason
-            ),
-            selectedRowIndices: $selectedRows,
-            sortState: $session.sortState,
-            columnLayout: columnLayoutBinding(for: selectedTab),
-            contentRevision: displayVersion
-        )
-        .safeAreaInset(edge: .top, spacing: 0) {
-            VStack(spacing: 0) {
-                NativeSearchField(text: $session.searchText, placeholder: String(localized: "Filter"))
-                    .padding(.horizontal, 6)
-                    .padding(.vertical, 4)
-                Divider()
+        DataGridView(model: session.gridModel)
+            .safeAreaInset(edge: .top, spacing: 0) {
+                VStack(spacing: 0) {
+                    NativeSearchField(text: $session.searchText, placeholder: String(localized: "Filter"))
+                        .padding(.horizontal, 6)
+                        .padding(.vertical, 4)
+                    Divider()
+                }
             }
-        }
     }
 
     // MARK: - Helper Views
@@ -600,7 +429,6 @@ struct TableStructureView: View {
         schemaName: nil,
         toolbarState: ConnectionToolbarState(),
         coordinator: nil,
-        selectionState: GridSelectionState(),
         session: StructureEditingSession(
             identity: "test.users",
             connection: connection,
diff --git a/apple/TablePro/Views/Structure/TriggerDetailView.swift b/apple/TablePro/Views/Structure/TriggerDetailView.swift
index bbeb726147..7820902422 100644
--- a/apple/TablePro/Views/Structure/TriggerDetailView.swift
+++ b/apple/TablePro/Views/Structure/TriggerDetailView.swift
@@ -24,7 +24,6 @@ final class TriggerInspectorState: ObservableObject {
         return list.first { selectedIDs.contains($0.id) } ?? list.first
     }
 
-    /// Edit and Delete act on one trigger, so they have no target while several rows are selected.
     func actionTarget(_ triggers: [TriggerInfo]) -> TriggerInfo? {
         let list = displayed(triggers)
         let selected = list.filter { selectedIDs.contains($0.id) }
@@ -195,9 +194,6 @@ struct TriggerDetailView: View {
         )
     }
 
-    /// Read through the tab's own scope rather than the session driver, which follows the sidebar:
-    /// an engine that qualifies its template with the connection's current database pre-fills a
-    /// statement that creates the trigger on a same-named table in whatever database that is.
     private func newTrigger() {
         let scope = scope
         let tableName = tableName
@@ -285,7 +281,6 @@ internal struct TriggerListPane: View {
     @StateObject private var grid = StructureListGridModel<TriggerInfo.ID>(
         accessibilityLabel: StructureTab.triggers.displayName
     )
-    @State private var columnLayout = ColumnLayoutState()
 
     private var showsEnabled: Bool { triggers.contains { $0.enabled != nil } }
 
@@ -309,20 +304,16 @@ internal struct TriggerListPane: View {
                 spokenValues: TriggerListColumns.spokenValues(for: trigger, showsEnabled: showsEnabled)
             )
         }
-        var hasher = Hasher()
-        hasher.combine(rows)
         return StructureListGrid(
             model: grid,
             columns: TriggerListColumns.titles(showsEnabled: showsEnabled),
             defaultWidths: TriggerListColumns.widths(showsEnabled: showsEnabled),
             minimumWidths: TriggerListColumns.minimumWidths(showsEnabled: showsEnabled),
-            contentKey: hasher.finalize(),
-            rows: { rows },
+            rows: rows,
             databaseType: databaseType,
-            selectedIDs: { inspector.selectedIDs },
+            selectedIDs: inspector.selectedIDs,
             select: { inspector.select($0) },
-            sortState: $state.sortState,
-            columnLayout: $columnLayout
+            sortState: $state.sortState
         )
     }
 }
diff --git a/apple/TablePro/Views/TableListing/TableListingTabView.swift b/apple/TablePro/Views/TableListing/TableListingTabView.swift
index dfaf957086..44fd926e3b 100644
--- a/apple/TablePro/Views/TableListing/TableListingTabView.swift
+++ b/apple/TablePro/Views/TableListing/TableListingTabView.swift
@@ -5,9 +5,7 @@
 
 import SwiftUI
 
-/// The tables of one database or schema with what the engine knows about each, drawn by the app's own
-/// data grid. Read-only and complete, so a header click sorts the rows on hand rather than re-running
-/// anything, the way the agent result pane does.
+// Read-only and complete, so a header click sorts the rows on hand rather than re-running anything.
 internal struct TableListingTabView: View {
     @ObservedObject var model: TableListingViewModel
     let databaseType: DatabaseType
@@ -40,7 +38,7 @@ internal struct TableListingTabView: View {
             emptyState(listing)
         case .loaded(let listing):
             VStack(spacing: 0) {
-                grid(listing.rows)
+                rowsGrid
                 if let notice = listing.notice {
                     noticeBar(notice)
                 }
@@ -48,7 +46,6 @@ internal struct TableListingTabView: View {
         }
     }
 
-    /// A page with nothing on it is not an empty database when the driver says more pages follow.
     private func emptyState(_ listing: TableListing) -> some View {
         Group {
             if listing.isIncomplete {
@@ -76,35 +73,18 @@ internal struct TableListingTabView: View {
             .statusBarChrome()
     }
 
-    private func grid(_ loaded: TableRows) -> some View {
-        let rows = TableRowsSorting.sorted(loaded, by: model.sortState)
-        return DataGridView(
-            tableRowsProvider: { rows },
-            changeManager: model.changeManager,
-            isEditable: false,
-            configuration: DataGridConfiguration(
-                databaseType: databaseType,
-                showRowNumbers: true,
-                supportsColumnCommands: false,
-                supportsValueFilter: false,
-                appliesRowCopyFormat: true
-            ),
-            delegate: model.gridDelegate,
-            selectedRowIndices: $model.selectedRows,
-            sortState: $model.sortState,
-            columnLayout: $model.columnLayout,
-            contentRevision: contentRevision
-        )
+    private var rowsGrid: some View {
+        DataGridView(model: model.grid.model)
+            .onAppear { model.grid.model.configuration = configuration }
     }
 
-    /// Moves whenever the rows the grid should draw move: a load lands, or a sort reorders them.
-    private var contentRevision: Int {
-        var hasher = Hasher()
-        hasher.combine(model.revision)
-        for column in model.sortState.columns {
-            hasher.combine(column.columnIndex)
-            hasher.combine(column.direction)
-        }
-        return hasher.finalize()
+    private var configuration: DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.traits = DataGridEngineTraits(databaseType: databaseType)
+        configuration.showRowNumbers = true
+        configuration.supportsValueFilter = false
+        configuration.appliesRowCopyFormat = true
+        configuration.commands = [.freezeColumns, .displayAs]
+        return configuration
     }
 }
diff --git a/apple/TableProTests/Core/Coordinators/FindMatcherTests.swift b/apple/TableProTests/Core/Coordinators/FindMatcherTests.swift
index 78a7abe9d8..32b9aea657 100644
--- a/apple/TableProTests/Core/Coordinators/FindMatcherTests.swift
+++ b/apple/TableProTests/Core/Coordinators/FindMatcherTests.swift
@@ -4,70 +4,12 @@
 //
 
 import Foundation
+import TableProPluginKit
 import Testing
 
 @testable import TablePro
 
 struct FindMatcherTests {
-    private let grid: [[String?]] = [
-        ["active", "Alice", nil],
-        ["inactive", "Bob", "note"],
-        ["ACTIVE", "Chloé", "other"],
-    ]
-
-    private func cellText(_ row: Int, _ column: Int) -> String? {
-        guard row >= 0, row < grid.count, column >= 0, column < grid[row].count else { return nil }
-        return grid[row][column]
-    }
-
-    private func run(term: String, searchable: @escaping (Int) -> Bool = { _ in true }) -> [FindMatch] {
-        FindMatcher.matches(
-            term: term,
-            displayRowCount: grid.count,
-            columnCount: 3,
-            isColumnSearchable: searchable,
-            cellText: cellText
-        )
-    }
-
-    @Test("finds every occurrence in row-major order")
-    func rowMajorOrder() {
-        let matches = run(term: "active")
-        #expect(matches == [
-            FindMatch(displayRow: 0, columnIndex: 0),
-            FindMatch(displayRow: 1, columnIndex: 0),
-            FindMatch(displayRow: 2, columnIndex: 0),
-        ])
-    }
-
-    @Test("matching ignores case")
-    func caseInsensitive() {
-        #expect(run(term: "ACTIVE").count == 3)
-        #expect(run(term: "aCtIvE").count == 3)
-    }
-
-    @Test("matching ignores diacritics")
-    func diacriticInsensitive() {
-        #expect(run(term: "chloe") == [FindMatch(displayRow: 2, columnIndex: 1)])
-    }
-
-    @Test("a nil cell never matches")
-    func nilCellsSkipped() {
-        #expect(run(term: "note") == [FindMatch(displayRow: 1, columnIndex: 2)])
-    }
-
-    @Test("an excluded column is never searched")
-    func excludedColumn() {
-        let matches = run(term: "active", searchable: { $0 != 0 })
-        #expect(matches.isEmpty)
-    }
-
-    @Test("an empty or whitespace term matches nothing")
-    func emptyTerm() {
-        #expect(run(term: "").isEmpty)
-        #expect(run(term: "   ").isEmpty)
-    }
-
     @Test("binary column types are not searchable, everything else is")
     func searchableColumnTypes() {
         #expect(FindMatcher.isSearchable(.blob(rawType: "BLOB")) == false)
@@ -90,20 +32,6 @@ struct FindMatcherTests {
         #expect(FindMatcher.isSearchable(.spatial(rawType: "GEOMETRY"), displayFormat: .text) == false)
     }
 
-    @Test("the nearest match to a display row is the first at or after it")
-    func nearestMatch() {
-        let matches = [
-            FindMatch(displayRow: 1, columnIndex: 0),
-            FindMatch(displayRow: 4, columnIndex: 0),
-            FindMatch(displayRow: 9, columnIndex: 0),
-        ]
-        #expect(FindMatcher.nearestMatchIndex(to: 0, in: matches) == 0)
-        #expect(FindMatcher.nearestMatchIndex(to: 4, in: matches) == 1)
-        #expect(FindMatcher.nearestMatchIndex(to: 5, in: matches) == 2)
-        #expect(FindMatcher.nearestMatchIndex(to: 99, in: matches) == 0)
-        #expect(FindMatcher.nearestMatchIndex(to: 0, in: []) == nil)
-    }
-
     @Test("a server search sends only text columns unless the engine's patterns read every scalar column")
     func serverSearchableColumns() {
         let typed: [ColumnType] = [
@@ -121,110 +49,79 @@ struct FindMatcherTests {
     }
 }
 
-struct TabFindStateTests {
-    private func state(matchCount: Int) -> TabFindState {
-        var value = TabFindState(isVisible: true)
-        value.term = "x"
-        value.matches = (0 ..< matchCount).map { FindMatch(displayRow: $0, columnIndex: 0) }
-        return value
+// The Find menu reaches the selected tab's grid model; each tab's model keeps its own bar (#2667).
+@MainActor
+struct FindCoordinatorRoutingTests {
+    private let fixtures = CoordinatorFixtures()
+
+    private func makeTabs() -> (MainContentCoordinator, first: UUID, second: UUID) {
+        let fixture = fixtures.make()
+        let rows = TableRows.from(
+            queryRows: [[.text("alice")], [.text("bob")], [.text("alina")]],
+            columns: ["name"],
+            columnTypes: [.text(rawType: nil)]
+        )
+        let first = QueryTab(title: "Album", query: "", tabType: .query)
+        let second = QueryTab(title: "Artist", query: "", tabType: .query)
+        fixture.addTab(first, rows: rows)
+        fixture.addTab(second, rows: rows)
+        fixture.tabManager.selectedTabId = first.id
+        return (fixture.coordinator, first.id, second.id)
     }
 
-    @Test("stepping forward wraps around")
-    func stepForwardWraps() {
-        var value = state(matchCount: 3)
-        value.stepForward()
-        #expect(value.currentMatchIndex == 0)
-        value.stepForward()
-        #expect(value.currentMatchIndex == 1)
-        value.currentMatchIndex = 2
-        value.stepForward()
-        #expect(value.currentMatchIndex == 0)
-    }
+    @Test("Find opens the bar on the selected tab's grid only")
+    func findOpensTheSelectedTabsBar() {
+        let (coordinator, first, second) = makeTabs()
 
-    @Test("stepping backward from no selection lands on the last match")
-    func stepBackwardWraps() {
-        var value = state(matchCount: 3)
-        value.stepBackward()
-        #expect(value.currentMatchIndex == 2)
-        value.stepBackward()
-        #expect(value.currentMatchIndex == 1)
-    }
+        coordinator.findCoordinator.showFind()
 
-    @Test("stepping with no matches does nothing")
-    func stepWithoutMatches() {
-        var value = state(matchCount: 0)
-        value.stepForward()
-        #expect(value.currentMatchIndex == nil)
-        value.stepBackward()
-        #expect(value.currentMatchIndex == nil)
+        #expect(coordinator.gridModel(forTab: first).find.isVisible)
+        #expect(!coordinator.gridModel(forTab: second).find.isVisible)
     }
 
-    @Test("escalation is offered only when rows are unloaded and a term is set")
-    func escalationAvailability() {
-        var value = TabFindState(isVisible: true)
-        value.scope = .pageOfMore
-        #expect(value.canEscalateToAllRows == false)
-        value.term = "abc"
-        #expect(value.canEscalateToAllRows)
-        value.scope = .allRowsLoaded
-        #expect(value.canEscalateToAllRows == false)
-    }
+    @Test("each tab keeps its own find term across a switch")
+    func termStaysWithItsTab() {
+        let (coordinator, first, second) = makeTabs()
+        coordinator.findCoordinator.showFind()
+        coordinator.activeGridModel?.find.term = "alice"
+        coordinator.tabManager.selectedTabId = second
+        coordinator.findCoordinator.showFind()
+        coordinator.activeGridModel?.find.term = "berlin"
 
-    @Test("clearing matches drops the current index too")
-    func clearMatches() {
-        var value = state(matchCount: 3)
-        value.currentMatchIndex = 2
-        value.clearMatches()
-        #expect(value.matches.isEmpty)
-        #expect(value.currentMatchIndex == nil)
-        #expect(value.currentMatch == nil)
+        coordinator.tabManager.selectedTabId = first
+
+        #expect(coordinator.activeGridModel?.find.term == "alice")
+        #expect(coordinator.gridModel(forTab: second).find.term == "berlin")
     }
 
-    /// The bar seeds its field from the selected tab's state, so the term has to stay with the tab it
-    /// was typed in. The other half of #2667, the bar's `.id(tab.id)`, is view identity.
-    @Test("each tab keeps its own find term across a switch")
-    @MainActor
-    func termStaysWithItsTab() {
-        let tabManager = QueryTabManager()
-        let coordinator = MainContentCoordinator(
-            connection: TestFixtures.makeConnection(),
-            tabManager: tabManager,
-            changeManager: DataChangeManager(),
-            toolbarState: ConnectionToolbarState()
-        )
-        defer { coordinator.teardown() }
-        let first = QueryTab(title: "Album", query: "", tabType: .table)
-        let second = QueryTab(title: "Artist", query: "", tabType: .table)
-        tabManager.tabs = [first, second]
+    @Test("Find Next and Find Previous step the selected tab's matches")
+    func stepsTheSelectedTabsMatches() throws {
+        let (coordinator, first, _) = makeTabs()
+        let model = coordinator.gridModel(forTab: first)
+        coordinator.findCoordinator.showFind()
+        model.find.term = "ali"
+        model.findQueryDidChange()
+        #expect(model.find.matches.count == 2)
+        #expect(coordinator.findCoordinator.hasActiveFind)
+        let start = try #require(model.find.currentIndex)
 
-        tabManager.selectedTabId = first.id
-        coordinator.findCoordinator.show()
-        coordinator.findCoordinator.setTerm("alice")
-        tabManager.selectedTabId = second.id
-        coordinator.findCoordinator.show()
-        coordinator.findCoordinator.setTerm("berlin")
-        tabManager.selectedTabId = first.id
+        coordinator.findCoordinator.findNext()
+        #expect(model.find.currentIndex != start)
 
-        #expect(coordinator.findCoordinator.selectedTabFindState?.term == "alice")
-        #expect(tabManager.tabs.first { $0.id == second.id }?.findState.term == "berlin")
+        coordinator.findCoordinator.findPrevious()
+        #expect(model.find.currentIndex == start)
     }
 }
 
-/// The find bar renders only on table tabs, and a table tab pages through `currentPage`, never
-/// through `hasMoreRows`, which is the query-tab truncation flag. Reading the wrong one made every
-/// table tab report its page as the whole table.
+// A table tab pages through `currentPage`; `hasMoreRows` is the query-tab truncation flag.
 struct FindScopeFromPaginationTests {
-    private func hasUnloadedRows(_ state: PaginationState, loadedRowCount: Int) -> Bool {
-        state.hasMoreRows || state.canGoToNextPage(loadedRowCount: loadedRowCount)
-    }
-
     @Test("page 1 of a multi-page table has unloaded rows even though hasMoreRows is false")
     func firstPageOfManyIsPaged() {
         var state = PaginationState(pageSize: 1_000)
         state.totalRowCount = 12_000
         state.currentPage = 1
         #expect(state.hasMoreRows == false)
-        #expect(hasUnloadedRows(state, loadedRowCount: 1_000))
+        #expect(state.hasUnloadedRows(loadedRowCount: 1_000))
     }
 
     @Test("the last page of a table has everything loaded")
@@ -232,7 +129,7 @@ struct FindScopeFromPaginationTests {
         var state = PaginationState(pageSize: 1_000)
         state.totalRowCount = 1_500
         state.currentPage = 2
-        #expect(hasUnloadedRows(state, loadedRowCount: 500) == false)
+        #expect(state.hasUnloadedRows(loadedRowCount: 500) == false)
     }
 
     @Test("a table that fits on one page has everything loaded")
@@ -240,7 +137,7 @@ struct FindScopeFromPaginationTests {
         var state = PaginationState(pageSize: 1_000)
         state.totalRowCount = 40
         state.currentPage = 1
-        #expect(hasUnloadedRows(state, loadedRowCount: 40) == false)
+        #expect(state.hasUnloadedRows(loadedRowCount: 40) == false)
     }
 
     @Test("an unknown row count with a full page is treated as paged, not as complete")
@@ -248,15 +145,15 @@ struct FindScopeFromPaginationTests {
         var state = PaginationState(pageSize: 1_000)
         state.totalRowCount = nil
         state.currentPage = 1
-        #expect(hasUnloadedRows(state, loadedRowCount: 1_000))
-        #expect(hasUnloadedRows(state, loadedRowCount: 200) == false)
+        #expect(state.hasUnloadedRows(loadedRowCount: 1_000))
+        #expect(state.hasUnloadedRows(loadedRowCount: 200) == false)
     }
 
     @Test("a truncated query result still counts as paged")
     func truncatedQueryResult() {
         var state = PaginationState(pageSize: 1_000)
         state.hasMoreRows = true
-        #expect(hasUnloadedRows(state, loadedRowCount: 10))
+        #expect(state.hasUnloadedRows(loadedRowCount: 10))
     }
 }
 
diff --git a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorCopyTests.swift b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorCopyTests.swift
index fa9a443225..f0a4168d96 100644
--- a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorCopyTests.swift
+++ b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorCopyTests.swift
@@ -5,7 +5,6 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 import TableProPluginKit
 import Testing
 
@@ -34,52 +33,55 @@ extension GlobalStateSuites {
             return fixture.coordinator
         }
 
-        /// Narrows the tab to the rows whose `name` is one of `names`, which is what a value filter
-        /// does and the only thing in the shipping app that makes display order differ from storage
-        /// order. No grid is attached, so this also covers the readers that run with none.
-        private func applyNameFilter(_ names: Set<String>, to coordinator: MainContentCoordinator) {
-            guard let tabId = coordinator.tabManager.selectedTab?.id else { return }
+        private func selectedModel(_ coordinator: MainContentCoordinator) throws -> DataGridModel {
+            let tabId = try #require(coordinator.tabManager.selectedTab?.id)
+            return coordinator.gridModel(forTab: tabId)
+        }
+
+        // The value filter is the only thing that makes display order differ from storage order. No grid is
+        // mounted, so this also covers the readers that run with none.
+        private func applyNameFilter(_ names: Set<String>, to coordinator: MainContentCoordinator) throws {
             var state = GridValueFilterState()
             state.set(
                 ColumnValueFilter(selectedValues: names, includesNull: false),
                 columnName: "name",
                 forColumn: 1
             )
-            coordinator.setValueFilter(state, forTab: tabId)
+            try selectedModel(coordinator).setValueFilter(state)
         }
 
-        @Test("Copy as JSON resolves display positions through the value-filtered order")
-        func copyAsJsonResolvesDisplayOrder() throws {
+        @Test("Copy as JSON copies the row the model selected under a value filter")
+        func copyAsJsonFollowsTheFilteredSelection() throws {
             let clipboard = try #require(RecordingClipboard.current)
-
             let coordinator = makeCoordinator()
-            applyNameFilter(["Bob"], to: coordinator)
+            try applyNameFilter(["Bob"], to: coordinator)
+            let model = try selectedModel(coordinator)
 
-            coordinator.copySelectedRowsAsJson(indices: [0])
+            model.setSelection(GridSelectionReducer.single(GridCoord(row: 0, displayColumn: 0)))
+            coordinator.copyRowsAsJson(model.selectedRowIDs)
 
+            #expect(model.selectedRowIDs == [.existing(1)])
             #expect(clipboard.text?.contains("Bob") == true)
             #expect(clipboard.text?.contains("Alice") != true)
         }
 
-        @Test("the display order survives with no grid mounted, which is what JSON mode reads")
-        func displayOrderResolvesWithNoGridAttached() {
+        @Test("the display order resolves with no grid mounted, which is what JSON mode reads")
+        func displayOrderResolvesWithNoGridMounted() throws {
             let coordinator = makeCoordinator()
-            applyNameFilter(["Bob"], to: coordinator)
+            try applyNameFilter(["Bob"], to: coordinator)
+            let tabId = try #require(coordinator.tabManager.selectedTab?.id)
 
-            #expect(coordinator.dataTabDelegate == nil)
-            #expect(coordinator.activeGridDisplayIDs == [.existing(1)])
+            #expect(try selectedModel(coordinator).isMounted == false)
+            #expect(coordinator.displayIDs(forTab: tabId) == [.existing(1)])
         }
 
         @Test("replacing the rows wholesale drops the value filter")
-        func newResultDropsTheValueFilter() {
+        func newResultDropsTheValueFilter() throws {
             let coordinator = makeCoordinator()
-            applyNameFilter(["Bob"], to: coordinator)
-            #expect(coordinator.activeGridDisplayIDs != nil)
+            try applyNameFilter(["Bob"], to: coordinator)
+            let tabId = try #require(coordinator.tabManager.selectedTab?.id)
+            #expect(coordinator.displayIDs(forTab: tabId) != nil)
 
-            guard let tabId = coordinator.tabManager.selectedTab?.id else {
-                Issue.record("no selected tab")
-                return
-            }
             coordinator.setActiveTableRows(
                 TableRows.from(
                     queryRows: [[.text("3"), .text("Carol")]],
@@ -89,23 +91,21 @@ extension GlobalStateSuites {
                 for: tabId
             )
 
-            #expect(coordinator.activeGridDisplayIDs == nil)
+            #expect(coordinator.displayIDs(forTab: tabId) == nil)
+            #expect(try selectedModel(coordinator).displayedRowIDs == nil)
             #expect(coordinator.tabManager.selectedTab?.valueFilter.isActive == false)
         }
 
-        /// Fetch All extends the same result rather than replacing it, so the filter stays and the
-        /// order is re-resolved over the rows that arrived. The memo keys on the registry's row-set
-        /// revision, so this holds with no grid mounted to recompute it.
+        // Fetch All extends the same result rather than replacing it, so the filter stays and the order is
+        // resolved again over the rows that arrived.
         @Test("loading more rows into the same result keeps the value filter and re-resolves the order")
-        func loadingMoreRowsKeepsTheValueFilter() {
+        func loadingMoreRowsKeepsTheValueFilter() throws {
             let coordinator = makeCoordinator()
-            applyNameFilter(["Bob"], to: coordinator)
-            #expect(coordinator.activeGridDisplayIDs == [.existing(1)])
+            try applyNameFilter(["Bob"], to: coordinator)
+            let model = try selectedModel(coordinator)
+            #expect(model.displayedRowIDs == [.existing(1)])
 
-            guard let tabId = coordinator.tabManager.selectedTab?.id else {
-                Issue.record("no selected tab")
-                return
-            }
+            let tabId = try #require(coordinator.tabManager.selectedTab?.id)
             coordinator.mutateActiveTableRows(for: tabId) { rows in
                 rows.replace(rows: [
                     [.text("1"), .text("Alice")],
@@ -115,40 +115,18 @@ extension GlobalStateSuites {
             }
 
             #expect(coordinator.tabManager.selectedTab?.valueFilter.isActive == true)
-            #expect(coordinator.activeGridDisplayIDs == [.existing(1), .existing(2)])
+            #expect(model.displayedRowIDs == [.existing(1), .existing(2)])
         }
 
-        /// The clear runs one line before `setActiveTableRows` drives the grid's full reload, and the
-        /// grid keeps its own mirror of the filter. Left un-adopted, the reload resolved the new rows
-        /// through the old filter and pruning it against the new columns wrote it back onto the tab.
-        @Test("a mounted grid does not resurrect the value filter a new result cleared")
-        func newResultClearsTheFilterOnTheMountedGridToo() {
+        // The model reads the filter through its store, so a filter a new result cleared cannot come back
+        // from a copy the grid kept.
+        @Test("a new result with other columns leaves the model unfiltered")
+        func newResultClearsTheFilterTheModelReads() throws {
             let coordinator = makeCoordinator()
-            let delegate = DataTabGridDelegate()
-            let grid = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: true,
-                selectedRowIndices: .constant([]),
-                delegate: delegate,
-                layoutPersister: InMemoryColumnLayoutStore()
-            )
-            delegate.dataGridAttach(tableViewCoordinator: grid)
-            coordinator.dataTabDelegate = delegate
-
-            guard let tabId = coordinator.tabManager.selectedTab?.id else {
-                Issue.record("no selected tab")
-                return
-            }
-            grid.tableRowsProvider = { [weak coordinator] in
-                coordinator?.tabSessionRegistry.tableRows(for: tabId) ?? TableRows()
-            }
-            grid.valueFilterBinding = Binding(
-                get: { coordinator.tabManager.selectedTab?.valueFilter ?? GridValueFilterState() },
-                set: { coordinator.setValueFilter($0, forTab: tabId) }
-            )
-            applyNameFilter(["Bob"], to: coordinator)
-            grid.adoptValueFilter(coordinator.tabManager.selectedTab?.valueFilter ?? GridValueFilterState())
-            #expect(grid.valueFilterState.isActive)
+            try applyNameFilter(["Bob"], to: coordinator)
+            let model = try selectedModel(coordinator)
+            #expect(model.store.valueFilter.isActive)
+            let tabId = try #require(coordinator.tabManager.selectedTab?.id)
 
             coordinator.setActiveTableRows(
                 TableRows.from(
@@ -160,32 +138,31 @@ extension GlobalStateSuites {
             )
 
             #expect(coordinator.tabManager.selectedTab?.valueFilter.isActive == false)
-            #expect(grid.valueFilterState.isActive == false)
-            #expect(coordinator.activeGridDisplayIDs == nil)
-            withExtendedLifetime((delegate, grid)) {}
+            #expect(model.store.valueFilter.isActive == false)
+            #expect(model.displayedRowIDs == nil)
+            #expect(model.rowCount == 1)
         }
 
-        @Test("Copy as JSON keeps storage order when no display mapping exists")
+        @Test("Copy as JSON keeps storage order when no value filter applies")
         func copyAsJsonWithoutDisplayMapping() throws {
             let clipboard = try #require(RecordingClipboard.current)
-
             let coordinator = makeCoordinator()
 
-            coordinator.copySelectedRowsAsJson(indices: [0])
+            coordinator.copyRowsAsJson([.existing(0)])
 
             #expect(clipboard.text?.contains("Alice") == true)
             #expect(clipboard.text?.contains("Bob") != true)
         }
 
-        @Test("Copy as JSON skips display positions past the current rows")
-        func copyAsJsonSkipsOutOfRangeIndices() throws {
+        @Test("Copy as JSON skips rows the result does not hold")
+        func copyAsJsonSkipsUnknownRows() throws {
             let clipboard = try #require(RecordingClipboard.current)
-
             let coordinator = makeCoordinator()
 
-            coordinator.copySelectedRowsAsJson(indices: [1, 99])
+            coordinator.copyRowsAsJson([.existing(1), .existing(99)])
 
             #expect(clipboard.text?.contains("Bob") == true)
+            #expect(clipboard.text?.contains("Alice") != true)
         }
 
         @Test("Copy as JSON preserves wide integer values")
@@ -199,7 +176,7 @@ extension GlobalStateSuites {
             )
             let coordinator = makeCoordinator(tableRows: tableRows)
 
-            coordinator.copySelectedRowsAsJson(indices: [0])
+            coordinator.copyRowsAsJson([.existing(0)])
 
             #expect(clipboard.text?.contains("\"value\": \(value)") == true)
         }
diff --git a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorJsonModeTests.swift b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorJsonModeTests.swift
index 629e1be274..f71fbf86c7 100644
--- a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorJsonModeTests.swift
+++ b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorJsonModeTests.swift
@@ -3,9 +3,7 @@
 //  TableProTests
 //
 //  A row command points the grid at the row it just touched. JSON mode reads that same selection
-//  as "show only these rows", so writing it there collapses the document. The filtered delete and
-//  duplicate paths used to be safe only by accident, because a display order existed only while
-//  the grid was mounted. Now that it survives, the guard has to be explicit. (#2251)
+//  as "show only these rows", so writing it there collapses the document (#2251).
 //
 
 import Foundation
@@ -48,53 +46,63 @@ struct RowEditingCoordinatorJsonModeTests {
             columnName: "name",
             forColumn: 1
         )
-        coordinator.setValueFilter(filter, forTab: tab.id)
+        coordinator.gridModel(forTab: tab.id).setValueFilter(filter)
         return coordinator
     }
 
+    private func model(_ coordinator: MainContentCoordinator) throws -> DataGridModel {
+        let tabId = try #require(coordinator.tabManager.selectedTabId)
+        return coordinator.gridModel(forTab: tabId)
+    }
+
     @Test("the filter narrows the display order, so the filtered delete path is the one that runs")
-    func filteredPathIsReached() {
+    func filteredPathIsReached() throws {
         let coordinator = makeCoordinator(mode: .data)
-        #expect(coordinator.activeGridDisplayIDs == [.existing(1), .existing(2)])
+        #expect(try model(coordinator).displayedRowIDs == [.existing(1), .existing(2)])
     }
 
     @Test("deleting in JSON mode leaves the selection alone")
-    func deleteInJsonModeDoesNotMoveTheSelection() {
+    func deleteInJsonModeDoesNotMoveTheSelection() throws {
         let coordinator = makeCoordinator(mode: .json)
-        coordinator.selectionState.indices = [0, 1]
+        let grid = try model(coordinator)
+        grid.selectRows([.existing(1), .existing(2)])
 
-        coordinator.deleteSelectedRows(indices: [0])
+        coordinator.deleteRows([.existing(1)])
 
-        #expect(coordinator.selectionState.indices == [0, 1])
+        #expect(grid.selectedRowIDs == [.existing(1), .existing(2)])
     }
 
     @Test("deleting in Data mode still moves the selection to the surviving neighbour")
-    func deleteInDataModeMovesTheSelection() {
+    func deleteInDataModeMovesTheSelection() throws {
         let coordinator = makeCoordinator(mode: .data)
-        coordinator.selectionState.indices = [0, 1]
+        let grid = try model(coordinator)
+        grid.selectRows([.existing(1), .existing(2)])
 
-        coordinator.deleteSelectedRows(indices: [0])
+        coordinator.deleteRows([.existing(1)])
 
-        #expect(coordinator.selectionState.indices == [1])
+        #expect(grid.selectedRowIDs == [.existing(2)])
     }
 
     @Test("duplicating in JSON mode leaves the selection alone")
-    func duplicateInJsonModeDoesNotMoveTheSelection() {
+    func duplicateInJsonModeDoesNotMoveTheSelection() throws {
         let coordinator = makeCoordinator(mode: .json)
-        coordinator.selectionState.indices = [1]
+        let grid = try model(coordinator)
+        grid.selectRows([.existing(2)])
 
-        coordinator.duplicateSelectedRow(index: 0)
+        coordinator.duplicateRow(.existing(1))
 
-        #expect(coordinator.selectionState.indices == [1])
+        #expect(grid.selectedRowIDs == [.existing(2)])
     }
 
     @Test("duplicating in Data mode still selects the new row")
-    func duplicateInDataModeSelectsTheNewRow() {
+    func duplicateInDataModeSelectsTheNewRow() throws {
         let coordinator = makeCoordinator(mode: .data)
-        coordinator.selectionState.indices = [0]
+        let grid = try model(coordinator)
+        grid.selectRows([.existing(1)])
 
-        coordinator.duplicateSelectedRow(index: 0)
+        coordinator.duplicateRow(.existing(1))
 
-        #expect(coordinator.selectionState.indices == [2])
+        #expect(grid.selection.affectedRows == IndexSet(integer: 2))
+        #expect(grid.selectedRowIDs.first?.isInserted == true)
     }
 }
diff --git a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorUUIDKeyTests.swift b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorUUIDKeyTests.swift
index 40e0894e66..71a31a2c8f 100644
--- a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorUUIDKeyTests.swift
+++ b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorUUIDKeyTests.swift
@@ -52,7 +52,7 @@ struct RowEditingCoordinatorUUIDKeyTests {
         return text == text.lowercased() && text != "0b1e7c9a-58f4-4b8e-9c55-1f1c86f0a001"
     }
 
-    /// The reporter's table: `id uuid PRIMARY KEY` with no default, which a new row sent as NULL.
+    // The reporter's table: `id uuid PRIMARY KEY` with no default, which a new row sent as NULL.
     @Test("Add Row on a uuid key with no default stages a fresh UUID in it")
     func addRowPrefillsTheUUIDKey() throws {
         let coordinator = makeCoordinator()
@@ -87,7 +87,7 @@ struct RowEditingCoordinatorUUIDKeyTests {
     func duplicatePrefillsTheUUIDKey() throws {
         let coordinator = makeCoordinator()
 
-        coordinator.duplicateSelectedRow(index: 0)
+        coordinator.duplicateRow(.existing(0))
 
         let row = try #require(lastRow(of: coordinator))
         #expect(isFreshUUID(row.values[0]))
diff --git a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorValueFilterTests.swift b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorValueFilterTests.swift
index 385406b99a..eb2fb4ad2d 100644
--- a/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorValueFilterTests.swift
+++ b/apple/TableProTests/Core/Coordinators/RowEditingCoordinatorValueFilterTests.swift
@@ -50,27 +50,33 @@ struct RowEditingCoordinatorValueFilterTests {
             columnName: "name",
             forColumn: 1
         )
-        coordinator.setValueFilter(filter, forTab: tab.id)
+        coordinator.gridModel(forTab: tab.id).setValueFilter(filter)
         return coordinator
     }
 
+    private func model(_ coordinator: MainContentCoordinator) throws -> DataGridModel {
+        let tabId = try #require(coordinator.tabManager.selectedTabId)
+        return coordinator.gridModel(forTab: tabId)
+    }
+
     private func tableRows(of coordinator: MainContentCoordinator) -> TableRows {
         guard let tabId = coordinator.tabManager.selectedTab?.id else { return TableRows() }
         return coordinator.tabSessionRegistry.tableRows(for: tabId)
     }
 
     @Test("The filter shows the two Bobs, so display positions are not storage indices")
-    func filterNarrowsTheDisplay() {
+    func filterNarrowsTheDisplay() throws {
         let coordinator = makeCoordinator()
 
-        #expect(coordinator.activeGridDisplayIDs == [.existing(1), .existing(3)])
+        #expect(try model(coordinator).displayedRowIDs == [.existing(1), .existing(3)])
     }
 
     @Test("Deleting the second shown row marks id 4, and the DELETE names id 4")
     func deleteMarksTheShownRow() throws {
         let coordinator = makeCoordinator()
+        let shown = try #require(try model(coordinator).rowID(at: 1))
 
-        coordinator.deleteSelectedRows(indices: [1])
+        coordinator.deleteRows([shown])
 
         #expect(coordinator.changeManager.isRowDeleted(.existing(3)))
         #expect(!coordinator.changeManager.isRowDeleted(.existing(1)))
@@ -80,27 +86,31 @@ struct RowEditingCoordinatorValueFilterTests {
     }
 
     @Test("A new row is selected at the position the filter shows it")
-    func addRowSelectsItsDisplayPosition() {
+    func addRowSelectsItsDisplayPosition() throws {
         let coordinator = makeCoordinator()
+        let grid = try model(coordinator)
 
         coordinator.addNewRow()
 
-        let displayIDs = coordinator.activeGridDisplayIDs ?? []
+        let displayIDs = grid.displayedRowIDs ?? []
         #expect(displayIDs.count == 3)
         #expect(displayIDs.last?.isInserted == true)
-        #expect(coordinator.selectionState.indices == [2])
+        #expect(grid.selection.affectedRows == IndexSet(integer: 2))
+        #expect(grid.selectedRowIDs.first == displayIDs.last)
     }
 
     @Test("A duplicated row is selected at the position the filter shows it")
-    func duplicateSelectsItsDisplayPosition() {
+    func duplicateSelectsItsDisplayPosition() throws {
         let coordinator = makeCoordinator()
+        let grid = try model(coordinator)
+        let shown = try #require(grid.rowID(at: 1))
 
-        coordinator.duplicateSelectedRow(index: 1)
+        coordinator.duplicateRow(shown)
 
         let rows = tableRows(of: coordinator)
         #expect(rows.count == 5)
         #expect(rows.rows.last?.values[1] == "Bob")
-        #expect(coordinator.selectionState.indices == [2])
+        #expect(grid.selection.affectedRows == IndexSet(integer: 2))
     }
 
     @Test("Discard puts back the row that was edited, not the one at the same storage offset")
diff --git a/apple/TableProTests/Core/DataFiles/DataFileControllerTests.swift b/apple/TableProTests/Core/DataFiles/DataFileControllerTests.swift
index d436598ae2..936fc1e956 100644
--- a/apple/TableProTests/Core/DataFiles/DataFileControllerTests.swift
+++ b/apple/TableProTests/Core/DataFiles/DataFileControllerTests.swift
@@ -3,6 +3,7 @@
 //  TableProTests
 //
 
+import AppKit
 import Foundation
 @testable import TablePro
 import TableProPluginKit
@@ -11,14 +12,8 @@ import TableProTabularIO
 import Testing
 
 @MainActor
-struct DataFileControllerTests {
-    private let undoManager = UndoManager()
-
-    private func loaded(_ text: String, fileExtension: String = "csv") async throws -> (DataFileController, URL) {
-        try await loaded(data: Data(text.utf8), fileExtension: fileExtension)
-    }
-
-    private func loaded(data: Data, fileExtension: String) async throws -> (DataFileController, URL) {
+private enum DataFileFixture {
+    static func open(data: Data, fileExtension: String, undoManager: UndoManager) async throws -> (DataFileController, URL) {
         let directory = FileManager.default.temporaryDirectory
             .appendingPathComponent("DataFileControllerTests-\(UUID().uuidString)")
         try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
@@ -33,12 +28,78 @@ struct DataFileControllerTests {
         return (controller, url)
     }
 
+    // The grid as the window builds it, with the window's configuration.
+    static func grid(for controller: DataFileController) -> DataGridViewController {
+        controller.gridModel.configuration = DataFileContentView.gridConfiguration(for: controller)
+        return DataGridViewController(model: controller.gridModel)
+    }
+
+    static func item(_ title: String, in menu: NSMenu?) -> NSMenuItem? {
+        menu?.items.first { $0.title == title }
+    }
+
+    static func perform(_ item: NSMenuItem) {
+        guard let action = item.action else { return }
+        _ = NSApp.sendAction(action, to: item.target, from: item)
+    }
+}
+
+// Header geometry exists only once the grid is laid out in a window.
+@MainActor
+private final class MountedDataFileGrid {
+    let grid: DataGridViewController
+    let window: NSWindow
+
+    init(controller: DataFileController) {
+        grid = DataFileFixture.grid(for: controller)
+        window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 600, height: 240),
+            styleMask: [.titled],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        window.contentView = grid.view
+        grid.view.layoutSubtreeIfNeeded()
+    }
+
+    func tearDown() {
+        grid.dismantle()
+        window.contentView = nil
+    }
+}
+
+@MainActor
+struct DataFileControllerTests {
+    private let undoManager = UndoManager()
+
+    private func loaded(_ text: String, fileExtension: String = "csv") async throws -> (DataFileController, URL) {
+        try await loaded(data: Data(text.utf8), fileExtension: fileExtension)
+    }
+
+    private func loaded(data: Data, fileExtension: String) async throws -> (DataFileController, URL) {
+        try await DataFileFixture.open(data: data, fileExtension: fileExtension, undoManager: undoManager)
+    }
+
     private func loaded(workbook base64: String) async throws -> DataFileController {
         let data = try #require(Data(base64Encoded: base64))
         let (controller, _) = try await loaded(data: data, fileExtension: "xlsx")
         return controller
     }
 
+    // A cell range on the page, as the grid's selection holds it.
+    private func select(_ cells: [(row: Int, column: Int)], in controller: DataFileController) {
+        let rects = cells.map { GridRect(rows: $0.row...$0.row, columns: $0.column...$0.column) }
+        let active = cells.last.map { GridCoord(row: $0.row, displayColumn: $0.column) }
+        controller.gridModel.setSelection(GridSelection(rectangles: rects, activeCell: active, anchor: active))
+    }
+
+    private func editableGrid(_ controller: DataFileController) -> DataGridModel {
+        let model = controller.gridModel
+        model.configuration.isEditable = true
+        return model
+    }
+
     private func column(_ controller: DataFileController, _ index: Int) -> [String] {
         controller.tableRows.rows.map { row in
             guard case .text(let text) = row.values[index] else { return "" }
@@ -74,7 +135,7 @@ struct DataFileControllerTests {
         #expect(column(controller, 1) == ["Rome"])
     }
 
-    /// Compared as text, "9" sorts after "50" and would be kept too.
+    // Compared as text, "9" sorts after "50" and would be kept too.
     @Test("A cell filter on a number column compares numbers, not text")
     func cellFilterComparesNumbersAsNumbers() async throws {
         let (controller, _) = try await loaded("amount,name\n9,nine\n50,fifty\n100,hundred\n")
@@ -122,13 +183,11 @@ struct DataFileControllerTests {
         #expect(column(controller, 0) == ["y"])
     }
 
-    @Test("Set Cells to Value from the grid writes the cells it resolved, not the focused column")
+    @Test("Set Cells to Value writes the cells the grid selected, not the focused column")
     func setCellsToValueWritesTheGridCells() async throws {
         let (controller, _) = try await loaded("name,city\nA,Paris\nB,London\nC,Rome\n")
-        let target = try #require(controller.cellTarget(for: [
-            SetValueTarget(displayRow: 0, columnIndex: 1),
-            SetValueTarget(displayRow: 2, columnIndex: 1)
-        ]))
+        select([(row: 0, column: 1), (row: 2, column: 1)], in: controller)
+        let target = try #require(controller.cellTarget())
         #expect(target.cells.map { $0.column } == [controller.columnNames.ids[1]])
         #expect(!target.coversWholeColumns)
 
@@ -154,13 +213,58 @@ struct DataFileControllerTests {
         #expect(column(controller, 1) == ["Paris", "London", "Rome"])
     }
 
+    @Test("A grid command over several cells is one commit and one undo step")
+    func gridCommitIsOneUndoStep() async throws {
+        let (controller, _) = try await loaded("name,city\nA,Paris\nB,London\nC,Rome\n")
+        let model = editableGrid(controller)
+        let city = try #require(model.columns.column(at: 1))
+        let first = try #require(model.rowID(at: 0))
+        let third = try #require(model.rowID(at: 2))
+        let rowIDs = [first, third]
+        let edits = rowIDs.map { DataGridCellEdit(rowID: $0, columnID: city.id, value: .enteredText("Oslo")) }
+
+        #expect(model.commit(edits, actionName: "Set Value"))
+
+        #expect(column(controller, 1) == ["Oslo", "London", "Oslo"])
+        #expect(undoManager.undoActionName == "Set Value")
+        undoManager.undo()
+        #expect(column(controller, 1) == ["Paris", "London", "Rome"])
+    }
+
+    @Test("A grid edit under a sort lands on the row it was made on")
+    func gridEditUnderSortTargetsItsRow() async throws {
+        let (controller, _) = try await loaded("n,tag\n3,c\n1,a\n2,b\n")
+        controller.updateSort(SortState(columns: [SortColumn(columnIndex: 0, direction: .ascending)]))
+        await controller.waitForPendingWork()
+        #expect(column(controller, 0) == ["1", "2", "3"])
+        let model = editableGrid(controller)
+        let rowID = try #require(model.rowID(at: 2))
+        let tag = try #require(model.columns.column(at: 1))
+
+        #expect(model.commit([DataGridCellEdit(rowID: rowID, columnID: tag.id, value: .enteredText("z"))], actionName: "Edit Cell"))
+
+        #expect(controller.table?.cells(row: 0).map(\.text) == ["3", "z"])
+        #expect(column(controller, 1) == ["a", "b", "z"])
+    }
+
+    @Test("A read-only file takes no commit from the grid")
+    func readOnlyFileRefusesGridCommits() async throws {
+        let controller = try await loaded(workbook: Self.twoSheetWorkbook)
+        let model = controller.gridModel
+        model.configuration.isEditable = true
+        let name = try #require(model.columns.column(at: 0))
+        let rowID = try #require(model.rowID(at: 0))
+
+        #expect(!model.commit([DataGridCellEdit(rowID: rowID, columnID: name.id, value: .enteredText("x"))], actionName: "Edit Cell"))
+        #expect(column(controller, 0) == ["Ann", "Bob", "Cy"])
+    }
+
     @Test("Separate cells in two columns change only those cells, not the rows and columns between them")
     func separateCellsStaySeparate() async throws {
         let (controller, _) = try await loaded("name,city\nA,Paris\nB,London\n")
-        let target = try #require(controller.cellTarget(for: [
-            SetValueTarget(displayRow: 0, columnIndex: 0),
-            SetValueTarget(displayRow: 1, columnIndex: 1)
-        ]))
+        select([(row: 0, column: 0), (row: 1, column: 1)], in: controller)
+        let target = try #require(controller.cellTarget())
+        #expect(!target.coversWholeColumns)
 
         controller.applyCleanup(.setValue("x"), target: target, actionName: "Set Cells to Value")
         await controller.waitForPendingWork()
@@ -169,6 +273,20 @@ struct DataFileControllerTests {
         #expect(column(controller, 1) == ["Paris", "x"])
     }
 
+    // A click selects the whole row; a cleanup command still changes only the cell under the cursor.
+    @Test("A clicked cell is the one a cleanup command changes")
+    func clickedCellIsTheTarget() async throws {
+        let (controller, _) = try await loaded("name,city\nA,Paris\nB,London\n")
+        controller.gridModel.selectCell(GridCoord(row: 1, displayColumn: 1))
+        let target = try #require(controller.cellTarget())
+
+        controller.applyCleanup(.setValue("x"), target: target, actionName: "Set Cells to Value")
+        await controller.waitForPendingWork()
+
+        #expect(column(controller, 0) == ["A", "B"])
+        #expect(column(controller, 1) == ["Paris", "x"])
+    }
+
     @Test("Changing the query goes back to the first page")
     func queryChangeResetsPage() async throws {
         let rows = (1...30).map { "row\($0)" }.joined(separator: "\n")
@@ -190,14 +308,27 @@ struct DataFileControllerTests {
         #expect(controller.table?.cells(row: 1).map(\.text) == ["3", "4", "5"])
     }
 
+    // The file's find searches every row off the main actor; the search has settled when this returns.
+    private func find(_ term: String, in controller: DataFileController) async -> DataGridModel {
+        let model = editableGrid(controller)
+        controller.showFind(replacing: true)
+        model.find.term = term
+        model.findQueryDidChange()
+        await model.findSearchSettled()
+        return model
+    }
+
     @Test("Replace All is one undo step")
     func replaceAllIsOneUndoStep() async throws {
         let (controller, _) = try await loaded("a\nfoo\nfoo bar\nbaz\n")
-        controller.find.text = "foo"
-        controller.find.replacement = "qux"
-        controller.replaceAll()
+        let model = await find("foo", in: controller)
+        model.find.replacement = "qux"
+
+        model.replaceAllMatches()
         await controller.waitForPendingWork()
+
         #expect(column(controller, 0) == ["qux", "qux bar", "baz"])
+        #expect(undoManager.undoActionName == String(localized: "Replace All"))
         controller.undoManager?.undo()
         #expect(column(controller, 0) == ["foo", "foo bar", "baz"])
     }
@@ -205,30 +336,114 @@ struct DataFileControllerTests {
     @Test("Undoing Replace All finds the restored matches again")
     func undoRefreshesFind() async throws {
         let (controller, _) = try await loaded("a\nfoo\nfoo bar\nbaz\n")
-        controller.showFind(replacing: true)
-        controller.find.text = "foo"
-        controller.runFind()
-        await controller.waitForPendingWork()
-        #expect(controller.find.matches.count == 2)
-        controller.find.replacement = "qux"
-        controller.replaceAll()
-        await controller.waitForPendingWork()
-        #expect(controller.find.matches.isEmpty)
+        let model = await find("foo", in: controller)
+        #expect(model.find.isVisible)
+        #expect(model.find.showsReplace)
+        #expect(model.find.matches.count == 2)
+        model.find.replacement = "qux"
+        model.replaceAllMatches()
+        await controller.waitForPendingWork()
+        await model.findSearchSettled()
+        #expect(model.find.matches.isEmpty)
         controller.undoManager?.undo()
         await controller.waitForPendingWork()
-        #expect(controller.find.matches.count == 2)
+        await model.findSearchSettled()
+        #expect(model.find.matches.count == 2)
+    }
+
+    @Test("A find match becomes the active cell on the matched column")
+    func findMatchIsTheActiveCell() async throws {
+        let (controller, _) = try await loaded("name,city\nA,Paris\nB,Oslo\n")
+        let model = await find("oslo", in: controller)
+
+        #expect(model.find.matches.count == 1)
+        #expect(model.selection.activeCell == GridCoord(row: 1, displayColumn: 1))
+        #expect(controller.activeCell()?.column == controller.columnNames.ids[1])
     }
 
-    @Test("Cancel stops a running find")
-    func cancelStopsFind() async throws {
-        let (controller, _) = try await loaded("a\nfoo\n")
-        controller.showFind(replacing: false)
-        controller.find.text = "foo"
-        controller.runFind()
-        let running = try #require(controller.findTask)
-        controller.cancelActivity()
-        #expect(running.isCancelled)
+    @Test("Replace in Column on a hidden column shows the column and replaces only in it")
+    func replaceInHiddenColumnStaysInIt() async throws {
+        let (controller, _) = try await loaded("name,notes\nfoo,foo\nbar,foo bar\n")
+        let model = editableGrid(controller)
+        controller.columnLayout.hiddenColumns.insert("notes")
+
+        controller.scopeFind(to: controller.columnNames.ids[1])
+        model.find.term = "foo"
+        model.findQueryDidChange()
+        await model.findSearchSettled()
+
+        #expect(!controller.columnLayout.hiddenColumns.contains("notes"))
+        let scope = try #require(model.find.options.columnScope)
+        #expect(model.columns.column(id: scope)?.name == "notes")
+        #expect(model.find.matches.count == 2)
+        model.find.replacement = "qux"
+        model.replaceAllMatches()
         await controller.waitForPendingWork()
+
+        #expect(column(controller, 0) == ["foo", "bar"])
+        #expect(column(controller, 1) == ["qux", "qux bar"])
+    }
+
+    @Test("Show Row as JSON on a row outside the selection shows that row")
+    func showRowAsJSONSelectsTheClickedRow() async throws {
+        let (controller, _) = try await loaded("name,city\nA,Paris\nB,London\nC,Rome\n")
+        let grid = DataFileFixture.grid(for: controller)
+        controller.selectRows(pageRows: [0])
+
+        let menu = grid.rowMenu(forRow: 2, displayColumn: 1, in: .main)
+        DataFileFixture.perform(try #require(DataFileFixture.item(String(localized: "Show Row as JSON"), in: menu)))
+
+        #expect(controller.isInspectorVisible)
+        #expect(controller.selectedRowIndices == [2])
+    }
+
+    @Test("Insert Row Above and Below on a row inside the selection anchor at the row right-clicked")
+    func insertRowItemsAnchorAtTheClickedRow() async throws {
+        let (controller, _) = try await loaded("n\n1\n2\n3\n4\n")
+        let grid = DataFileFixture.grid(for: controller)
+        controller.selectRows(pageRows: [0, 1, 2])
+
+        let menu = grid.rowMenu(forRow: 2, displayColumn: 0, in: .main)
+        let above = try #require(DataFileFixture.item(String(localized: "Insert Row Above"), in: menu))
+        let below = try #require(DataFileFixture.item(String(localized: "Insert Row Below"), in: menu))
+        #expect(above.representedObject as? Int == 2)
+        #expect(below.representedObject as? Int == 2)
+
+        controller.insertRow(anchoredAtPageRow: below.representedObject as? Int, below: true)
+        #expect(column(controller, 0) == ["1", "2", "3", "", "4"])
+    }
+
+    @Test("Column Statistics points at the column's header; a hidden column has no header to point at")
+    func statisticsAnchorIsTheColumnHeader() async throws {
+        let (controller, _) = try await loaded("name,city\nA,Paris\nB,London\n")
+        let mounted = MountedDataFileGrid(controller: controller)
+        defer { mounted.tearDown() }
+        let ids = controller.columnNames.ids
+
+        let name = try #require(controller.headerAnchor(for: ids[0]))
+        let city = try #require(controller.headerAnchor(for: ids[1]))
+
+        #expect(name.view is NSTableHeaderView)
+        #expect(city.view === name.view)
+        #expect(name.rect.width > 0)
+        #expect(city.rect.minX >= name.rect.maxX - 1)
+
+        controller.columnLayout.hiddenColumns.insert("city")
+        #expect(controller.headerAnchor(for: ids[1])?.view == nil)
+    }
+
+    @Test("The header menu offers Display As on a file's column and applies the chosen format")
+    func headerMenuOffersDisplayAs() async throws {
+        let (controller, _) = try await loaded("payload\nabc\n")
+        let grid = DataFileFixture.grid(for: controller)
+        let column = try #require(controller.gridModel.columns.column(at: 0))
+
+        let menu = grid.headerMenu(for: column)
+        let displayAs = try #require(DataFileFixture.item(String(localized: "Display As"), in: menu)?.submenu)
+        #expect(displayAs.items.contains { $0.title == ValueDisplayFormat.uuid.displayName })
+        DataFileFixture.perform(try #require(displayAs.items.first { $0.title == ValueDisplayFormat.json.displayName }))
+
+        #expect(controller.gridModel.store.displayFormats.first == .json)
     }
 
     @Test("Saving writes untouched rows byte for byte and the edited row once")
@@ -494,8 +709,8 @@ struct DataFileControllerTests {
 
     @Test("Count messages use the singular for one")
     func countMessagesAgreeInNumber() {
-        #expect(DataFileController.replacementMessage(replacements: 1, cells: 1) == "Replaced 1 match in 1 cell.")
-        #expect(DataFileController.replacementMessage(replacements: 12, cells: 3) == "Replaced 12 matches in 3 cells.")
+        #expect(GridFindEngine.replacementMessage(replacements: 1, cells: 1) == "Replaced 1 match in 1 cell.")
+        #expect(GridFindEngine.replacementMessage(replacements: 12, cells: 3) == "Replaced 12 matches in 3 cells.")
         #expect(DataFileController.duplicatesMessage(removed: 1) == "Removed 1 duplicate row.")
         #expect(DataFileController.changedCellsMessage(2) == "Changed 2 cells.")
         #expect(DataFileCountPhrase.raggedRows(1) == "1 row has a different number of fields")
@@ -697,7 +912,7 @@ struct DataFileControllerTests {
         await controller.waitForPendingWork()
         #expect(column(controller, 0) == ["apple", "caf\u{E9}", "zoe"])
         controller.setCell(pageRow: 1, column: 0, text: "漢")
-        controller.selectedRowIndices = []
+        controller.selectRows(pageRows: [])
         let output = url.deletingLastPathComponent().appendingPathComponent("out.csv")
         #expect {
             try controller.write(to: output, typeName: DataFileKind.commaSeparatedType)
@@ -706,6 +921,7 @@ struct DataFileControllerTests {
             return message.contains("Row 2") && message.contains("“name”") && message.contains("“漢”")
         }
         #expect(controller.selectedRowIndices == [1])
+        #expect(controller.gridModel.selectedRowIDs.count == 1)
     }
 
     @Test("An invisible character is named by its code point")
@@ -714,3 +930,23 @@ struct DataFileControllerTests {
         #expect(DataFileController.describe("漢") == "“漢”")
     }
 }
+
+extension GlobalStateSuites {
+    @Suite(.recordingClipboard)
+    @MainActor
+    struct DataFileCopyRowsTests {
+        @Test("Copy Rows writes a NULL or missing cell as empty and a tab or line break in a value as a space")
+        func copyRowsKeepsEachRecordOnOneLine() async throws {
+            let text = "{\"id\":1,\"name\":null,\"note\":\"a\\tb\"}\n{\"id\":2,\"note\":\"line1\\nline2\"}\n"
+            let (controller, _) = try await DataFileFixture.open(data: Data(text.utf8), fileExtension: "jsonl", undoManager: UndoManager())
+            let grid = DataFileFixture.grid(for: controller)
+            controller.selectRows(pageRows: [0, 1])
+
+            grid.copySelectedRows(nil)
+
+            let clipboard = try #require(RecordingClipboard.current)
+            #expect(clipboard.text == "1\t\ta b\n2\t\tline1 line2")
+            #expect(clipboard.gridRows?.rows.last?.last == .text("line1\nline2"))
+        }
+    }
+}
diff --git a/apple/TableProTests/Core/DataFiles/DataFileSelectionSummaryTests.swift b/apple/TableProTests/Core/DataFiles/DataFileSelectionSummaryTests.swift
index cc53e2305e..d5bc4ea58c 100644
--- a/apple/TableProTests/Core/DataFiles/DataFileSelectionSummaryTests.swift
+++ b/apple/TableProTests/Core/DataFiles/DataFileSelectionSummaryTests.swift
@@ -5,25 +5,43 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProNumberFormatting
 import TableProPluginKit
 import TableProTabular
+import TableProTestSupport
 import Testing
 
 @MainActor
 struct DataFileSelectionSummaryTests {
-    /// The coordinator holds its delegate and its table view weakly, so the test holds them.
+    // The grid's controller computes the summary, so the test mounts it in a window and holds both.
     @MainActor
-    private struct MountedGrid {
+    private final class MountedGrid {
         let controller: DataFileController
-        let delegate: DataFileGridDelegate
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-
-        var tracker: SelectionSummaryTracker { coordinator.selectionSummaryTracker }
+        let grid: DataGridViewController
+        let window: NSWindow
+
+        init(controller: DataFileController) {
+            self.controller = controller
+            grid = DataGridViewController(model: controller.gridModel)
+            window = NSWindow(
+                contentRect: NSRect(x: 0, y: 0, width: 600, height: 240),
+                styleMask: [.titled],
+                backing: .buffered,
+                defer: false
+            )
+            window.isReleasedWhenClosed = false
+            window.contentView = grid.view
+            grid.view.layoutSubtreeIfNeeded()
+        }
+
+        var tracker: SelectionSummaryTracker { grid.selectionSummaryTracker }
         var summary: SelectionSummary? { controller.selectionSummary.summary }
+
+        func tearDown() {
+            grid.dismantle()
+            window.contentView = nil
+        }
     }
 
     private let undoManager = UndoManager()
@@ -41,44 +59,10 @@ struct DataFileSelectionSummaryTests {
         await controller.waitForPendingWork()
         #expect(controller.loadState == .loaded)
 
-        let delegate = DataFileGridDelegate(controller: controller)
-        let view = DataGridView(
-            tableRowsProvider: { [controller] in controller.tableRows },
-            changeManager: controller.anyChangeManager,
-            isEditable: controller.isEditable,
-            delegate: delegate,
-            layoutPersister: InMemoryColumnLayoutStore(),
-            selectedRowIndices: .constant([]),
-            sortState: .constant(SortState()),
-            columnLayout: .constant(ColumnLayoutState()),
-            selectionSummary: controller.selectionSummary
-        )
-        let coordinator = view.makeCoordinator()
-        coordinator.tableRowsProvider = { [controller] in controller.tableRows }
-        delegate.dataGridAttach(tableViewCoordinator: coordinator)
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        let tableRows = controller.tableRows
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: tableRows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.updateCache()
-        tableView.reloadData()
-        return MountedGrid(controller: controller, delegate: delegate, tableView: tableView, coordinator: coordinator)
+        let grid = MountedGrid(controller: controller)
+        // The grid attaches its summary on the turn after it mounts.
+        try await waitUntil(timeout: .seconds(5)) { grid.tracker.state === controller.selectionSummary }
+        return grid
     }
 
     private static func firstColumn(rows: ClosedRange<Int>) -> GridSelection {
@@ -92,25 +76,26 @@ struct DataFileSelectionSummaryTests {
     @Test("the window's own column rules are used, so an empty CSV cell is Empty and an integer column is summed")
     func dataFilePolicyIsConsulted() async throws {
         let grid = try await mount("n,label\n1,a\n,b\n3,c\n")
+        defer { grid.tearDown() }
         let id = try #require(grid.controller.columnNames.ids.first)
         #expect(grid.controller.kind(of: id) == .integer)
         #expect(grid.controller.tableRows.rows[1].values[0] == .text(""))
 
-        grid.coordinator.selectionController.update(Self.firstColumn(rows: 0...2))
+        grid.controller.gridModel.setSelection(Self.firstColumn(rows: 0...2))
         await grid.tracker.pendingTask?.value
 
         #expect(grid.summary?.emptyCount == 1)
         #expect(grid.summary?.valueCount == 2)
         #expect(grid.summary?.numbers?.sum.decimal == 4)
-        withExtendedLifetime(grid) {}
     }
 
     @Test("overriding a text column to Integer sums it, and setting it back to automatic stops")
     func kindOverridePublishesNewFigures() async throws {
         let grid = try await mount("code,label\n007,a\n010,b\n3,c\n")
+        defer { grid.tearDown() }
         let id = try #require(grid.controller.columnNames.ids.first)
         #expect(grid.controller.kind(of: id) == .text)
-        grid.coordinator.selectionController.update(Self.firstColumn(rows: 0...2))
+        grid.controller.gridModel.setSelection(Self.firstColumn(rows: 0...2))
         await grid.tracker.pendingTask?.value
         #expect(grid.summary?.valueCount == 3)
         #expect(grid.summary?.numbers == nil)
@@ -124,17 +109,16 @@ struct DataFileSelectionSummaryTests {
         await grid.tracker.pendingTask?.value
         #expect(grid.summary?.numbers == nil)
         #expect(grid.summary?.valueCount == 3)
-        withExtendedLifetime(grid) {}
     }
 
-    /// The kind override is not an undo step of its own; an undo puts back the kinds an earlier edit
-    /// captured, and it reloads the page, which drops the cell selection with it.
+    // The kind override is not an undo step of its own; an undo puts back the kinds an earlier edit captured.
     @Test("undoing back past a kind override leaves no figures computed under the override")
     func undoPastKindOverrideLeavesNoStaleFigures() async throws {
         let grid = try await mount("code,label\n007,a\n010,b\n3,c\n")
+        defer { grid.tearDown() }
         let id = try #require(grid.controller.columnNames.ids.first)
         grid.controller.setCell(pageRow: 0, column: 1, text: "z")
-        grid.coordinator.selectionController.update(Self.firstColumn(rows: 0...2))
+        grid.controller.gridModel.setSelection(Self.firstColumn(rows: 0...2))
         grid.controller.setKindOverride(.integer, for: id)
         await grid.tracker.pendingTask?.value
         #expect(grid.summary?.numbers?.sum.decimal == 20)
@@ -146,6 +130,17 @@ struct DataFileSelectionSummaryTests {
         #expect(grid.controller.kind(of: id) == .text)
         #expect(grid.summary?.numbers == nil)
         #expect(grid.tracker.currentSummary?.numbers == nil)
-        withExtendedLifetime(grid) {}
+    }
+
+    @Test("the status bar's row count follows the grid's selection")
+    func selectedRowsFollowTheGrid() async throws {
+        let grid = try await mount("n,label\n1,a\n2,b\n3,c\n")
+        defer { grid.tearDown() }
+
+        grid.controller.gridModel.setSelection(Self.firstColumn(rows: 1...2))
+        #expect(grid.controller.selectedRowIndices == [1, 2])
+
+        grid.controller.gridModel.clearSelection()
+        #expect(grid.controller.selectedRowIndices.isEmpty)
     }
 }
diff --git a/apple/TableProTests/Core/DataGrid/DataGridRowIdentityCommitTests.swift b/apple/TableProTests/Core/DataGrid/DataGridRowIdentityCommitTests.swift
new file mode 100644
index 0000000000..d898bb6af2
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/DataGridRowIdentityCommitTests.swift
@@ -0,0 +1,247 @@
+//
+//  DataGridRowIdentityCommitTests.swift
+//  TableProTests
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+// Records each commit in a real change manager and writes the rows, the way the data tab's adapter does.
+@MainActor
+private final class ChangeRecordingOwner: DataGridDataSource, DataGridActions {
+    var tableRows: TableRows
+    let manager: DataChangeManager
+    let changeState: AnyChangeManager
+    weak var model: DataGridModel?
+    private(set) var commitCount = 0
+
+    init(_ tableRows: TableRows, manager: DataChangeManager) {
+        self.tableRows = tableRows
+        self.manager = manager
+        changeState = AnyChangeManager(manager)
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        commitCount += 1
+        var writes: [(row: Int, column: Int, value: PluginCellValue)] = []
+        for edit in edits {
+            guard let storageRow = tableRows.index(of: edit.rowID) else { continue }
+            manager.recordCellChange(
+                rowID: edit.rowID,
+                columnIndex: edit.dataIndex,
+                columnName: edit.columnName,
+                oldValue: edit.oldValue,
+                newValue: edit.newValue,
+                originalRow: edit.originalRow,
+                absence: edit.absence,
+                isExpression: edit.isExpression
+            )
+            writes.append((row: storageRow, column: edit.dataIndex, value: edit.newValue))
+        }
+        guard !writes.isEmpty else { return false }
+        model?.apply(tableRows.editMany(writes))
+        return true
+    }
+}
+
+@MainActor
+struct DataGridRowIdentityCommitTests {
+    private static let status = DataGridColumnID(name: "status", occurrence: 0)
+    private static let id = DataGridColumnID(name: "id", occurrence: 0)
+
+    private func makeManager() -> DataChangeManager {
+        let manager = DataChangeManager()
+        manager.configureForTable(
+            tableName: "users",
+            columns: ["id", "status"],
+            primaryKeyColumns: ["id"],
+            databaseType: .mysql,
+            generatedColumns: []
+        )
+        return manager
+    }
+
+    private func makeGrid(manager: DataChangeManager) -> (DataGridModel, ChangeRecordingOwner) {
+        let owner = ChangeRecordingOwner(TableRows.from(
+            queryRows: [
+                [.text("1"), .text("active")],
+                [.text("2"), .text("inactive")],
+                [.text("3"), .text("active")],
+                [.text("4"), .text("inactive")],
+            ],
+            columns: ["id", "status"],
+            columnTypes: [.text(rawType: nil), .text(rawType: nil)]
+        ), manager: manager)
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        let model = DataGridModel(configuration: configuration)
+        model.dataSource = owner
+        model.actions = owner
+        owner.model = model
+        model.reloadRows()
+        return (model, owner)
+    }
+
+    private func filterToInactive(_ model: DataGridModel) {
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["inactive"], includesNull: false), columnName: "status", forColumn: 1)
+        model.setValueFilter(filter)
+    }
+
+    private func edit(_ rowID: RowID, _ column: DataGridColumnID, _ text: String) -> DataGridCellEdit {
+        DataGridCellEdit(rowID: rowID, columnID: column, value: .enteredText(text))
+    }
+
+    @Test("An edit under a value filter lands on the row shown there, and only that row changes")
+    func editUnderFilterLandsOnTheShownRow() throws {
+        let manager = makeManager()
+        let (model, owner) = makeGrid(manager: manager)
+        filterToInactive(model)
+        #expect(model.order.filteredIDs == [.existing(1), .existing(3)])
+        let shown = try #require(model.rowID(at: 1))
+
+        #expect(model.commit([edit(shown, Self.status, "archived")], actionName: "Edit Cell"))
+
+        #expect(manager.isCellModified(rowID: .existing(3), columnIndex: 1))
+        #expect(!manager.isCellModified(rowID: .existing(1), columnIndex: 1))
+        #expect(owner.tableRows.rows[3].values[1] == "archived")
+        #expect(owner.tableRows.rows[1].values[1] == "inactive")
+
+        let statements = try manager.generateSQL()
+        let parameters = statements.first?.parameters ?? []
+        #expect(statements.count == 1)
+        #expect(parameters.count == 2)
+        #expect(parameters.last.flatMap { $0 as? String } == "4")
+    }
+
+    @Test("An edit keeps its row when the filter is cleared and positions move")
+    func editFollowsItsRowAcrossADisplayOrderChange() throws {
+        let manager = makeManager()
+        // The model holds its owner weakly, so the test holds it.
+        let (model, owner) = makeGrid(manager: manager)
+        defer { withExtendedLifetime(owner) {} }
+        filterToInactive(model)
+        let shown = try #require(model.rowID(at: 0))
+
+        model.commit([edit(shown, Self.status, "archived")], actionName: "Edit Cell")
+        model.setValueFilter(GridValueFilterState())
+
+        let index = RowVisualIndex()
+        index.rebuild(from: model.changeState)
+        #expect(!model.order.isFiltered)
+        #expect(model.displayIndex(of: .existing(1)) == 1)
+        #expect(index.visualState(for: .existing(1)).modifiedColumns == [1])
+        #expect(index.visualState(for: .existing(0)).modifiedColumns.isEmpty)
+    }
+
+    @Test("Undoing an edit made under a value filter reverts the row that was edited")
+    func undoUnderFilterRevertsTheEditedRow() throws {
+        let manager = makeManager()
+        let undoManager = UndoManager()
+        undoManager.groupsByEvent = false
+        manager.undoManagerProvider = { undoManager }
+        var captured: UndoResult?
+        manager.onUndoApplied = { captured = $0 }
+        let (model, owner) = makeGrid(manager: manager)
+        filterToInactive(model)
+        let shown = try #require(model.rowID(at: 1))
+
+        model.commit([edit(shown, Self.id, "9")], actionName: "Edit Cell")
+        #expect(owner.tableRows.rows[3].values[0] == "9")
+
+        undoManager.undo()
+        let result = try #require(captured)
+        _ = RowOperationsManager(changeManager: manager).applyUndoResult(result, tableRows: &owner.tableRows)
+
+        #expect(owner.tableRows.rows[3].values[0] == "4")
+        #expect(owner.tableRows.rows[1].values[0] == "2")
+        #expect(!manager.isCellModified(rowID: .existing(3), columnIndex: 0))
+    }
+
+    @Test("A deleted row is recognised at whatever position the filter shows it")
+    func deletedRowIsFoundByIdentity() throws {
+        let manager = makeManager()
+        // The model holds its owner weakly, so the test holds it.
+        let (model, owner) = makeGrid(manager: manager)
+        defer { withExtendedLifetime(owner) {} }
+        manager.recordRowDeletion(rowID: .existing(3), originalRow: ["4", "inactive"])
+        filterToInactive(model)
+
+        let shown = try #require(model.rowID(at: 1))
+        let index = RowVisualIndex()
+        index.rebuild(from: model.changeState)
+
+        #expect(shown == .existing(3))
+        #expect(model.changeState?.isRowDeleted(shown) == true)
+        #expect(model.changeState?.isRowDeleted(.existing(1)) == false)
+        #expect(index.visualState(for: shown).isDeleted)
+    }
+
+    @Test("A commit over the shown rows under a filter writes them and skips a deleted one")
+    func commitOverShownRowsSkipsDeleted() {
+        let manager = makeManager()
+        // The model holds its owner weakly, so the test holds it.
+        let (model, owner) = makeGrid(manager: manager)
+        defer { withExtendedLifetime(owner) {} }
+        filterToInactive(model)
+        manager.recordRowDeletion(rowID: .existing(3), originalRow: ["4", "inactive"])
+
+        let shown = (0..<model.rowCount).compactMap { model.rowID(at: $0) }
+        model.commit(shown.map { edit($0, Self.status, "gone") }, actionName: "Fill Column")
+
+        #expect(manager.isCellModified(rowID: .existing(1), columnIndex: 1))
+        #expect(!manager.isCellModified(rowID: .existing(3), columnIndex: 1))
+        #expect(!manager.isCellModified(rowID: .existing(0), columnIndex: 1))
+        #expect(!manager.isCellModified(rowID: .existing(2), columnIndex: 1))
+    }
+
+    @Test("A commit by row identity writes the record the editor was opened for")
+    func identityCommitWritesTheOpenedRecord() throws {
+        let manager = makeManager()
+        let (model, owner) = makeGrid(manager: manager)
+        let opened = try #require(model.rowID(at: 1))
+
+        filterToInactive(model)
+        model.commit([edit(opened, Self.status, "archived")], actionName: "Edit Cell")
+
+        #expect(opened == .existing(1))
+        #expect(model.rowID(at: 1) == .existing(3))
+        #expect(manager.isCellModified(rowID: .existing(1), columnIndex: 1))
+        #expect(!manager.isCellModified(rowID: .existing(3), columnIndex: 1))
+        #expect(owner.tableRows.rows[1].values[1] == .text("archived"))
+        #expect(owner.tableRows.rows[3].values[1] == .text("inactive"))
+    }
+
+    @Test("A commit by row identity still writes a record the filter is hiding")
+    func identityCommitWritesAHiddenRecord() throws {
+        let manager = makeManager()
+        let (model, owner) = makeGrid(manager: manager)
+        let opened = try #require(model.rowID(at: 0))
+
+        filterToInactive(model)
+        #expect(model.displayIndex(of: opened) == nil)
+        model.commit([edit(opened, Self.status, "archived")], actionName: "Edit Cell")
+
+        #expect(opened == .existing(0))
+        #expect(manager.isCellModified(rowID: .existing(0), columnIndex: 1))
+        #expect(owner.tableRows.rows[0].values[1] == .text("archived"))
+    }
+
+    @Test("A commit naming a record the result no longer holds writes nothing")
+    func identityCommitForAMissingRecordWritesNothing() {
+        let manager = makeManager()
+        let (model, owner) = makeGrid(manager: manager)
+
+        let committed = model.commit([edit(.existing(99), Self.status, "archived")], actionName: "Edit Cell")
+
+        #expect(!committed)
+        #expect(owner.commitCount == 0)
+        #expect(!manager.hasChanges)
+        #expect(owner.tableRows.rows[1].values[1] == .text("inactive"))
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/DataGridChangeTests.swift b/apple/TableProTests/Core/DataGrid/Engine/DataGridChangeTests.swift
new file mode 100644
index 0000000000..a3e6a88bcb
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/DataGridChangeTests.swift
@@ -0,0 +1,83 @@
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+struct DataGridChangeTests {
+    private let rows = TableRows.from(
+        queryRows: (0..<5).map { [PluginCellValue.text("\($0)"), .text("name-\($0)"), .text("mail-\($0)")] },
+        columns: ["id", "name", "email"],
+        columnTypes: [.integer(rawType: nil), .text(rawType: nil), .text(rawType: nil)]
+    )
+
+    private var columns: DataGridColumnSet {
+        DataGridColumnSet(tableRows: rows, layout: ColumnLayoutState())
+    }
+
+    private let filtered = DataGridRowOrder(filteredIDs: [.existing(3), .existing(1)], revision: 1)
+
+    private func change(_ delta: Delta, order: DataGridRowOrder = .unfiltered, columns: DataGridColumnSet? = nil) -> DataGridChange {
+        DataGridChange.from(delta, order: order, rows: rows, columns: columns ?? self.columns)
+    }
+
+    @Test("A full replace reloads and new column metadata rebuilds the columns")
+    func replaceAndColumns() {
+        #expect(change(.fullReplace) == .reload)
+        #expect(change(.columnsReplaced) == .columnsChanged)
+    }
+
+    @Test("Inserts and removals pass through while the order is the storage order")
+    func rowSetChangesUnfiltered() {
+        #expect(change(.rowsInserted(IndexSet([1, 4]))) == .rowsInserted(IndexSet([1, 4])))
+        #expect(change(.rowsRemoved(IndexSet(integer: 2))) == .rowsRemoved(IndexSet(integer: 2)))
+    }
+
+    @Test("Inserts and removals under a filter reload, since they reshape the order")
+    func rowSetChangesFiltered() {
+        #expect(change(.rowsInserted(IndexSet(integer: 0)), order: filtered) == .reload)
+        #expect(change(.rowsRemoved(IndexSet(integer: 3)), order: filtered) == .reload)
+    }
+
+    @Test("A cell change names its display row and display column")
+    func cellChangeMapsToDisplay() {
+        var layout = ColumnLayoutState()
+        layout.columnOrder = ["email", "id", "name"]
+        let reordered = DataGridColumnSet(tableRows: rows, layout: layout)
+
+        #expect(change(.cellChanged(row: 2, column: 2), columns: reordered) == .rowsUpdated(IndexSet(integer: 2), columns: IndexSet(integer: 0)))
+        #expect(change(.cellChanged(row: 2, column: 0), columns: reordered) == .rowsUpdated(IndexSet(integer: 2), columns: IndexSet(integer: 1)))
+    }
+
+    @Test("Cell changes under a filter skip the rows it hides and map the rest")
+    func cellChangesUnderFilter() {
+        let delta = Delta.cellsChanged([
+            CellPosition(row: 1, column: 0),
+            CellPosition(row: 2, column: 0),
+            CellPosition(row: 3, column: 1)
+        ])
+
+        #expect(change(delta, order: filtered) == .rowsUpdated(IndexSet([0, 1]), columns: IndexSet([0, 1])))
+    }
+
+    @Test("Changes only to hidden or missing rows are no change at all")
+    func changesOutsideTheOrderAreNone() {
+        #expect(change(.cellChanged(row: 2, column: 0), order: filtered).isNone)
+        #expect(change(.cellChanged(row: 40, column: 0)).isNone)
+        #expect(change(.none).isNone)
+    }
+
+    @Test("An insert or removal moves every row from its first index to the end, and an update moves none")
+    func insertsAndRemovalsMoveTheRowsBelow() {
+        #expect(DataGridChange.rowsInserted(IndexSet([2, 4])).movedRows(rowCount: 7) == IndexSet(integersIn: 2..<7))
+        #expect(DataGridChange.rowsRemoved(IndexSet([1, 3])).movedRows(rowCount: 5) == IndexSet(integersIn: 1..<5))
+        #expect(DataGridChange.rowsRemoved(IndexSet(integer: 4)).movedRows(rowCount: 4).isEmpty)
+        #expect(DataGridChange.rowsUpdated(IndexSet(integer: 1), columns: nil).movedRows(rowCount: 5).isEmpty)
+        #expect(DataGridChange.reload.movedRows(rowCount: 5).isEmpty)
+    }
+
+    @Test("A real update is never mistaken for no change")
+    func updateIsNotNone() {
+        #expect(!change(.cellChanged(row: 0, column: 0)).isNone)
+        #expect(!DataGridChange.reload.isNone)
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/DataGridColumnSetTests.swift b/apple/TableProTests/Core/DataGrid/Engine/DataGridColumnSetTests.swift
new file mode 100644
index 0000000000..dde81bef63
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/DataGridColumnSetTests.swift
@@ -0,0 +1,123 @@
+import Foundation
+@testable import TablePro
+import Testing
+
+struct DataGridColumnSetTests {
+    private func rows(_ columns: [String], types: [ColumnType]? = nil, comments: [String: String] = [:]) -> TableRows {
+        TableRows(
+            columns: columns,
+            columnTypes: types ?? columns.map { _ in .text(rawType: "TEXT") },
+            columnComments: comments
+        )
+    }
+
+    private func layout(order: [String]? = nil, hidden: Set<String> = [], frozen: Int = 0) -> ColumnLayoutState {
+        var layout = ColumnLayoutState()
+        layout.columnOrder = order
+        layout.hiddenColumns = hidden
+        layout.frozenColumnCount = frozen
+        return layout
+    }
+
+    private func id(_ name: String, _ occurrence: Int = 0) -> DataGridColumnID {
+        DataGridColumnID(name: name, occurrence: occurrence)
+    }
+
+    @Test("A repeated name counts its occurrences, and each column keeps a key of its own")
+    func repeatedNamesCountOccurrences() {
+        let ids = DataGridColumnSet.columnIDs(for: ["id", "name", "id", "id#1"])
+
+        #expect(ids == [id("id"), id("name"), id("id", 1), id("id#1")])
+        #expect(Set(ids.map { $0.stringValue }).count == 4)
+    }
+
+    @Test("Columns come in data order with their type and comment")
+    func columnsCarryTypeAndComment() {
+        let set = DataGridColumnSet(
+            tableRows: rows(["id", "name"], types: [.integer(rawType: "INT"), .text(rawType: nil)], comments: ["name": "Full name"]),
+            layout: ColumnLayoutState()
+        )
+
+        #expect(set.count == 2)
+        #expect(set.column(at: 0) == DataGridColumn(id: id("id"), dataIndex: 0, type: .integer(rawType: "INT"), comment: nil))
+        #expect(set.column(at: 1) == DataGridColumn(id: id("name"), dataIndex: 1, type: .text(rawType: nil), comment: "Full name"))
+        #expect(set.column(at: 1)?.name == "name")
+    }
+
+    @Test("A hidden column leaves the set and the others keep their data index")
+    func hiddenColumnsLeave() {
+        let set = DataGridColumnSet(tableRows: rows(["id", "name", "email"]), layout: layout(hidden: ["name"]))
+
+        #expect(set.orderedNames == ["id", "email"])
+        #expect(set.column(at: 1)?.dataIndex == 2)
+        #expect(set.displayPosition(ofDataIndex: 1) == nil)
+        #expect(set.displayPosition(ofDataIndex: 2) == 1)
+        #expect(set.column(id: id("name")) == nil)
+    }
+
+    @Test("A saved order places the columns it names and appends the rest in data order")
+    func savedOrderApplies() {
+        let set = DataGridColumnSet(tableRows: rows(["id", "name", "email"]), layout: layout(order: ["email", "ghost", "id"]))
+
+        #expect(set.orderedNames == ["email", "id", "name"])
+        #expect(set.displayPosition(of: id("email")) == 0)
+        #expect(set.displayPosition(ofDataIndex: 0) == 1)
+        #expect(set.dataIndex(atDisplayPosition: 0) == 2)
+    }
+
+    @Test("A saved order gives repeated names their occurrences in turn")
+    func savedOrderWithRepeatedNames() {
+        let set = DataGridColumnSet(tableRows: rows(["a", "b", "a"]), layout: layout(order: ["b", "a"]))
+
+        #expect(set.columns.map { $0.id } == [id("b"), id("a"), id("a", 1)])
+        #expect(set.displayPosition(ofDataIndex: 2) == 2)
+    }
+
+    @Test("The frozen count clamps to the presented columns")
+    func frozenCountClamps() {
+        let over = DataGridColumnSet(tableRows: rows(["a", "b", "c"]), layout: layout(hidden: ["c"], frozen: 5))
+        let under = DataGridColumnSet(columns: over.columns, frozenCount: -2)
+
+        #expect(over.frozenCount == 2)
+        #expect(over.frozenColumns.count == 2)
+        #expect(under.frozenCount == 0)
+        #expect(under.frozenColumns.isEmpty)
+    }
+
+    @Test("Only the leading frozen positions read as frozen")
+    func frozenPositions() {
+        let set = DataGridColumnSet(tableRows: rows(["a", "b", "c"]), layout: layout(frozen: 1))
+
+        #expect(set.isFrozen(displayPosition: 0))
+        #expect(!set.isFrozen(displayPosition: 1))
+        #expect(!set.isFrozen(displayPosition: -1))
+        #expect(set.frozenColumns.map { $0.name } == ["a"])
+        #expect(set.withFrozenCount(2).frozenCount == 2)
+        #expect(set.withFrozenCount(9).frozenCount == 3)
+    }
+
+    @Test("Positions outside the set name no column")
+    func outOfRangeLookups() {
+        let set = DataGridColumnSet(tableRows: rows(["a", "b"]), layout: ColumnLayoutState())
+
+        #expect(set.column(at: -1) == nil)
+        #expect(set.column(at: 2) == nil)
+        #expect(set.dataIndex(atDisplayPosition: 5) == nil)
+        #expect(DataGridColumnSet.empty.isEmpty)
+        #expect(DataGridColumnSet.empty.column(at: 0) == nil)
+    }
+
+    @Test("Moving a column reorders the positions and keeps the frozen count")
+    func movingReorders() {
+        let set = DataGridColumnSet(tableRows: rows(["a", "b", "c"]), layout: layout(frozen: 1))
+
+        let moved = set.moving(from: 2, to: 0)
+
+        #expect(moved.orderedNames == ["c", "a", "b"])
+        #expect(moved.frozenCount == 1)
+        #expect(moved.displayPosition(of: id("c")) == 0)
+        #expect(moved.displayPosition(ofDataIndex: 0) == 1)
+        #expect(set.moving(from: 0, to: 7) == set)
+        #expect(set.moving(from: 1, to: 1) == set)
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/DataGridModelTests.swift b/apple/TableProTests/Core/DataGrid/Engine/DataGridModelTests.swift
new file mode 100644
index 0000000000..e0dfd98b46
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/DataGridModelTests.swift
@@ -0,0 +1,387 @@
+import AppKit
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+private final class FakeChangeManager: ChangeManaging {
+    var hasChanges: Bool { false }
+    var reloadVersion: Int { 0 }
+    var canRedo: Bool { false }
+    var rowChanges: [RowChange] { [] }
+    var insertedRowIDs: Set<RowID> { [] }
+    var deletedRowIDs: Set<RowID> = []
+    var generatedColumns: Set<String> = []
+
+    func isRowDeleted(_ rowID: RowID) -> Bool {
+        deletedRowIDs.contains(rowID)
+    }
+
+    func recordCellChange(
+        rowID: RowID,
+        columnIndex: Int,
+        columnName: String,
+        oldValue: PluginCellValue,
+        newValue: PluginCellValue,
+        originalRow: [PluginCellValue]?
+    ) {}
+
+    func undoRowDeletion(rowID: RowID) {}
+}
+
+@MainActor
+private final class FakeGridOwner: DataGridDataSource, DataGridActions {
+    var tableRows: TableRows
+    let changes = FakeChangeManager()
+    let changeState: AnyChangeManager
+    private(set) var commits: [(edits: [DataGridResolvedEdit], actionName: String)] = []
+
+    init(_ tableRows: TableRows) {
+        self.tableRows = tableRows
+        self.changeState = AnyChangeManager(changes)
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        commits.append((edits, actionName))
+        return true
+    }
+}
+
+@MainActor
+private final class FakeMountedView: DataGridMountedView {
+    var changes: [DataGridChange] = []
+
+    func apply(_ change: DataGridChange) {
+        changes.append(change)
+    }
+
+    func selectionDidChange() {}
+    func configurationDidChange() {}
+    func reveal(row: Int, displayColumn: Int?) {}
+    func revealColumn(_ displayColumn: Int) {}
+    func sortDidChange() {}
+    func summaryRulesDidChange() {}
+    func viewportSample() -> (row: Int, offset: CGFloat)? { nil }
+    func beginEditing(row: Int, displayColumn: Int) -> Bool { false }
+    var isEditing: Bool { false }
+    func commitEditing() -> Bool { true }
+    func discardEditing() {}
+    func focus() -> Bool { false }
+    func anchor(forColumn displayColumn: Int) -> (view: NSView, rect: NSRect)? { nil }
+}
+
+@MainActor
+struct DataGridModelTests {
+    private static let people: TableRows = TableRows.from(
+        queryRows: [
+            ["0", "ann", "30"],
+            ["1", "bob", "41"],
+            ["2", "cid", "25"],
+            ["3", "dee", "33"],
+            ["4", "eve", "52"]
+        ],
+        columns: ["id", "name", "age"],
+        columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .integer(rawType: "INT")]
+    )
+
+    private func mount(
+        _ owner: FakeGridOwner,
+        configuration: DataGridConfiguration = DataGridConfiguration()
+    ) -> (DataGridModel, FakeMountedView) {
+        let model = DataGridModel(configuration: configuration)
+        model.dataSource = owner
+        model.actions = owner
+        let view = FakeMountedView()
+        model.attach(view)
+        model.reloadRows()
+        view.changes.removeAll()
+        return (model, view)
+    }
+
+    private func cell(_ row: Int, _ column: Int) -> GridSelection {
+        GridSelectionReducer.single(GridCoord(row: row, displayColumn: column))
+    }
+
+    private func nameFilter(_ names: Set<String>) -> GridValueFilterState {
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: names, includesNull: false), columnName: "name", forColumn: 1)
+        return filter
+    }
+
+    private func rows(_ table: TableRows, order ids: [Int]) -> TableRows {
+        var reordered = table
+        reordered.reorderRows(ContiguousArray(ids.compactMap { table.row(withID: .existing($0)) }))
+        return reordered
+    }
+
+    // MARK: - Selection by identity
+
+    @Test("The selection follows its row through a value filter and back")
+    func selectionFollowsRowThroughFilter() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, view) = mount(owner)
+        model.setSelection(cell(3, 1))
+
+        model.setValueFilter(nameFilter(["bob", "dee"]))
+
+        #expect(model.rowCount == 2)
+        #expect(model.selection == cell(1, 1))
+        #expect(model.activeCell?.rowID == .existing(3))
+        #expect(view.changes == [.reload])
+
+        model.setValueFilter(GridValueFilterState())
+
+        #expect(model.selection == cell(3, 1))
+    }
+
+    @Test("The selection follows its row when the rows come back in a new order")
+    func selectionFollowsRowThroughReload() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, view) = mount(owner)
+        model.setSelection(cell(3, 1))
+
+        owner.tableRows = rows(Self.people, order: [4, 3, 2, 1, 0])
+        model.reloadRows()
+
+        #expect(model.selection == cell(1, 1))
+        #expect(model.selectedRowIDs == [.existing(3)])
+        #expect(view.changes == [.reload])
+    }
+
+    @Test("A reload without the selected row leaves nothing selected")
+    func reloadWithoutSelectedRowClears() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, _) = mount(owner)
+        model.setSelection(cell(3, 1))
+
+        owner.tableRows = rows(Self.people, order: [0, 1, 2, 4])
+        model.reloadRows()
+
+        #expect(model.selection == .empty)
+    }
+
+    @Test("Removed rows leave the selection and reach the view as a removal")
+    func removedRowsLeaveSelection() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, view) = mount(owner)
+        model.selectRows([.existing(1), .existing(2), .existing(3)])
+
+        let delta = owner.tableRows.remove(rowIDs: [.existing(2)])
+        model.apply(delta)
+
+        #expect(model.selectedRowIDs == [.existing(1), .existing(3)])
+        #expect(model.selection.rectangles == [GridRect(rows: 1...2, columns: 0...2)])
+        #expect(view.changes == [.rowsRemoved(IndexSet(integer: 2))])
+    }
+
+    @Test("An inserted row pushes the selection down with its row")
+    func insertedRowShiftsSelection() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, view) = mount(owner)
+        model.setSelection(cell(3, 1))
+
+        let delta = owner.tableRows.insertInsertedRow(at: 0, values: ["9", "new", "1"])
+        model.apply(delta)
+
+        #expect(model.selection == cell(4, 1))
+        #expect(view.changes == [.rowsInserted(IndexSet(integer: 0))])
+    }
+
+    @Test("Selecting rows by identity selects them whole and stores them by identity")
+    func selectRowsByIdentity() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, _) = mount(owner)
+
+        model.selectRows([.existing(4), .existing(0)])
+
+        #expect(model.selection.rectangles == [GridRect(rows: 0...0, columns: 0...2), GridRect(rows: 4...4, columns: 0...2)])
+        #expect(model.store.selectionSnapshot.rowIDs == [.existing(0), .existing(4)])
+    }
+
+    @Test("A selection past the rows is clamped away")
+    func setSelectionClamps() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, _) = mount(owner)
+
+        model.setSelection(cell(99, 1))
+
+        #expect(model.selection == .empty)
+    }
+
+    // MARK: - Changes under a filter
+
+    @Test("A cell edit that keeps its row in the filter repaints only that row")
+    func cellEditUnderFilterRepaintsRow() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, view) = mount(owner)
+        model.setValueFilter(nameFilter(["bob", "dee"]))
+        view.changes.removeAll()
+
+        model.apply(owner.tableRows.edit(row: 3, column: 2, value: .text("34")))
+
+        #expect(view.changes == [.rowsUpdated(IndexSet(integer: 1), columns: IndexSet(integer: 2))])
+    }
+
+    @Test("A cell edit that no longer matches the filter keeps its row until the filter changes")
+    func cellEditLeavingFilterKeepsTheRow() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, view) = mount(owner)
+        model.setValueFilter(nameFilter(["bob", "dee"]))
+        view.changes.removeAll()
+
+        model.apply(owner.tableRows.edit(row: 3, column: 1, value: .text("zed")))
+
+        #expect(view.changes == [.rowsUpdated(IndexSet(integer: 1), columns: IndexSet(integer: 1))])
+        #expect(model.rowCount == 2)
+        #expect(model.rowID(at: 1) == .existing(3))
+    }
+
+    // MARK: - Commit
+
+    @Test("A commit resolves entered text and hands the writable edits over in one batch")
+    func commitResolvesAndBatches() throws {
+        let table = TableRows.from(
+            queryRows: [
+                ["1", "ann", "30", "x", "g"],
+                ["2", "bob", "41", "y", "h"],
+                ["3", "cid", "25", "z", "i"],
+                ["4", "dee", "33", "w", "j"]
+            ],
+            columns: ["id", "name", "age", "locked", "gen"],
+            columnTypes: [
+                .integer(rawType: "INT"), .text(rawType: "TEXT"), .integer(rawType: "INT"),
+                .text(rawType: "TEXT"), .text(rawType: "TEXT")
+            ],
+            unloadedCells: [2: [1: 2_048]]
+        )
+        let owner = FakeGridOwner(table)
+        owner.changes.generatedColumns = ["gen"]
+        owner.changes.deletedRowIDs = [.existing(1)]
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        configuration.lockedColumns = ["locked"]
+        let (model, _) = mount(owner, configuration: configuration)
+
+        func edit(_ row: Int, _ column: String, _ text: String) -> DataGridCellEdit {
+            DataGridCellEdit(rowID: .existing(row), columnID: DataGridColumnID(name: column, occurrence: 0), value: .enteredText(text))
+        }
+
+        let committed = model.commit([
+            edit(0, "name", "anna"),
+            edit(0, "age", ""),
+            edit(3, "name", ""),
+            edit(0, "id", "1"),
+            edit(0, "locked", "q"),
+            edit(0, "gen", "q"),
+            edit(2, "name", "q"),
+            edit(1, "name", "q")
+        ], actionName: "Edit Cells")
+
+        #expect(committed)
+        try #require(owner.commits.count == 1)
+        #expect(owner.commits[0].actionName == "Edit Cells")
+        let firstRow: [PluginCellValue] = ["1", "ann", "30", "x", "g"]
+        #expect(owner.commits[0].edits == [
+            DataGridResolvedEdit(
+                rowID: .existing(0), dataIndex: 1, columnName: "name",
+                oldValue: .text("ann"), newValue: .text("anna"),
+                originalRow: firstRow, absence: FieldAbsence(), isExpression: false
+            ),
+            DataGridResolvedEdit(
+                rowID: .existing(0), dataIndex: 2, columnName: "age",
+                oldValue: .text("30"), newValue: .null,
+                originalRow: firstRow, absence: FieldAbsence(), isExpression: false
+            ),
+            DataGridResolvedEdit(
+                rowID: .existing(3), dataIndex: 1, columnName: "name",
+                oldValue: .text("dee"), newValue: .text(""),
+                originalRow: ["4", "dee", "33", "w", "j"], absence: FieldAbsence(), isExpression: false
+            )
+        ])
+
+        #expect(!model.commit([edit(0, "id", "1"), edit(0, "gen", "q")], actionName: "Edit Cells"))
+        #expect(owner.commits.count == 1)
+    }
+
+    @Test("A grid that is not editable commits nothing")
+    func readOnlyGridCommitsNothing() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, _) = mount(owner)
+
+        let committed = model.commit(
+            [DataGridCellEdit(rowID: .existing(0), columnID: DataGridColumnID(name: "name", occurrence: 0), value: .enteredText("x"))],
+            actionName: "Edit Cell"
+        )
+
+        #expect(!committed)
+        #expect(owner.commits.isEmpty)
+    }
+
+    // MARK: - Columns and formats
+
+    @Test("Reordering and freezing columns keeps the selection on the same column")
+    func columnLayoutKeepsSelection() {
+        let owner = FakeGridOwner(Self.people)
+        let (model, view) = mount(owner)
+        model.setSelection(cell(1, 2))
+
+        model.updateColumnLayout {
+            $0.columnOrder = ["age", "id", "name"]
+            $0.frozenColumnCount = 1
+        }
+
+        #expect(model.columns.orderedNames == ["age", "id", "name"])
+        #expect(model.columns.frozenCount == 1)
+        #expect(model.selection == cell(1, 0))
+        #expect(model.activeCell?.column.name == "age")
+        #expect(view.changes == [.columnsChanged])
+
+        model.updateColumnLayout { $0.frozenColumnCount = 2 }
+
+        #expect(model.columns.frozenCount == 2)
+        #expect(model.selection == cell(1, 0))
+    }
+
+    @Test("A new display format on a filtered column keeps the rows the user picked")
+    func displayFormatRemapsPickedValues() throws {
+        let owner = FakeGridOwner(TableRows.from(
+            queryRows: [["0", "0"], ["1", "5"]],
+            columns: ["id", "ts"],
+            columnTypes: [.integer(rawType: "INT"), .integer(rawType: "INT")]
+        ))
+        let (model, view) = mount(owner)
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["0"], includesNull: false), columnName: "ts", forColumn: 1)
+        model.setValueFilter(filter)
+        #expect(model.rowCount == 1)
+        view.changes.removeAll()
+        let column = try #require(model.columns.column(at: 1))
+
+        model.setDisplayFormat(.unixTimestamp, for: column)
+
+        #expect(model.displayFormat(for: column) == .unixTimestamp)
+        #expect(model.rowCount == 1)
+        #expect(model.rowID(at: 0) == .existing(0))
+        #expect(model.store.valueFilter.filter(forColumn: 1)?.selectedValues.contains("0") == false)
+        #expect(view.changes == [.reload])
+    }
+
+    @Test("A new display format without a filter repaints that column only")
+    func displayFormatRepaintsColumn() throws {
+        let owner = FakeGridOwner(TableRows.from(
+            queryRows: [["0", "0"], ["1", "5"]],
+            columns: ["id", "ts"],
+            columnTypes: [.integer(rawType: "INT"), .integer(rawType: "INT")]
+        ))
+        let (model, view) = mount(owner)
+        let column = try #require(model.columns.column(at: 1))
+
+        model.setDisplayFormat(.unixTimestamp, for: column)
+
+        #expect(view.changes == [.rowsUpdated(IndexSet(integersIn: 0..<2), columns: IndexSet(integer: 1))])
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/DataGridRowOrderTests.swift b/apple/TableProTests/Core/DataGrid/Engine/DataGridRowOrderTests.swift
new file mode 100644
index 0000000000..6a6166c657
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/DataGridRowOrderTests.swift
@@ -0,0 +1,88 @@
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+struct DataGridRowOrderTests {
+    private let rows = TableRows.from(
+        queryRows: (0..<5).map { [PluginCellValue.text("\($0)")] },
+        columns: ["id"],
+        columnTypes: [.integer(rawType: nil)]
+    )
+
+    @Test("With no filter the display order is the storage order")
+    func unfilteredReadsStorage() {
+        let order = DataGridRowOrder.unfiltered
+
+        #expect(!order.isFiltered)
+        #expect(order.count(in: rows) == 5)
+        #expect(order.rowID(at: 2, in: rows) == .existing(2))
+        #expect(order.storageIndex(at: 4, in: rows) == 4)
+        #expect(order.row(at: 1, in: rows)?.id == .existing(1))
+        #expect(order.displayIndex(of: .existing(3), in: rows) == 3)
+        #expect(order.displayIndex(ofStorageIndex: 3, in: rows) == 3)
+    }
+
+    @Test("A filtered order reads its own list of rows")
+    func filteredReadsItsList() {
+        let order = DataGridRowOrder(filteredIDs: [.existing(4), .existing(1)], revision: 1)
+
+        #expect(order.isFiltered)
+        #expect(order.count(in: rows) == 2)
+        #expect(order.rowID(at: 0, in: rows) == .existing(4))
+        #expect(order.storageIndex(at: 0, in: rows) == 4)
+        #expect(order.row(at: 1, in: rows)?.id == .existing(1))
+        #expect(order.displayIndex(of: .existing(1), in: rows) == 1)
+        #expect(order.displayIndex(ofStorageIndex: 4, in: rows) == 0)
+    }
+
+    @Test("A row the filter leaves out has no display position")
+    func filteredOutRowHasNoPosition() {
+        let order = DataGridRowOrder(filteredIDs: [.existing(4), .existing(1)], revision: 1)
+
+        #expect(order.displayIndex(of: .existing(2), in: rows) == nil)
+        #expect(order.displayIndex(ofStorageIndex: 2, in: rows) == nil)
+    }
+
+    @Test("A filter that keeps nothing still counts as a filter")
+    func emptyFilterIsFiltered() {
+        let order = DataGridRowOrder(filteredIDs: [], revision: 1)
+
+        #expect(order.isFiltered)
+        #expect(order.count(in: rows) == 0)
+        #expect(order.rowID(at: 0, in: rows) == nil)
+        #expect(order.displayIndex(of: .existing(0), in: rows) == nil)
+    }
+
+    @Test("Positions outside the order resolve nothing")
+    func outOfRangePositions() {
+        let filtered = DataGridRowOrder(filteredIDs: [.existing(0)], revision: 1)
+
+        for order in [DataGridRowOrder.unfiltered, filtered] {
+            #expect(order.rowID(at: -1, in: rows) == nil)
+            #expect(order.rowID(at: 5, in: rows) == nil)
+            #expect(order.storageIndex(at: 9, in: rows) == nil)
+            #expect(order.displayIndex(ofStorageIndex: -1, in: rows) == nil)
+            #expect(order.displayIndex(ofStorageIndex: 5, in: rows) == nil)
+        }
+    }
+
+    @Test("Batch conversions skip what the order does not hold")
+    func batchConversions() {
+        let order = DataGridRowOrder(filteredIDs: [.existing(4), .existing(1)], revision: 1)
+
+        #expect(order.rowIDs(atDisplayIndexes: IndexSet([0, 1, 9]), in: rows) == [.existing(4), .existing(1)])
+        #expect(order.displayIndexes(of: [.existing(1), .existing(3)], in: rows) == IndexSet(integer: 1))
+        #expect(DataGridRowOrder.unfiltered.displayIndexes(of: [.existing(3), .inserted(UUID())], in: rows) == IndexSet(integer: 3))
+    }
+
+    @Test("A row inserted into storage is found by its identity")
+    func insertedRowsResolveByIdentity() {
+        var grown = rows
+        let id = RowID.inserted(UUID())
+        grown.insertInsertedRow(at: 0, id: id, values: [.text("new")])
+
+        #expect(DataGridRowOrder.unfiltered.displayIndex(of: id, in: grown) == 0)
+        #expect(DataGridRowOrder.unfiltered.displayIndex(of: .existing(0), in: grown) == 1)
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/GridDatasetFindTests.swift b/apple/TableProTests/Core/DataGrid/Engine/GridDatasetFindTests.swift
new file mode 100644
index 0000000000..05aeaa4ec9
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/GridDatasetFindTests.swift
@@ -0,0 +1,469 @@
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import TableProTabular
+import TableProTabularIO
+import TableProTestSupport
+import Testing
+
+// Holds ten rows and shows four at a time, as a data file shows a page of its rows.
+@MainActor
+private final class PagedFindOwner: DataGridDataSource, DataGridActions, DataGridDatasetFinding {
+    static let columns = ["name", "city"]
+
+    private(set) var values: [[String]]
+    let pageSize: Int
+    weak var model: DataGridModel?
+    var gate: AsyncGate?
+    private(set) var pageOffset = 0
+    private(set) var page = TableRows()
+    private(set) var searches: [GridDatasetFindQuery] = []
+    private(set) var replaceAllQueries: [GridDatasetFindQuery] = []
+    private(set) var ownerCommits = 0
+    private(set) var gridCommits = 0
+    private let changeState = AnyChangeManager(DataFileChangeManager())
+
+    init(_ values: [[String]], pageSize: Int) {
+        self.values = values
+        self.pageSize = pageSize
+        rebuildPage()
+    }
+
+    var gridRows: TableRows { page }
+    var gridChangeState: AnyChangeManager { changeState }
+    var gridRowNumberOffset: Int { pageOffset }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        gridCommits += 1
+        return true
+    }
+
+    func gridFindAll(_ query: GridDatasetFindQuery) async throws -> [GridFindState.Match] {
+        searches.append(query)
+        if let gate {
+            await gate.wait()
+        }
+        return matches(for: query)
+    }
+
+    func gridDisplayPosition(of rowID: RowID) -> Int? {
+        guard case .existing(let index) = rowID, values.indices.contains(index) else { return nil }
+        return index
+    }
+
+    func gridLoadRow(_ rowID: RowID) -> Bool {
+        guard let position = gridDisplayPosition(of: rowID) else { return false }
+        let offset = (position / pageSize) * pageSize
+        if offset != pageOffset {
+            pageOffset = offset
+            reload()
+        }
+        return true
+    }
+
+    func gridReplace(_ match: GridFindState.Match, query: GridDatasetFindQuery, with template: String) -> Bool {
+        guard case .existing(let index) = match.rowID, let column = dataIndex(of: match.columnID) else { return false }
+        let original = values[index][column]
+        let replaced = original.replacingOccurrences(of: query.term, with: template, options: .caseInsensitive)
+        guard replaced != original else { return false }
+        values[index][column] = replaced
+        ownerCommits += 1
+        datasetDidChange()
+        return true
+    }
+
+    func gridReplaceAll(_ query: GridDatasetFindQuery, with template: String) {
+        replaceAllQueries.append(query)
+        for match in matches(for: query) {
+            guard case .existing(let index) = match.rowID, let column = dataIndex(of: match.columnID) else { continue }
+            values[index][column] = values[index][column]
+                .replacingOccurrences(of: query.term, with: template, options: .caseInsensitive)
+        }
+        ownerCommits += 1
+        datasetDidChange()
+    }
+
+    // An edit the grid did not make, such as an undo.
+    func edit(row: Int, column: Int, to text: String) {
+        values[row][column] = text
+        datasetDidChange()
+    }
+
+    private func matches(for query: GridDatasetFindQuery) -> [GridFindState.Match] {
+        var found: [GridFindState.Match] = []
+        for (index, row) in values.enumerated() {
+            for column in query.columns {
+                guard let dataIndex = dataIndex(of: column),
+                      row[dataIndex].localizedCaseInsensitiveContains(query.term) else { continue }
+                found.append(GridFindState.Match(rowID: .existing(index), columnID: column))
+            }
+        }
+        return found
+    }
+
+    private func dataIndex(of column: DataGridColumnID) -> Int? {
+        DataGridColumnSet.columnIDs(for: Self.columns).firstIndex(of: column)
+    }
+
+    private func datasetDidChange() {
+        reload()
+        model?.findDatasetDidChange()
+    }
+
+    private func reload() {
+        rebuildPage()
+        model?.reloadRows()
+    }
+
+    private func rebuildPage() {
+        var rows = ContiguousArray<Row>()
+        for index in pageOffset..<min(pageOffset + pageSize, values.count) {
+            rows.append(Row(id: .existing(index), values: ContiguousArray(values[index].map { PluginCellValue.text($0) })))
+        }
+        page = TableRows(
+            rows: rows,
+            columns: Self.columns,
+            columnTypes: Self.columns.map { _ in ColumnType.text(rawType: "TEXT") }
+        )
+    }
+}
+
+@MainActor
+struct GridDatasetFindTests {
+    private static let rows = [
+        ["ann", "Paris"], ["bob", "Lyon"], ["cid", "Paris"], ["dan", "Nice"],
+        ["eve", "Rome"], ["fay", "Paris"], ["gus", "Oslo"], ["hal", "Bern"],
+        ["ivy", "Paris"], ["jon", "Lima"],
+    ]
+
+    private static let name = DataGridColumnID(name: "name", occurrence: 0)
+    private static let city = DataGridColumnID(name: "city", occurrence: 0)
+
+    private func mount(editable: Bool = false, commands: Set<DataGridCommand> = []) -> (DataGridModel, PagedFindOwner) {
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = editable
+        configuration.commands = commands
+        let owner = PagedFindOwner(Self.rows, pageSize: 4)
+        let model = DataGridModel(configuration: configuration)
+        model.dataSource = owner
+        model.actions = owner
+        model.datasetFinder = owner
+        owner.model = model
+        model.reloadRows()
+        return (model, owner)
+    }
+
+    private func search(_ model: DataGridModel, _ term: String, replacement: String? = nil) async {
+        model.showFind(replace: replacement != nil)
+        model.find.term = term
+        if let replacement {
+            model.find.replacement = replacement
+        }
+        model.findQueryDidChange()
+        await model.findSearchSettled()
+    }
+
+    private func match(_ row: Int) -> GridFindState.Match {
+        GridFindState.Match(rowID: .existing(row), columnID: Self.city)
+    }
+
+    // A find match selects its row with the cursor on the matched cell, as a click does.
+    private func cell(_ row: Int, _ column: Int, in model: DataGridModel) -> GridSelection {
+        GridSelectionReducer.cursor(
+            GridCoord(row: row, displayColumn: column),
+            in: GridSelectionContext(rowCount: model.rowCount, columnCount: model.columns.count)
+        )
+    }
+
+    @Test("The count covers every row the owner holds, not the loaded page")
+    func countCoversEveryRow() async {
+        let (model, owner) = mount(commands: [.searchAllRows])
+
+        await search(model, "paris")
+
+        #expect(model.find.matches == [match(0), match(2), match(5), match(8)])
+        #expect(model.find.currentIndex == 0)
+        #expect(model.find.isSearching == false)
+        #expect(owner.searches.map { $0.columns } == [[Self.name, Self.city]])
+        #expect(model.offersSearchAllRows == false)
+    }
+
+    @Test("Find Next across a page boundary loads that page and selects the cell")
+    func findNextCrossesPage() async {
+        let (model, owner) = mount()
+        await search(model, "paris")
+        #expect(model.selection == cell(0, 1, in: model))
+
+        model.findNext()
+        #expect(owner.pageOffset == 0)
+        #expect(model.selection == cell(2, 1, in: model))
+
+        model.findNext()
+        #expect(owner.pageOffset == 4)
+        #expect(model.selection == cell(1, 1, in: model))
+        #expect(model.activeCell?.rowID == .existing(5))
+        #expect(model.find.currentIndex == 2)
+
+        model.findNext()
+        model.findNext()
+        #expect(owner.pageOffset == 0)
+        #expect(model.selection == cell(0, 1, in: model))
+        #expect(model.find.currentIndex == 0)
+        #expect(owner.searches.count == 1)
+    }
+
+    @Test("Find Previous from the first match wraps to the last page")
+    func findPreviousWraps() async {
+        let (model, owner) = mount()
+        await search(model, "paris")
+
+        model.findPrevious()
+
+        #expect(owner.pageOffset == 8)
+        #expect(model.activeCell?.rowID == .existing(8))
+        #expect(model.find.currentIndex == 3)
+    }
+
+    @Test("Find Next starts from where the user moved the cursor")
+    func findNextFromCursor() async {
+        let (model, owner) = mount()
+        await search(model, "paris")
+        model.setSelection(cell(3, 0, in: model))
+
+        model.findNext()
+
+        #expect(owner.pageOffset == 4)
+        #expect(model.activeCell?.rowID == .existing(5))
+        #expect(model.find.currentIndex == 2)
+    }
+
+    @Test("A new search lands on the first match from the cursor, on the page that holds it")
+    func searchStartsFromCursor() async {
+        let (model, owner) = mount()
+        let loaded = owner.gridLoadRow(.existing(6))
+        #expect(loaded)
+        model.setSelection(cell(2, 0, in: model))
+
+        await search(model, "paris")
+
+        #expect(model.find.currentIndex == 3)
+        #expect(owner.pageOffset == 8)
+        #expect(model.selection == cell(0, 1, in: model))
+    }
+
+    @Test("A change in the owner's rows searches again and keeps the current match")
+    func datasetChangeKeepsCurrentMatch() async {
+        let (model, owner) = mount()
+        await search(model, "paris")
+        model.findNext()
+        #expect(model.find.currentMatch == match(2))
+
+        owner.edit(row: 1, column: 1, to: "Paris")
+        await model.findSearchSettled()
+
+        #expect(owner.searches.count == 2)
+        #expect(model.find.matches == [match(0), match(1), match(2), match(5), match(8)])
+        #expect(model.find.currentMatch == match(2))
+    }
+
+    @Test("Replace writes through the owner and moves to the next match on its page")
+    func replaceMovesToNextMatch() async {
+        let (model, owner) = mount(editable: true)
+        await search(model, "paris", replacement: "Turin")
+        model.findNext()
+
+        model.replaceCurrentMatch()
+
+        #expect(owner.values[2][1] == "Turin")
+        #expect(owner.ownerCommits == 1)
+        #expect(owner.gridCommits == 0)
+        #expect(model.find.currentMatch == match(5))
+        #expect(owner.pageOffset == 4)
+        #expect(model.selection == cell(1, 1, in: model))
+
+        await model.findSearchSettled()
+        #expect(model.find.matches == [match(0), match(5), match(8)])
+        #expect(model.find.currentMatch == match(5))
+    }
+
+    @Test("Replace All hands the owner one query and lands as one commit")
+    func replaceAllIsOneCommit() async {
+        let (model, owner) = mount(editable: true)
+        await search(model, "paris", replacement: "Turin")
+
+        let outcome = model.replaceAllMatches()
+
+        #expect(outcome == nil)
+        #expect(owner.replaceAllQueries.map { $0.term } == ["paris"])
+        #expect(owner.replaceAllQueries.map { $0.columns } == [[Self.name, Self.city]])
+        #expect(owner.ownerCommits == 1)
+        #expect(owner.gridCommits == 0)
+        #expect(owner.values.filter { $0[1] == "Turin" }.count == 4)
+
+        await model.findSearchSettled()
+        #expect(model.find.matches.isEmpty)
+        #expect(owner.searches.count == 2)
+    }
+
+    @Test("An invalid regular expression reports a problem without asking the owner")
+    func invalidPatternSkipsOwner() async {
+        let (model, owner) = mount()
+        model.showFind()
+        model.find.options.usesRegularExpression = true
+        model.find.term = "(paris"
+
+        model.findQueryDidChange()
+        await model.findSearchSettled()
+
+        #expect(model.find.problem == GridFindEngine.invalidPatternProblem)
+        #expect(owner.searches.isEmpty)
+    }
+
+    @Test("Stopping a search clears its progress and drops the result it returns late")
+    func stopDropsLateResult() async throws {
+        let (model, owner) = mount()
+        let gate = AsyncGate()
+        owner.gate = gate
+        model.showFind()
+        model.find.term = "paris"
+        model.findQueryDidChange()
+        let running = try #require(model.find.datasetSearch)
+        await gate.arrived(1)
+        #expect(model.find.isSearching)
+
+        model.stopFindSearch()
+        #expect(model.find.isSearching == false)
+        #expect(model.find.searchStopped)
+
+        await gate.open()
+        await running.value
+        #expect(model.find.matches.isEmpty)
+        #expect(model.find.datasetSearch == nil)
+    }
+
+    @Test("Bisection finds the match at, after and before a cell and wraps at the ends")
+    func sortedIndexWraps() {
+        let cells = [
+            GridCoord(row: 0, displayColumn: 1),
+            GridCoord(row: 2, displayColumn: 0),
+            GridCoord(row: 2, displayColumn: 3),
+            GridCoord(row: 7, displayColumn: 1),
+        ]
+        let position = { (index: Int) -> GridCoord? in cells[index] }
+        let middle = GridCoord(row: 2, displayColumn: 0)
+
+        #expect(GridFindEngine.sortedIndex(atOrAfter: middle, count: 4, position: position) == 1)
+        #expect(GridFindEngine.sortedIndex(after: middle, count: 4, position: position) == 2)
+        #expect(GridFindEngine.sortedIndex(before: middle, count: 4, position: position) == 0)
+        #expect(GridFindEngine.sortedIndex(atOrAfter: GridCoord(row: 8, displayColumn: 0), count: 4, position: position) == 0)
+        #expect(GridFindEngine.sortedIndex(after: cells[3], count: 4, position: position) == 0)
+        #expect(GridFindEngine.sortedIndex(before: cells[0], count: 4, position: position) == 3)
+        #expect(GridFindEngine.sortedIndex(after: middle, count: 0, position: position) == nil)
+    }
+}
+
+@MainActor
+struct DataFileWholeFileFindTests {
+    private static let file = "name,n\nfoo,1\nbar,2\nfoo,3\nbaz,4\nfoo,5\n"
+
+    private let undoManager = UndoManager()
+
+    private func loaded(pageSize: Int) async throws -> DataFileController {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("GridDatasetFindTests-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let url = directory.appendingPathComponent("rows.csv")
+        try Data(Self.file.utf8).write(to: url)
+        let controller = DataFileController()
+        controller.undoManager = undoManager
+        let kind = try #require(DataFileKind.classify(url))
+        controller.load(url: url, kind: kind)
+        await controller.waitForPendingWork()
+        #expect(controller.loadState == .loaded)
+        controller.pageSize = pageSize
+        controller.refreshPage()
+        controller.gridModel.configuration.isEditable = controller.isEditable
+        return controller
+    }
+
+    private func search(_ controller: DataFileController, replacement: String? = nil) async {
+        let model = controller.gridModel
+        model.showFind(replace: replacement != nil)
+        model.find.term = "foo"
+        if let replacement {
+            model.find.replacement = replacement
+        }
+        model.findQueryDidChange()
+        await controller.waitForPendingWork()
+    }
+
+    private func names(_ controller: DataFileController) -> [String] {
+        guard let table = controller.table else { return [] }
+        return (0..<table.rowCount).map { table.cells(row: $0).first?.text ?? "" }
+    }
+
+    @Test("Find counts matches on every page and Find Next loads the page that holds the next one")
+    func findCoversEveryPage() async throws {
+        let controller = try await loaded(pageSize: 2)
+        let model = controller.gridModel
+
+        await search(controller)
+
+        #expect(model.find.matches.count == 3)
+        #expect(controller.pageOffset == 0)
+        model.findNext()
+        #expect(controller.pageOffset == 2)
+        #expect(model.selection.activeCell == GridCoord(row: 0, displayColumn: 0))
+        model.findNext()
+        #expect(controller.pageOffset == 4)
+    }
+
+    @Test("Replace changes one cell and moves to the next match on another page")
+    func replaceMovesToNextPage() async throws {
+        let controller = try await loaded(pageSize: 2)
+        let model = controller.gridModel
+        await search(controller, replacement: "qux")
+
+        model.replaceCurrentMatch()
+
+        #expect(names(controller) == ["qux", "bar", "foo", "baz", "foo"])
+        #expect(controller.pageOffset == 2)
+        await controller.waitForPendingWork()
+        #expect(model.find.matches.count == 2)
+    }
+
+    @Test("Replace All covers every page as one undo step, and Undo finds the matches again")
+    func replaceAllIsOneUndoStep() async throws {
+        let controller = try await loaded(pageSize: 2)
+        let model = controller.gridModel
+        await search(controller, replacement: "qux")
+
+        model.replaceAllMatches()
+        await controller.waitForPendingWork()
+
+        #expect(names(controller) == ["qux", "bar", "qux", "baz", "qux"])
+        #expect(controller.statusMessage == GridFindEngine.replacementMessage(replacements: 3, cells: 3))
+        #expect(model.find.matches.isEmpty)
+
+        controller.undoManager?.undo()
+        await controller.waitForPendingWork()
+        #expect(names(controller) == ["foo", "bar", "foo", "baz", "foo"])
+        #expect(model.find.matches.count == 3)
+    }
+
+    @Test("Cancel stops a running find")
+    func cancelStopsFind() async throws {
+        let controller = try await loaded(pageSize: 2)
+        let model = controller.gridModel
+        model.showFind()
+        model.find.term = "foo"
+        model.findQueryDidChange()
+        let running = try #require(model.find.datasetSearch)
+
+        controller.cancelActivity()
+
+        #expect(running.isCancelled)
+        #expect(model.find.isSearching == false)
+        await controller.waitForPendingWork()
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/GridFindEngineTests.swift b/apple/TableProTests/Core/DataGrid/Engine/GridFindEngineTests.swift
new file mode 100644
index 0000000000..6c3ed73cdd
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/GridFindEngineTests.swift
@@ -0,0 +1,581 @@
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct GridFindEngineTests {
+    private static let people = TableRows.from(
+        queryRows: [
+            ["active", "Alice", nil],
+            ["inactive", "Bob", "note"],
+            ["ACTIVE", "Chloé", "act now"]
+        ],
+        columns: ["status", "name", "remark"],
+        columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT"), .text(rawType: "TEXT")]
+    )
+
+    private static let status = DataGridColumnID(name: "status", occurrence: 0)
+    private static let name = DataGridColumnID(name: "name", occurrence: 0)
+    private static let remark = DataGridColumnID(name: "remark", occurrence: 0)
+
+    private func source(
+        _ rows: TableRows = people,
+        layout: ColumnLayoutState = ColumnLayoutState(),
+        order: DataGridRowOrder = .unfiltered,
+        formats: [ValueDisplayFormat?] = [],
+        revealsInvisibleCharacters: Bool = false
+    ) -> GridFindEngine.Source {
+        GridFindEngine.Source(
+            rows: rows,
+            order: order,
+            columns: DataGridColumnSet(tableRows: rows, layout: layout),
+            displayFormats: formats,
+            revealsInvisibleCharacters: revealsInvisibleCharacters
+        )
+    }
+
+    private func options(
+        matchesCase: Bool = false,
+        wholeWord: Bool = false,
+        regex: Bool = false,
+        scope: DataGridColumnID? = nil
+    ) -> GridFindState.Options {
+        GridFindState.Options(
+            matchesCase: matchesCase,
+            matchesWholeWord: wholeWord,
+            usesRegularExpression: regex,
+            columnScope: scope
+        )
+    }
+
+    private func match(_ row: Int, _ column: DataGridColumnID) -> GridFindState.Match {
+        GridFindState.Match(rowID: .existing(row), columnID: column)
+    }
+
+    private func search(
+        _ term: String,
+        _ options: GridFindState.Options = GridFindState.Options(),
+        in source: GridFindEngine.Source? = nil
+    ) -> GridFindEngine.Result {
+        GridFindEngine.search(term, options: options, in: source ?? self.source())
+    }
+
+    // MARK: - Matching
+
+    @Test("Matches come in display order, row then displayed column")
+    func displayOrder() {
+        var layout = ColumnLayoutState()
+        layout.columnOrder = ["remark", "status", "name"]
+
+        let result = search("act", in: source(layout: layout))
+
+        #expect(result.matches == [
+            match(0, Self.status),
+            match(1, Self.status),
+            match(2, Self.remark),
+            match(2, Self.status)
+        ])
+        #expect(result.problem == nil)
+    }
+
+    @Test("A value filter's order decides the match order and hides filtered rows")
+    func followsRowOrder() {
+        let order = DataGridRowOrder(filteredIDs: [.existing(2), .existing(0)], revision: 1)
+
+        let result = search("active", in: source(order: order))
+
+        #expect(result.matches == [match(2, Self.status), match(0, Self.status)])
+    }
+
+    @Test("Matching ignores case and diacritics unless Match Case is on")
+    func caseAndDiacritics() {
+        #expect(search("ACTIVE").matches.count == 3)
+        #expect(search("chloe").matches == [match(2, Self.name)])
+        #expect(search("ACTIVE", options(matchesCase: true)).matches == [match(2, Self.status)])
+    }
+
+    @Test("Whole Words skips a term inside a longer word")
+    func wholeWords() {
+        #expect(search("act", options(wholeWord: true)).matches == [match(2, Self.remark)])
+        #expect(search("active", options(wholeWord: true)).matches == [match(0, Self.status), match(2, Self.status)])
+    }
+
+    @Test("A regular expression matches by pattern")
+    func regularExpression() {
+        #expect(search("^b.b$", options(regex: true)).matches == [match(1, Self.name)])
+        #expect(search("^in", options(regex: true)).matches == [match(1, Self.status)])
+    }
+
+    @Test("An invalid regular expression reports a problem and finds nothing")
+    func invalidRegularExpression() {
+        let result = search("(", options(regex: true))
+
+        #expect(result.matches.isEmpty)
+        #expect(result.problem != nil)
+    }
+
+    @Test("A pattern that only matches the empty string finds nothing")
+    func emptyRegexMatch() {
+        #expect(search("x*", options(regex: true)).matches.isEmpty)
+    }
+
+    @Test("An empty or whitespace term finds nothing")
+    func emptyTerm() {
+        #expect(search("").matches.isEmpty)
+        #expect(search("   ").matches.isEmpty)
+        #expect(search("", options(regex: true)).matches.isEmpty)
+    }
+
+    @Test("A literal term is trimmed")
+    func literalTermTrimmed() {
+        #expect(search("  bob ").matches == [match(1, Self.name)])
+    }
+
+    @Test("A NULL cell is never read")
+    func nullNeverRead() {
+        let source = self.source()
+        let row = Self.people.rows[0]
+        let column = source.columns.column(id: Self.remark)
+
+        #expect(column.flatMap { GridFindEngine.searchableText(in: row, column: $0, source: source) } == nil)
+    }
+
+    @Test("A column scope searches that column only")
+    func columnScope() {
+        #expect(search("act", options(scope: Self.remark)).matches == [match(2, Self.remark)])
+    }
+
+    @Test("A scope on a column that is not presented searches every column")
+    func staleScope() {
+        let gone = DataGridColumnID(name: "gone", occurrence: 0)
+
+        #expect(search("act", options(scope: gone)).matches.count == 4)
+    }
+
+    @Test("A hidden column is never searched")
+    func hiddenColumn() {
+        var layout = ColumnLayoutState()
+        layout.hiddenColumns = ["status"]
+
+        #expect(search("act", in: source(layout: layout)).matches == [match(2, Self.remark)])
+    }
+
+    @Test("A lone carriage return reads as the space the cell shows while marks are off")
+    func invisibleCharacters() {
+        let rows = TableRows.from(queryRows: [["a\rb"]], columns: ["text"], columnTypes: [.text(rawType: "TEXT")])
+
+        #expect(search("a b", in: source(rows)).matches.count == 1)
+        #expect(search("a b", in: source(rows, revealsInvisibleCharacters: true)).matches.isEmpty)
+    }
+
+    // MARK: - Binary columns
+
+    private static let payload = TableRows(
+        rows: [
+            Row(id: .existing(0), values: [.bytes(Data("signup".utf8))]),
+            Row(id: .existing(1), values: [.bytes(Data([0x89, 0x50, 0x4E, 0x47]))])
+        ],
+        columns: ["payload"],
+        columnTypes: [.blob(rawType: "VARBINARY(255)")]
+    )
+
+    @Test("A binary column showing text is searched on that text")
+    func binaryTextColumn() {
+        let result = search("signup", in: source(Self.payload, formats: [.text]))
+
+        #expect(result.matches == [match(0, DataGridColumnID(name: "payload", occurrence: 0))])
+    }
+
+    @Test("A cell that fell back to hex is not searched on that hex")
+    func hexFallbackCell() {
+        let source = self.source(Self.payload, formats: [.text])
+
+        #expect(search("8950", in: source).matches.isEmpty)
+        #expect(search("0x89504E47", in: source).matches.isEmpty)
+    }
+
+    @Test("A binary column left raw is not searched")
+    func rawBinaryColumn() {
+        let source = self.source(Self.payload)
+
+        #expect(search("signup", in: source).matches.isEmpty)
+        #expect(search("8950", in: source).matches.isEmpty)
+    }
+
+    // MARK: - Replacing
+
+    private static let contacts = TableRows.from(
+        queryRows: [
+            ["Foo and FOO", "ann@example.com"],
+            ["bar", nil],
+            ["food", "bob@example.com"]
+        ],
+        columns: ["note", "email"],
+        columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+    )
+
+    private func replace(
+        _ term: String,
+        with template: String,
+        _ options: GridFindState.Options = GridFindState.Options(),
+        writable: (DataGridColumn) -> Bool = { _ in true }
+    ) -> GridFindEngine.Replacement {
+        let source = self.source(Self.contacts)
+        let found = GridFindEngine.search(term, options: options, in: source)
+        return GridFindEngine.replacements(
+            for: found.matches,
+            term: term,
+            options: options,
+            template: template,
+            in: source,
+            isWritable: writable
+        )
+    }
+
+    @Test("Replace writes entered text for every occurrence in a matched cell")
+    func replaceLiteral() {
+        let result = replace("foo", with: "baz")
+        let note = DataGridColumnID(name: "note", occurrence: 0)
+
+        #expect(result.edits == [
+            DataGridCellEdit(rowID: .existing(0), columnID: note, value: .enteredText("baz and baz")),
+            DataGridCellEdit(rowID: .existing(2), columnID: note, value: .enteredText("bazd"))
+        ])
+        #expect(result.replacements == 3)
+        #expect(result.cells == 2)
+    }
+
+    @Test("A literal replacement keeps a dollar sign as typed")
+    func literalTemplateIsNotExpanded() {
+        let result = replace("bar", with: "$1")
+
+        #expect(result.edits.map { $0.value } == [.enteredText("$1")])
+    }
+
+    @Test("A regular expression replacement expands capture groups")
+    func regexTemplateExpands() {
+        let result = replace("(\\w+)@example\\.com", with: "$1@test.dev", GridFindState.Options(usesRegularExpression: true))
+
+        #expect(result.edits.map { $0.value } == [.enteredText("ann@test.dev"), .enteredText("bob@test.dev")])
+    }
+
+    @Test("Replace skips a column it may not write")
+    func replaceSkipsUnwritableColumn() {
+        let result = replace("example", with: "test") { $0.name != "email" }
+
+        #expect(result.edits.isEmpty)
+        #expect(result.replacements == 0)
+    }
+
+    @Test("The Replace All message counts matches and cells")
+    func replacementMessage() {
+        #expect(GridFindEngine.replacementMessage(replacements: 1, cells: 1) == "Replaced 1 match in 1 cell.")
+        #expect(GridFindEngine.replacementMessage(replacements: 12, cells: 3) == "Replaced 12 matches in 3 cells.")
+        #expect(GridFindEngine.replacementMessage(replacements: 0, cells: 0) == String(localized: "No matches to replace."))
+    }
+
+    // MARK: - Stepping
+
+    private let positions: [GridCoord?] = [
+        GridCoord(row: 1, displayColumn: 0),
+        GridCoord(row: 4, displayColumn: 2),
+        GridCoord(row: 4, displayColumn: 5),
+        GridCoord(row: 9, displayColumn: 0)
+    ]
+
+    @Test("A new search lands on the first match at or after the cursor, else the first")
+    func landingIndex() {
+        #expect(GridFindEngine.index(atOrAfter: nil, in: positions) == 0)
+        #expect(GridFindEngine.index(atOrAfter: GridCoord(row: 4, displayColumn: 2), in: positions) == 1)
+        #expect(GridFindEngine.index(atOrAfter: GridCoord(row: 4, displayColumn: 3), in: positions) == 2)
+        #expect(GridFindEngine.index(atOrAfter: GridCoord(row: 10, displayColumn: 0), in: positions) == 0)
+        #expect(GridFindEngine.index(atOrAfter: nil, in: []) == nil)
+    }
+
+    @Test("Stepping from the current match wraps both ways")
+    func stepWraps() {
+        #expect(GridFindEngine.step(from: nil, active: nil, positions: positions, forward: true) == 0)
+        #expect(GridFindEngine.step(from: nil, active: nil, positions: positions, forward: false) == 3)
+        #expect(GridFindEngine.step(from: 3, active: positions[3], positions: positions, forward: true) == 0)
+        #expect(GridFindEngine.step(from: 0, active: positions[0], positions: positions, forward: false) == 3)
+        #expect(GridFindEngine.step(from: 1, active: positions[1], positions: positions, forward: true) == 2)
+        #expect(GridFindEngine.step(from: nil, active: nil, positions: [], forward: true) == nil)
+    }
+
+    @Test("Once the cursor leaves the current match, stepping starts from the cursor")
+    func stepFromCursor() {
+        let cursor = GridCoord(row: 5, displayColumn: 0)
+
+        #expect(GridFindEngine.step(from: 0, active: cursor, positions: positions, forward: true) == 3)
+        #expect(GridFindEngine.step(from: 0, active: cursor, positions: positions, forward: false) == 2)
+        #expect(GridFindEngine.step(from: 3, active: GridCoord(row: 20, displayColumn: 0), positions: positions, forward: true) == 0)
+    }
+}
+
+// MARK: - Model
+
+@MainActor
+private final class FindGridOwner: DataGridDataSource, DataGridActions {
+    var tableRows: TableRows
+    let changeState: AnyChangeManager
+    private(set) var commits: [(edits: [DataGridResolvedEdit], actionName: String)] = []
+    private(set) var searchedTerms: [String] = []
+
+    init(_ tableRows: TableRows) {
+        self.tableRows = tableRows
+        self.changeState = AnyChangeManager(DataChangeManager())
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+    var hasUnloadedRows = false
+    var gridHasUnloadedRows: Bool { hasUnloadedRows }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        commits.append((edits, actionName))
+        for edit in edits {
+            guard let index = tableRows.index(of: edit.rowID) else { continue }
+            tableRows.rows[index].values[edit.dataIndex] = edit.newValue
+        }
+        return true
+    }
+
+    func gridSearchAllRows(term: String) {
+        searchedTerms.append(term)
+    }
+}
+
+@MainActor
+struct DataGridModelFindTests {
+    private static let companies = TableRows.from(
+        queryRows: [
+            ["1", "Globex", "St. Louis"],
+            ["2", "Initech", "Acme Falls"],
+            ["3", "Acme", "Paris"],
+            ["4", "Acme Corp", "Acme"]
+        ],
+        columns: ["id", "company", "city"],
+        columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .text(rawType: "TEXT")]
+    )
+
+    private static let company = DataGridColumnID(name: "company", occurrence: 0)
+
+    private func mount(
+        _ configure: (inout DataGridConfiguration) -> Void = { _ in }
+    ) -> (DataGridModel, FindGridOwner) {
+        var configuration = DataGridConfiguration()
+        configure(&configuration)
+        let owner = FindGridOwner(Self.companies)
+        let model = DataGridModel(configuration: configuration)
+        model.dataSource = owner
+        model.actions = owner
+        model.reloadRows()
+        return (model, owner)
+    }
+
+    private func cell(_ row: Int, _ column: Int) -> GridSelection {
+        GridSelectionReducer.single(GridCoord(row: row, displayColumn: column))
+    }
+
+    private func search(_ model: DataGridModel, _ term: String) {
+        model.showFind()
+        model.find.term = term
+        model.findQueryDidChange()
+    }
+
+    @Test("A match becomes the active cell, column included")
+    func matchSetsActiveCell() {
+        let (model, owner) = mount()
+        model.setSelection(cell(2, 0))
+
+        search(model, "acme")
+
+        #expect(model.find.matches.count == 4)
+        #expect(model.find.currentIndex == 1)
+        #expect(model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+        #expect(model.activeCell?.column.name == "company")
+        #expect(owner.commits.isEmpty)
+    }
+
+    @Test("Find Next walks the matches and wraps")
+    func findNextWraps() {
+        let (model, owner) = mount()
+        search(model, "acme")
+        #expect(model.selection.activeCell == GridCoord(row: 1, displayColumn: 2))
+
+        model.findNext()
+        #expect(model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+        model.findNext()
+        model.findNext()
+        #expect(model.selection.activeCell == GridCoord(row: 3, displayColumn: 2))
+        model.findNext()
+        #expect(model.selection.activeCell == GridCoord(row: 1, displayColumn: 2))
+        #expect(model.find.currentIndex == 0)
+        #expect(owner.commits.isEmpty)
+    }
+
+    @Test("Find Previous starts from where the user moved the cursor")
+    func findPreviousFromCursor() {
+        let (model, owner) = mount()
+        search(model, "acme")
+        model.setSelection(cell(3, 0))
+
+        model.findPrevious()
+
+        #expect(model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+        #expect(owner.commits.isEmpty)
+    }
+
+    @Test("A refresh keeps the current match by identity and leaves the selection alone")
+    func refreshKeepsCurrentMatch() {
+        let (model, owner) = mount()
+        model.setSelection(cell(2, 0))
+        search(model, "acme")
+
+        owner.tableRows.rows[0].values[2] = .text("Acme Town")
+        model.reloadRows()
+        model.refreshFind()
+
+        #expect(model.find.matches.count == 5)
+        #expect(model.find.currentMatch == GridFindState.Match(rowID: .existing(2), columnID: Self.company))
+        #expect(model.find.currentIndex == 2)
+        #expect(model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+    }
+
+    @Test("Replace commits the current match as one edit and moves to the next match")
+    func replaceCurrent() {
+        let (model, owner) = mount { $0.isEditable = true }
+        search(model, "acme")
+        model.find.replacement = "Umbrella"
+
+        model.replaceCurrentMatch()
+
+        #expect(owner.commits.count == 1)
+        #expect(owner.commits.first?.actionName == String(localized: "Replace"))
+        #expect(owner.commits.first?.edits.map { $0.newValue } == [.text("Umbrella Falls")])
+        #expect(owner.commits.first?.edits.map { $0.rowID } == [.existing(1)])
+        #expect(model.find.matches.count == 3)
+        #expect(model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+    }
+
+    @Test("Replace All is one commit and leaves a column it may not write")
+    func replaceAllOneCommit() throws {
+        let (model, owner) = mount {
+            $0.isEditable = true
+            $0.lockedColumns = ["city"]
+        }
+        search(model, "acme")
+        model.find.replacement = "Umbrella"
+
+        let outcome = try #require(model.replaceAllMatches())
+
+        #expect(outcome.cells == 2)
+        #expect(outcome.replacements == 2)
+        #expect(owner.commits.count == 1)
+        #expect(owner.commits.first?.actionName == String(localized: "Replace All"))
+        #expect(owner.commits.first?.edits.map { $0.newValue } == [.text("Umbrella"), .text("Umbrella Corp")])
+        #expect(model.find.matches.count == 2)
+    }
+
+    @Test("A read-only grid offers no replace")
+    func readOnlyGridHasNoReplace() {
+        let (model, owner) = mount()
+        model.showFind(replace: true)
+        model.find.term = "acme"
+        model.findQueryDidChange()
+
+        #expect(model.find.showsReplace == false)
+        #expect(model.replaceAllMatches() == nil)
+        model.replaceCurrentMatch()
+        #expect(owner.commits.isEmpty)
+    }
+
+    @Test("Hiding the bar clears the term, the matches, the scope and the replace row")
+    func hideClears() {
+        let (model, owner) = mount { $0.isEditable = true }
+        model.findInColumn(Self.company, replace: true)
+        model.find.term = "acme"
+        model.findQueryDidChange()
+        #expect(model.find.matches.count == 2)
+
+        model.hideFind()
+
+        #expect(model.find.isVisible == false)
+        #expect(model.find.term.isEmpty)
+        #expect(model.find.matches.isEmpty)
+        #expect(model.find.options.columnScope == nil)
+        #expect(model.find.showsReplace == false)
+        #expect(owner.commits.isEmpty)
+    }
+
+    @Test("Search All Rows hands the trimmed term to the owner only where the grid offers it")
+    func searchAllRows() {
+        let (plain, plainOwner) = mount()
+        search(plain, "  zzz ")
+        plain.searchAllRows()
+        #expect(plainOwner.searchedTerms.isEmpty)
+        #expect(plain.find.isVisible)
+
+        let (offered, owner) = mount { $0.commands = [.searchAllRows] }
+        search(offered, "  zzz ")
+        offered.searchAllRows()
+        #expect(owner.searchedTerms == ["zzz"])
+        #expect(offered.find.isVisible == false)
+    }
+
+    @Test("Search All Rows waits for plain options, since the server matches the term as typed in any column")
+    func searchAllRowsNeedsPlainOptions() {
+        let (model, owner) = mount { $0.commands = [.searchAllRows] }
+        search(model, "^zzz$")
+        model.find.options.usesRegularExpression = true
+
+        model.searchAllRows()
+        #expect(owner.searchedTerms.isEmpty)
+        #expect(!model.searchAllRowsKeepsTheOptions)
+
+        model.find.options.usesRegularExpression = false
+        model.searchAllRows()
+        #expect(owner.searchedTerms == ["^zzz$"])
+    }
+
+    @Test("New rows under an open bar are searched again")
+    func reloadSearchesTheNewRows() {
+        let (model, owner) = mount()
+        search(model, "acme")
+        #expect(model.find.matches.count == 4)
+
+        owner.tableRows = TableRows.from(
+            queryRows: [["9", "Acme", "Oslo"]],
+            columns: ["id", "company", "city"],
+            columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .text(rawType: "TEXT")]
+        )
+        model.reloadRows()
+
+        #expect(model.find.matches.count == 1)
+    }
+
+    @Test("The counter names the page whenever the owner holds more rows, Search All Rows offered or not")
+    func pageScopeFollowsTheOwnersRows() {
+        let (model, owner) = mount()
+        #expect(!model.findCoversPageOnly)
+
+        owner.hasUnloadedRows = true
+        #expect(model.findCoversPageOnly)
+        #expect(!model.offersSearchAllRows)
+    }
+
+    @Test("Use Selection for Find takes the cell's text, escaped for a regular expression")
+    func useSelectionForFind() {
+        let (model, owner) = mount()
+        model.setSelection(cell(0, 2))
+        model.find.options.usesRegularExpression = true
+
+        model.useSelectionForFind()
+
+        #expect(model.find.isVisible)
+        #expect(model.find.term == NSRegularExpression.escapedPattern(for: "St. Louis"))
+        #expect(model.find.matches == [GridFindState.Match(rowID: .existing(0), columnID: DataGridColumnID(name: "city", occurrence: 0))])
+        #expect(owner.commits.isEmpty)
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/GridSelectionReducerTests.swift b/apple/TableProTests/Core/DataGrid/Engine/GridSelectionReducerTests.swift
new file mode 100644
index 0000000000..50c34a8e0c
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/GridSelectionReducerTests.swift
@@ -0,0 +1,678 @@
+import Foundation
+@testable import TablePro
+import Testing
+
+struct GridSelectionReducerTests {
+    private let grid = GridSelectionContext(rowCount: 10, columnCount: 6)
+
+    private func cell(_ row: Int, _ column: Int) -> GridCoord {
+        GridCoord(row: row, displayColumn: column)
+    }
+
+    private func single(_ row: Int, _ column: Int) -> GridSelection {
+        GridSelectionReducer.single(cell(row, column))
+    }
+
+    private func cursorAt(_ row: Int, _ column: Int) -> GridSelection {
+        GridSelectionReducer.cursor(cell(row, column), in: grid)
+    }
+
+    private func range(_ anchor: GridCoord, _ active: GridCoord) -> GridSelection {
+        GridSelection(rectangles: [GridRect.between(anchor, active)], activeCell: active, anchor: anchor)
+    }
+
+    private func wholeRows(_ rows: ClosedRange<Int>) -> GridRect {
+        GridRect(rows: rows, columns: 0...5)
+    }
+
+    // MARK: - Press and drag
+
+    @Test("A plain press selects the cell's row with the cursor on the cell and starts a replacing drag")
+    func plainPressSelectsCell() {
+        let (selection, drag) = GridSelectionReducer.press(.empty, at: cell(2, 3), modifiers: [], in: grid)
+
+        #expect(selection == cursorAt(2, 3))
+        #expect(selection.rectangles == [wholeRows(2...2)])
+        #expect(!selection.picksRows)
+        #expect(drag == GridSelectionDrag(origin: cell(2, 3), base: .empty, mode: .replace))
+    }
+
+    @Test("A plain press replaces a range")
+    func plainPressReplacesRange() {
+        let (selection, _) = GridSelectionReducer.press(range(cell(1, 1), cell(4, 4)), at: cell(6, 2), modifiers: [], in: grid)
+
+        #expect(selection == cursorAt(6, 2))
+    }
+
+    @Test("A drag builds a rectangle anchored where the press landed")
+    func dragBuildsRectangle() {
+        let (_, drag) = GridSelectionReducer.press(.empty, at: cell(2, 3), modifiers: [], in: grid)
+
+        let dragged = GridSelectionReducer.drag(drag, to: cell(4, 1), in: grid)
+
+        #expect(dragged.rectangles == [GridRect(rows: 2...4, columns: 1...3)])
+        #expect(dragged.activeCell == cell(4, 1))
+        #expect(dragged.anchor == cell(2, 3))
+        #expect(GridSelectionReducer.drag(drag, to: cell(2, 3), in: grid) == cursorAt(2, 3))
+    }
+
+    @Test("A drag past either edge holds at that edge")
+    func dragClampsToGrid() {
+        let (_, drag) = GridSelectionReducer.press(.empty, at: cell(2, 3), modifiers: [], in: grid)
+
+        let dragged = GridSelectionReducer.drag(drag, to: cell(50, 40), in: grid)
+
+        #expect(dragged.rectangles == [GridRect(rows: 2...9, columns: 3...5)])
+        #expect(dragged.activeCell == cell(9, 5))
+    }
+
+    @Test("Shift-press ranges from the anchor and the drag keeps that anchor")
+    func shiftPressExtendsFromAnchor() {
+        let (selection, drag) = GridSelectionReducer.press(single(1, 1), at: cell(3, 4), modifiers: .shift, in: grid)
+
+        #expect(selection == range(cell(1, 1), cell(3, 4)))
+        #expect(drag == GridSelectionDrag(origin: cell(1, 1), base: .empty, mode: .replace))
+        #expect(GridSelectionReducer.drag(drag, to: cell(0, 0), in: grid) == range(cell(1, 1), cell(0, 0)))
+    }
+
+    @Test("Shift-press without an anchor ranges from the active cell")
+    func shiftPressFallsBackToActiveCell() {
+        let start = GridSelection(rectangles: [GridRect(cell: cell(2, 2))], activeCell: cell(2, 2), anchor: nil)
+
+        let (selection, _) = GridSelectionReducer.press(start, at: cell(4, 0), modifiers: .shift, in: grid)
+
+        #expect(selection == range(cell(2, 2), cell(4, 0)))
+    }
+
+    @Test("Shift-press on an empty selection puts the cursor on the cell")
+    func shiftPressOnEmptySelectsCell() {
+        let (selection, _) = GridSelectionReducer.press(.empty, at: cell(5, 5), modifiers: .shift, in: grid)
+
+        #expect(selection == cursorAt(5, 5))
+    }
+
+    @Test("Command-press adds a cell and starts an additive drag over the old selection")
+    func commandPressAddsCell() {
+        let start = single(1, 1)
+
+        let (selection, drag) = GridSelectionReducer.press(start, at: cell(3, 3), modifiers: .command, in: grid)
+
+        #expect(selection.rectangles == [GridRect(cell: cell(1, 1)), GridRect(cell: cell(3, 3))])
+        #expect(selection.activeCell == cell(3, 3))
+        #expect(selection.anchor == cell(3, 3))
+        #expect(drag == GridSelectionDrag(origin: cell(3, 3), base: start, mode: .additive))
+    }
+
+    @Test("Command-press on the only selected cell clears the selection")
+    func commandPressOnOnlyCellClears() {
+        let (selection, _) = GridSelectionReducer.press(single(1, 1), at: cell(1, 1), modifiers: .command, in: grid)
+
+        #expect(selection == .empty)
+    }
+
+    @Test("Command-press inside a block takes out only that cell")
+    func commandPressInsideBlockRemovesCell() {
+        let block = range(cell(0, 0), cell(2, 2))
+
+        let (selection, _) = GridSelectionReducer.press(block, at: cell(1, 1), modifiers: .command, in: grid)
+
+        #expect(selection.uniqueCellCount == 8)
+        #expect(!selection.contains(cell(1, 1)))
+        #expect(selection.contains(cell(0, 0)))
+        #expect(selection.contains(cell(2, 2)))
+    }
+
+    @Test("A Command-drag appends a rectangle and keeps the earlier selection")
+    func commandDragAppendsRectangle() {
+        let (_, drag) = GridSelectionReducer.press(single(0, 0), at: cell(2, 2), modifiers: .command, in: grid)
+
+        let dragged = GridSelectionReducer.drag(drag, to: cell(3, 4), in: grid)
+
+        #expect(dragged.rectangles == [GridRect(cell: cell(0, 0)), GridRect(rows: 2...3, columns: 2...4)])
+        #expect(dragged.activeCell == cell(3, 4))
+        #expect(dragged.anchor == cell(2, 2))
+    }
+
+    @Test("A Command-drag back onto its origin is the press's toggle again")
+    func commandDragBackToOriginToggles() {
+        let (pressed, drag) = GridSelectionReducer.press(single(1, 1), at: cell(1, 1), modifiers: .command, in: grid)
+        #expect(pressed == .empty)
+
+        let away = GridSelectionReducer.drag(drag, to: cell(2, 2), in: grid)
+        #expect(away.contains(cell(1, 1)))
+        #expect(away.contains(cell(2, 2)))
+
+        #expect(GridSelectionReducer.drag(drag, to: cell(1, 1), in: grid) == .empty)
+    }
+
+    @Test("A Command-press or Command-drag in the body keeps a picked column")
+    func commandGesturesKeepPickedColumn() {
+        let picked = GridSelection.column(2, totalRows: 10)
+
+        let (pressed, drag) = GridSelectionReducer.press(picked, at: cell(5, 4), modifiers: .command, in: grid)
+        let dragged = GridSelectionReducer.drag(drag, to: cell(6, 5), in: grid)
+
+        #expect(pressed.columns == IndexSet(integer: 2))
+        #expect(dragged.columns == IndexSet(integer: 2))
+        #expect(dragged.contains(cell(9, 2)))
+    }
+
+    @Test("Only a header click marks a column, not a drag that spans every row")
+    func onlyHeaderMarksColumns() {
+        let (_, drag) = GridSelectionReducer.press(.empty, at: cell(0, 2), modifiers: [], in: grid)
+
+        let dragged = GridSelectionReducer.drag(drag, to: cell(9, 2), in: grid)
+
+        #expect(dragged.columns.isEmpty)
+    }
+
+    @Test("Shift and Command together press like a plain click")
+    func shiftCommandPressIsPlain() {
+        let (selection, drag) = GridSelectionReducer.press(single(1, 1), at: cell(3, 3), modifiers: [.shift, .command], in: grid)
+
+        #expect(selection == cursorAt(3, 3))
+        #expect(drag.mode == .replace)
+    }
+
+    @Test("A press past the edges lands on the nearest cell")
+    func pressClampsToGrid() {
+        let (selection, _) = GridSelectionReducer.press(.empty, at: cell(20, -3), modifiers: [], in: grid)
+
+        #expect(selection == cursorAt(9, 0))
+    }
+
+    @Test("A press on a grid with no rows selects nothing")
+    func pressOnEmptyGrid() {
+        let empty = GridSelectionContext(rowCount: 0, columnCount: 6)
+
+        let (selection, drag) = GridSelectionReducer.press(single(1, 1), at: cell(0, 0), modifiers: [], in: empty)
+
+        #expect(selection == .empty)
+        #expect(GridSelectionReducer.drag(drag, to: cell(1, 1), in: empty) == .empty)
+    }
+
+    // MARK: - Row header
+
+    @Test("A row header press selects the whole row and starts a rows drag")
+    func rowHeaderSelectsRow() {
+        let (selection, drag) = GridSelectionReducer.rowHeaderPress(.empty, row: 4, modifiers: [], in: grid)
+
+        #expect(selection.rectangles == [wholeRows(4...4)])
+        #expect(selection.activeCell == cell(4, 0))
+        #expect(selection.anchor == cell(4, 0))
+        #expect(drag == GridSelectionDrag(origin: cell(4, 0), base: .empty, mode: .rows))
+    }
+
+    @Test("A row header press keeps the column the cursor was on")
+    func rowHeaderKeepsActiveColumn() {
+        let (selection, _) = GridSelectionReducer.rowHeaderPress(single(2, 3), row: 6, modifiers: [], in: grid)
+
+        #expect(selection.rectangles == [wholeRows(6...6)])
+        #expect(selection.activeCell == cell(6, 3))
+    }
+
+    @Test("Shift on a row header extends whole rows from the anchor")
+    func rowHeaderShiftExtends() {
+        let (start, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 2, modifiers: [], in: grid)
+
+        let (selection, drag) = GridSelectionReducer.rowHeaderPress(start, row: 5, modifiers: .shift, in: grid)
+
+        #expect(selection.rectangles == [wholeRows(2...5)])
+        #expect(selection.anchor == cell(2, 0))
+        #expect(selection.activeCell == cell(5, 0))
+        #expect(drag.origin == cell(2, 0))
+    }
+
+    @Test("Command on a row header adds a row, and again takes it back")
+    func rowHeaderCommandToggles() {
+        let (start, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 2, modifiers: [], in: grid)
+
+        let (added, _) = GridSelectionReducer.rowHeaderPress(start, row: 5, modifiers: .command, in: grid)
+        #expect(added.rectangles == [wholeRows(2...2), wholeRows(5...5)])
+        #expect(added.activeCell == cell(5, 0))
+
+        let (removed, _) = GridSelectionReducer.rowHeaderPress(added, row: 5, modifiers: .command, in: grid)
+        #expect(removed.rectangles == [wholeRows(2...2)])
+        #expect(removed.activeCell == cell(2, 0))
+    }
+
+    @Test("Command on a row inside a run of rows splits the run")
+    func rowHeaderCommandSplitsRun() {
+        let run = GridSelection(rectangles: [wholeRows(2...6)], activeCell: cell(2, 0), anchor: cell(2, 0))
+
+        let (selection, _) = GridSelectionReducer.rowHeaderPress(run, row: 4, modifiers: .command, in: grid)
+
+        #expect(selection.rectangles == [wholeRows(2...3), wholeRows(5...6)])
+        #expect(selection.activeCell == cell(2, 0))
+    }
+
+    @Test("A rows drag extends whole rows from the pressed row in either direction")
+    func rowsDragExtends() {
+        let (_, drag) = GridSelectionReducer.rowHeaderPress(.empty, row: 3, modifiers: [], in: grid)
+
+        let down = GridSelectionReducer.drag(drag, to: cell(7, 2), in: grid)
+        #expect(down.rectangles == [wholeRows(3...7)])
+        #expect(down.activeCell == cell(7, 0))
+        #expect(down.anchor == cell(3, 0))
+
+        let up = GridSelectionReducer.drag(drag, to: cell(1, 5), in: grid)
+        #expect(up.rectangles == [wholeRows(1...3)])
+        #expect(up.activeCell == cell(1, 0))
+    }
+
+    @Test("A Command rows drag adds to what was selected")
+    func commandRowsDragAdds() {
+        let (start, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 0, modifiers: [], in: grid)
+        let (_, drag) = GridSelectionReducer.rowHeaderPress(start, row: 4, modifiers: .command, in: grid)
+
+        let dragged = GridSelectionReducer.drag(drag, to: cell(6, 0), in: grid)
+
+        #expect(dragged.rectangles == [wholeRows(0...0), wholeRows(4...6)])
+    }
+
+    @Test("A row number press that may lift rows picks a clicked row, so it copies as a row")
+    func rowNumberDragPressPicksAClickedRow() {
+        let picked = GridSelectionReducer.rowNumberDragPress(cursorAt(2, 3), row: 2, keepsPickedRows: true, in: grid)
+
+        #expect(picked.picksRows)
+        #expect(picked.rectangles == [wholeRows(2...2)])
+        #expect(picked.activeCell == cell(2, 3))
+    }
+
+    @Test("A row number press inside picked rows keeps them all for the drag")
+    func rowNumberDragPressKeepsPickedRows() {
+        let (start, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 1, modifiers: [], in: grid)
+        let (rows, _) = GridSelectionReducer.rowHeaderPress(start, row: 3, modifiers: .shift, in: grid)
+
+        #expect(GridSelectionReducer.rowNumberDragPress(rows, row: 2, keepsPickedRows: true, in: grid) == rows)
+    }
+
+    @Test("Where a drag reorders one row, a row number press picks the pressed row alone")
+    func rowNumberDragPressForReorderPicksThePressedRow() {
+        let (start, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 1, modifiers: [], in: grid)
+        let (rows, _) = GridSelectionReducer.rowHeaderPress(start, row: 3, modifiers: .shift, in: grid)
+
+        let pressed = GridSelectionReducer.rowNumberDragPress(rows, row: 3, keepsPickedRows: false, in: grid)
+
+        #expect(pressed.picksRows)
+        #expect(pressed.rectangles == [wholeRows(3...3)])
+        #expect(pressed.affectedRows == IndexSet(integer: 3))
+    }
+
+    // MARK: - Column header
+
+    @Test("Command on a header picks the whole column and marks it")
+    func headerPicksColumn() {
+        let selection = GridSelectionReducer.columnHeaderCommandClick(.empty, column: 2, modifiers: .command, in: grid)
+
+        #expect(selection.rectangles == [GridRect(rows: 0...9, columns: 2...2)])
+        #expect(selection.columns == IndexSet(integer: 2))
+        #expect(selection.activeCell == cell(0, 2))
+    }
+
+    @Test("Command on a picked header gives the column back")
+    func headerTogglesColumn() {
+        let picked = GridSelectionReducer.columnHeaderCommandClick(.empty, column: 2, modifiers: .command, in: grid)
+
+        #expect(GridSelectionReducer.columnHeaderCommandClick(picked, column: 2, modifiers: .command, in: grid) == .empty)
+    }
+
+    @Test("Command on a header keeps the rest of the selection, and giving it back leaves the rest")
+    func headerKeepsOtherCells() {
+        let picked = GridSelectionReducer.columnHeaderCommandClick(single(3, 0), column: 4, modifiers: .command, in: grid)
+        #expect(picked.contains(cell(3, 0)))
+        #expect(picked.columns == IndexSet(integer: 4))
+
+        let released = GridSelectionReducer.columnHeaderCommandClick(picked, column: 4, modifiers: .command, in: grid)
+        #expect(released.rectangles == [GridRect(cell: cell(3, 0))])
+        #expect(released.columns.isEmpty)
+        #expect(released.activeCell == cell(3, 0))
+    }
+
+    @Test("Picking a header again never stacks a duplicate rectangle")
+    func headerNeverDuplicates() {
+        var selection = GridSelection.empty
+        for column in [2, 3, 2, 2] {
+            selection = GridSelectionReducer.columnHeaderCommandClick(selection, column: column, modifiers: .command, in: grid)
+        }
+
+        #expect(selection.rectangles.count == 2)
+        #expect(selection.columns == IndexSet([2, 3]))
+    }
+
+    @Test("Shift-Command on a header picks every column from the anchor's to this one")
+    func headerShiftPicksRun() {
+        let first = GridSelectionReducer.columnHeaderCommandClick(.empty, column: 1, modifiers: .command, in: grid)
+
+        let run = GridSelectionReducer.columnHeaderCommandClick(first, column: 3, modifiers: [.command, .shift], in: grid)
+
+        #expect(run.columns == IndexSet(integersIn: 1...3))
+        #expect(run.rectangles.count == 3)
+        #expect(run.activeCell == cell(0, 3))
+        #expect(run.anchor == cell(0, 1))
+
+        let released = GridSelectionReducer.columnHeaderCommandClick(run, column: 2, modifiers: .command, in: grid)
+        #expect(released.columns == IndexSet([1, 3]))
+        #expect(!released.contains(cell(5, 2)))
+    }
+
+    @Test("Command on a header after a click adds the column to the cursor's cell, not to the clicked row")
+    func headerAfterClickKeepsOnlyTheCursorCell() {
+        let picked = GridSelectionReducer.columnHeaderCommandClick(cursorAt(2, 1), column: 4, modifiers: .command, in: grid)
+
+        #expect(picked.rectangles == [GridRect(cell: cell(2, 1)), GridRect(rows: 0...9, columns: 4...4)])
+        #expect(picked.columns == IndexSet(integer: 4))
+        #expect(picked.mode == .cells)
+        #expect(!picked.contains(cell(2, 5)))
+
+        let run = GridSelectionReducer.columnHeaderCommandClick(cursorAt(2, 1), column: 3, modifiers: [.command, .shift], in: grid)
+        #expect(run.columns == IndexSet(integersIn: 1...3))
+        #expect(!run.contains(cell(2, 5)))
+    }
+
+    @Test("Command on a header after picked rows picks the column alone")
+    func headerAfterRowPickPicksOnlyTheColumn() {
+        let (rows, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 3, modifiers: [], in: grid)
+
+        let picked = GridSelectionReducer.columnHeaderCommandClick(rows, column: 4, modifiers: .command, in: grid)
+
+        #expect(picked.rectangles == [GridRect(rows: 0...9, columns: 4...4)])
+        #expect(picked.columns == IndexSet(integer: 4))
+    }
+
+    @Test("A header outside the grid leaves the selection alone")
+    func headerOutsideGrid() {
+        #expect(GridSelectionReducer.columnHeaderCommandClick(single(1, 1), column: 9, modifiers: .command, in: grid) == single(1, 1))
+    }
+
+    // MARK: - Arrows
+
+    @Test("An arrow moves the cursor and collapses a range onto the cursor's row")
+    func arrowMovesAndCollapses() {
+        let block = range(cell(1, 1), cell(3, 3))
+
+        #expect(GridSelectionReducer.move(block, .right, extending: false, toEdge: false, in: grid) == cursorAt(3, 4))
+        #expect(GridSelectionReducer.move(single(4, 2), .up, extending: false, toEdge: false, in: grid) == cursorAt(3, 2))
+        #expect(GridSelectionReducer.move(single(4, 2), .down, extending: false, toEdge: false, in: grid) == cursorAt(5, 2))
+        #expect(GridSelectionReducer.move(single(4, 2), .left, extending: false, toEdge: false, in: grid) == cursorAt(4, 1))
+    }
+
+    @Test("An arrow at an edge stays put and never wraps")
+    func arrowStopsAtEdges() {
+        #expect(GridSelectionReducer.move(single(0, 0), .up, extending: false, toEdge: false, in: grid) == cursorAt(0, 0))
+        #expect(GridSelectionReducer.move(single(0, 0), .left, extending: false, toEdge: false, in: grid) == cursorAt(0, 0))
+        #expect(GridSelectionReducer.move(single(9, 5), .down, extending: false, toEdge: false, in: grid) == cursorAt(9, 5))
+        #expect(GridSelectionReducer.move(single(9, 5), .right, extending: false, toEdge: false, in: grid) == cursorAt(9, 5))
+    }
+
+    @Test("Command-arrow jumps to the grid edge")
+    func arrowToEdge() {
+        let start = single(4, 2)
+
+        #expect(GridSelectionReducer.move(start, .down, extending: false, toEdge: true, in: grid) == cursorAt(9, 2))
+        #expect(GridSelectionReducer.move(start, .up, extending: false, toEdge: true, in: grid) == cursorAt(0, 2))
+        #expect(GridSelectionReducer.move(start, .left, extending: false, toEdge: true, in: grid) == cursorAt(4, 0))
+        #expect(GridSelectionReducer.move(start, .right, extending: false, toEdge: true, in: grid) == cursorAt(4, 5))
+    }
+
+    @Test("Shift-arrow grows the rectangle from the anchor and moves the active cell")
+    func shiftArrowGrows() {
+        let down = GridSelectionReducer.move(single(2, 2), .down, extending: true, toEdge: false, in: grid)
+        #expect(down == range(cell(2, 2), cell(3, 2)))
+
+        let right = GridSelectionReducer.move(down, .right, extending: true, toEdge: false, in: grid)
+        #expect(right == range(cell(2, 2), cell(3, 3)))
+    }
+
+    @Test("Shift-arrow back the other way shrinks with the anchor fixed")
+    func shiftArrowShrinks() {
+        var selection = single(2, 2)
+        for direction in [GridMoveDirection.down, .down, .up] {
+            selection = GridSelectionReducer.move(selection, direction, extending: true, toEdge: false, in: grid)
+        }
+
+        #expect(selection == range(cell(2, 2), cell(3, 2)))
+    }
+
+    @Test("Shift-Command-arrow extends to the grid edge")
+    func shiftArrowToEdge() {
+        let selection = GridSelectionReducer.move(single(4, 2), .right, extending: true, toEdge: true, in: grid)
+
+        #expect(selection == range(cell(4, 2), cell(4, 5)))
+    }
+
+    @Test("Shift-arrow after a row header press starts a range at the cursor")
+    func shiftArrowAfterRowHeader() {
+        let (rows, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 6, modifiers: [], in: grid)
+
+        let selection = GridSelectionReducer.move(rows, .down, extending: true, toEdge: false, in: grid)
+
+        #expect(selection.rectangles == [GridRect(rows: 6...7, columns: 0...0)])
+    }
+
+    @Test("An arrow with nothing selected lands on the first row")
+    func arrowFromNothing() {
+        #expect(GridSelectionReducer.move(.empty, .down, extending: false, toEdge: false, in: grid) == cursorAt(0, 0))
+        #expect(GridSelectionReducer.move(.empty, .right, extending: true, toEdge: false, in: grid) == cursorAt(0, 0))
+    }
+
+    @Test("An arrow on a grid with no columns selects nothing")
+    func arrowOnEmptyGrid() {
+        let empty = GridSelectionContext(rowCount: 4, columnCount: 0)
+
+        #expect(GridSelectionReducer.move(single(1, 1), .down, extending: false, toEdge: false, in: empty) == .empty)
+    }
+
+    @Test("Command-Left and Command-Right reach the first and last column")
+    func moveToColumnEdge() {
+        #expect(GridSelectionReducer.moveToColumnEdge(single(3, 3), last: true, extending: false, in: grid) == cursorAt(3, 5))
+        #expect(GridSelectionReducer.moveToColumnEdge(single(3, 3), last: false, extending: false, in: grid) == cursorAt(3, 0))
+        #expect(GridSelectionReducer.moveToColumnEdge(single(3, 3), last: true, extending: true, in: grid) == range(cell(3, 3), cell(3, 5)))
+    }
+
+    @Test("Left and Right over a clicked row move the cursor and keep the row")
+    func arrowAcrossClickedRowKeepsRow() {
+        let moved = GridSelectionReducer.move(cursorAt(4, 2), .right, extending: false, toEdge: false, in: grid)
+
+        #expect(moved.rectangles == [wholeRows(4...4)])
+        #expect(moved.activeCell == cell(4, 3))
+        #expect(!moved.picksRows)
+    }
+
+    @Test("A Command-press after a click adds the clicked cell to the cursor's cell")
+    func commandPressAfterClickAddsCell() {
+        let (selection, _) = GridSelectionReducer.press(cursorAt(2, 1), at: cell(5, 3), modifiers: .command, in: grid)
+
+        #expect(selection.rectangles == [GridRect(cell: cell(2, 1)), GridRect(cell: cell(5, 3))])
+        #expect(selection.activeCell == cell(5, 3))
+    }
+
+    @Test("Row picks stay picks through a native row move")
+    func nativeMoveKeepsRowPick() {
+        let (picked, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 2, modifiers: [], in: grid)
+        #expect(picked.picksRows)
+
+        let moved = GridSelectionReducer.rowsSelectedNatively(IndexSet(integer: 3), previous: picked, in: grid)
+
+        #expect(moved.picksRows)
+        #expect(!GridSelectionReducer.rowsSelectedNatively(IndexSet(integer: 3), previous: cursorAt(2, 1), in: grid).picksRows)
+    }
+
+    // MARK: - Tab
+
+    @Test("Tab moves right and wraps to the next row's first cell")
+    func tabMovesAndWraps() {
+        #expect(GridSelectionReducer.tab(single(2, 1), forward: true, in: grid) == cursorAt(2, 2))
+        #expect(GridSelectionReducer.tab(single(2, 5), forward: true, in: grid) == cursorAt(3, 0))
+    }
+
+    @Test("Shift-Tab moves left and wraps to the previous row's last cell")
+    func backtabMovesAndWraps() {
+        #expect(GridSelectionReducer.tab(single(2, 3), forward: false, in: grid) == cursorAt(2, 2))
+        #expect(GridSelectionReducer.tab(single(2, 0), forward: false, in: grid) == cursorAt(1, 5))
+    }
+
+    @Test("Tab stops at the last cell and Shift-Tab at the first")
+    func tabStopsAtEnds() {
+        #expect(GridSelectionReducer.tab(single(9, 5), forward: true, in: grid) == cursorAt(9, 5))
+        #expect(GridSelectionReducer.tab(single(0, 0), forward: false, in: grid) == cursorAt(0, 0))
+    }
+
+    @Test("Tab collapses a range onto the next cell")
+    func tabCollapsesRange() {
+        #expect(GridSelectionReducer.tab(range(cell(1, 1), cell(3, 3)), forward: true, in: grid) == cursorAt(3, 4))
+    }
+
+    @Test("Tab with nothing selected leaves the selection empty")
+    func tabWithNothingSelected() {
+        #expect(GridSelectionReducer.tab(.empty, forward: true, in: grid) == .empty)
+    }
+
+    // MARK: - Whole grid and rows
+
+    @Test("Select All picks every row, marks no column and leaves no cursor")
+    func selectAllCoversGrid() {
+        let selection = GridSelectionReducer.selectAll(single(4, 3), in: grid)
+
+        #expect(selection.rectangles == [GridRect(rows: 0...9, columns: 0...5)])
+        #expect(selection.columns.isEmpty)
+        #expect(selection.picksRows)
+        #expect(selection.activeCell == nil)
+        #expect(GridSelectionReducer.selectAll(.empty, in: grid).activeCell == nil)
+        #expect(GridSelectionReducer.selectAll(.empty, in: GridSelectionContext(rowCount: 0, columnCount: 3)) == .empty)
+    }
+
+    @Test("Shift-Space widens to every touched row, one rectangle per run")
+    func widenToRowsMergesRuns() {
+        let scattered = GridSelection(
+            rectangles: [
+                GridRect(rows: 1...2, columns: 1...1),
+                GridRect(rows: 2...3, columns: 4...4),
+                GridRect(rows: 6...6, columns: 0...0)
+            ],
+            activeCell: cell(2, 4),
+            anchor: cell(2, 4)
+        )
+
+        let widened = GridSelectionReducer.widenToRows(scattered, in: grid)
+
+        #expect(widened.rectangles == [wholeRows(1...3), wholeRows(6...6)])
+        #expect(widened.activeCell == cell(2, 4))
+    }
+
+    @Test("Shift-Space over Select All stays one rectangle")
+    func widenSelectAllStaysOneRectangle() {
+        let all = GridSelectionReducer.selectAll(single(0, 0), in: grid)
+
+        #expect(GridSelectionReducer.widenToRows(all, in: grid).rectangles.count == 1)
+        #expect(GridSelectionReducer.widenToRows(.empty, in: grid) == .empty)
+    }
+
+    // MARK: - Escape
+
+    @Test("Escape drops a range back to the cursor's row")
+    func cancelKeepsActiveCell() {
+        #expect(GridSelectionReducer.cancel(range(cell(1, 1), cell(3, 3)), in: grid) == cursorAt(3, 3))
+        #expect(GridSelectionReducer.cancel(range(cell(0, 0), cell(2, 2)), in: grid) == cursorAt(2, 2))
+        #expect(GridSelectionReducer.cancel(single(4, 4), in: grid) == cursorAt(4, 4))
+    }
+
+    @Test("Escape on the cursor's row clears the selection")
+    func cancelSingleCellClears() {
+        #expect(GridSelectionReducer.cancel(cursorAt(4, 4), in: grid) == .empty)
+        #expect(GridSelectionReducer.cancel(.empty, in: grid) == .empty)
+    }
+
+    @Test("Escape on whole rows clears the selection")
+    func cancelWholeRowsClears() {
+        let (rows, _) = GridSelectionReducer.rowHeaderPress(.empty, row: 3, modifiers: .shift, in: grid)
+        let (run, _) = GridSelectionReducer.rowHeaderPress(rows, row: 6, modifiers: .shift, in: grid)
+
+        #expect(GridSelectionReducer.cancel(run, in: grid) == .empty)
+        #expect(GridSelectionReducer.cancel(GridSelectionReducer.selectAll(single(1, 1), in: grid), in: grid) == .empty)
+    }
+
+    @Test("Escape on a picked column keeps the cursor")
+    func cancelPickedColumnKeepsCursor() {
+        let picked = GridSelectionReducer.columnHeaderCommandClick(.empty, column: 2, modifiers: .command, in: grid)
+
+        #expect(GridSelectionReducer.cancel(picked, in: grid) == cursorAt(0, 2))
+    }
+
+    // MARK: - Native row selection
+
+    @Test("Down from a cell selects the next row and keeps the column")
+    func nativeRowMoveKeepsColumn() {
+        let selection = GridSelectionReducer.rowsSelectedNatively(IndexSet(integer: 3), previous: single(2, 3), in: grid)
+
+        #expect(selection.rectangles == [wholeRows(3...3)])
+        #expect(selection.activeCell == cell(3, 3))
+        #expect(selection.anchor == cell(3, 3))
+    }
+
+    @Test("Rows extended natively move the cursor to the new row and keep the anchor")
+    func nativeRowExtendKeepsAnchor() {
+        let previous = GridSelection(rectangles: [wholeRows(3...3)], activeCell: cell(3, 3), anchor: cell(3, 3))
+
+        let selection = GridSelectionReducer.rowsSelectedNatively(IndexSet(integersIn: 3...4), previous: previous, in: grid)
+
+        #expect(selection.rectangles == [wholeRows(3...4)])
+        #expect(selection.activeCell == cell(4, 3))
+        #expect(selection.anchor == cell(3, 3))
+    }
+
+    @Test("Rows shrunk natively put the cursor on the end that lost a row")
+    func nativeRowShrinkMovesCursor() {
+        let previous = GridSelection(rectangles: [wholeRows(2...4)], activeCell: cell(2, 1), anchor: cell(4, 1))
+
+        let selection = GridSelectionReducer.rowsSelectedNatively(IndexSet(integersIn: 3...4), previous: previous, in: grid)
+
+        #expect(selection.activeCell == cell(3, 1))
+        #expect(selection.anchor == cell(4, 1))
+    }
+
+    @Test("Scattered native rows become one rectangle per run, and rows past the end drop")
+    func nativeRowsByRun() {
+        let selection = GridSelectionReducer.rowsSelectedNatively(IndexSet([1, 2, 5, 8, 9, 12]), previous: .empty, in: grid)
+
+        #expect(selection.rectangles == [wholeRows(1...2), wholeRows(5...5), wholeRows(8...9)])
+        #expect(selection.activeCell == cell(9, 0))
+    }
+
+    @Test("No native rows is no selection")
+    func nativeNoRows() {
+        #expect(GridSelectionReducer.rowsSelectedNatively(IndexSet(), previous: single(1, 1), in: grid) == .empty)
+    }
+}
+
+struct GridSelectionDragIndexTests {
+    private func column(hit: Int, x: CGFloat) -> Int? {
+        GridSelectionReducer.dragIndex(hit: hit, coordinate: x, first: 1, last: 4, lastMaxEdge: 500)
+    }
+
+    @Test("A drag past the trailing edge holds the last column, past the leading edge the first")
+    func outsideHitsHoldTheNearEnd() {
+        #expect(column(hit: -1, x: 5_000) == 4)
+        #expect(column(hit: -1, x: -30) == 1)
+    }
+
+    @Test("A hit inside the run is clamped into the presented range")
+    func hitInsideRunIsClamped() {
+        #expect(column(hit: 3, x: 200) == 3)
+        #expect(column(hit: 0, x: 10) == 1)
+        #expect(column(hit: 9, x: 480) == 4)
+    }
+
+    @Test("A drag below the last row holds the last row, above the first the first")
+    func rowsOutsideHoldTheNearEnd() {
+        #expect(GridSelectionReducer.dragIndex(hit: -1, coordinate: 99_999, first: 0, last: 39, lastMaxEdge: 880) == 39)
+        #expect(GridSelectionReducer.dragIndex(hit: -1, coordinate: -30, first: 0, last: 39, lastMaxEdge: 880) == 0)
+        #expect(GridSelectionReducer.dragIndex(hit: 99, coordinate: 400, first: 0, last: 39, lastMaxEdge: 880) == 39)
+    }
+
+    @Test("Nothing to land on resolves nothing")
+    func emptyRunResolvesNothing() {
+        #expect(GridSelectionReducer.dragIndex(hit: -1, coordinate: 100, first: -1, last: -1, lastMaxEdge: 0) == nil)
+        #expect(GridSelectionReducer.dragIndex(hit: -1, coordinate: 10, first: 0, last: -1, lastMaxEdge: 0) == nil)
+    }
+}
diff --git a/apple/TableProTests/Core/DataGrid/Engine/GridSelectionSnapshotTests.swift b/apple/TableProTests/Core/DataGrid/Engine/GridSelectionSnapshotTests.swift
new file mode 100644
index 0000000000..a9499cb74e
--- /dev/null
+++ b/apple/TableProTests/Core/DataGrid/Engine/GridSelectionSnapshotTests.swift
@@ -0,0 +1,216 @@
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+struct GridSelectionSnapshotTests {
+    private let names = ["a", "b", "c", "d"]
+
+    private func rows(order ids: [Int]) -> TableRows {
+        let rows = ids.map { id in
+            Row(id: .existing(id), values: ContiguousArray(names.map { PluginCellValue.text("\($0)\(id)") }))
+        }
+        return TableRows(
+            rows: ContiguousArray(rows),
+            columns: names,
+            columnTypes: names.map { _ in .text(rawType: nil) }
+        )
+    }
+
+    private var storage: TableRows { rows(order: Array(0..<6)) }
+
+    private func columns(order: [String]? = nil, hidden: Set<String> = [], in tableRows: TableRows? = nil) -> DataGridColumnSet {
+        var layout = ColumnLayoutState()
+        layout.columnOrder = order
+        layout.hiddenColumns = hidden
+        return DataGridColumnSet(tableRows: tableRows ?? storage, layout: layout)
+    }
+
+    private func cell(_ row: Int, _ column: Int) -> GridCoord {
+        GridCoord(row: row, displayColumn: column)
+    }
+
+    private func snapshot(_ selection: GridSelection) -> GridSelectionSnapshot {
+        GridSelectionSnapshot(selection, order: .unfiltered, rows: storage, columns: columns())
+    }
+
+    @Test("A selection survives a round trip through identity unchanged")
+    func roundTrip() {
+        let selection = GridSelection(
+            rectangles: [GridRect(rows: 1...2, columns: 0...1)],
+            activeCell: cell(2, 1),
+            anchor: cell(1, 0)
+        ).union(.column(2, totalRows: 6))
+
+        let resolved = snapshot(selection).resolved(order: .unfiltered, rows: storage, columns: columns())
+
+        #expect(resolved == selection)
+    }
+
+    @Test("Columns a reorder pulls apart stay apart, so no column joins the selection")
+    func reorderSplitsColumns() {
+        let selected = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 1...2, columns: 0...1)],
+            activeCell: cell(2, 1),
+            anchor: cell(1, 0)
+        ))
+
+        let reordered = columns(order: ["a", "c", "b", "d"])
+        let resolved = selected.resolved(order: .unfiltered, rows: storage, columns: reordered)
+
+        #expect(resolved.rectangles == [GridRect(rows: 1...2, columns: 0...0), GridRect(rows: 1...2, columns: 2...2)])
+        #expect(!resolved.contains(cell(1, 1)))
+    }
+
+    @Test("Whole rows keep spanning every column, one shown later included")
+    func wholeRowsSpanShownColumns() {
+        let rowsSnapshot = GridSelectionSnapshot(
+            GridSelection(
+                rectangles: [GridRect(rows: 2...3, columns: 0...2)],
+                activeCell: cell(2, 0),
+                anchor: cell(2, 0),
+                mode: .rows
+            ),
+            order: .unfiltered,
+            rows: storage,
+            columns: columns(hidden: ["d"])
+        )
+
+        let resolved = rowsSnapshot.resolved(order: .unfiltered, rows: storage, columns: columns())
+
+        #expect(resolved.rectangles == [GridRect(rows: 2...3, columns: 0...3)])
+    }
+
+    @Test("A cell selection whose columns are all gone selects nothing rather than whole rows")
+    func cellsWithGoneColumnsSelectNothing() {
+        let cells = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 1...1, columns: 3...3)],
+            activeCell: cell(1, 3),
+            anchor: cell(1, 3)
+        ))
+
+        let resolved = cells.resolved(order: .unfiltered, rows: storage, columns: columns(hidden: ["d"]))
+
+        #expect(resolved.isEmpty)
+    }
+
+    @Test("The snapshot names rows and columns by identity")
+    func capturesIdentity() {
+        let captured = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 3...4, columns: 1...2)],
+            activeCell: cell(4, 2),
+            anchor: cell(3, 1)
+        ))
+
+        #expect(captured.rowIDs == [.existing(3), .existing(4)])
+        #expect(captured.rectangles == [GridSelectionSnapshot.Rectangle(
+            rowIDs: [.existing(3), .existing(4)],
+            columnIDs: [DataGridColumnID(name: "b", occurrence: 0), DataGridColumnID(name: "c", occurrence: 0)]
+        )])
+        #expect(captured.activeCell == GridSelectionSnapshot.Cell(rowID: .existing(4), columnID: DataGridColumnID(name: "c", occurrence: 0)))
+        #expect(!captured.isEmpty)
+    }
+
+    @Test("Rows follow their identity through a filter, and a hidden anchor falls back to the active cell")
+    func rowsFollowThroughFilter() {
+        let captured = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 2...4, columns: 1...1)],
+            activeCell: cell(3, 1),
+            anchor: cell(2, 1)
+        ))
+        let filter = DataGridRowOrder(filteredIDs: [.existing(0), .existing(3), .existing(4)], revision: 1)
+
+        let resolved = captured.resolved(order: filter, rows: storage, columns: columns())
+
+        #expect(resolved.rectangles == [GridRect(rows: 1...2, columns: 1...1)])
+        #expect(resolved.activeCell == cell(1, 1))
+        #expect(resolved.anchor == cell(1, 1))
+    }
+
+    @Test("Rows that are no longer adjacent become one rectangle per run")
+    func reorderedRowsSplit() {
+        let captured = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 1...2, columns: 0...0)],
+            activeCell: cell(1, 0),
+            anchor: cell(1, 0)
+        ))
+        let reordered = rows(order: [1, 0, 2, 3, 4, 5])
+
+        let resolved = captured.resolved(order: .unfiltered, rows: reordered, columns: columns(in: reordered))
+
+        #expect(resolved.rectangles == [GridRect(rows: 0...0, columns: 0...0), GridRect(rows: 2...2, columns: 0...0)])
+        #expect(resolved.activeCell == cell(0, 0))
+    }
+
+    @Test("Columns follow their identity through a reorder")
+    func columnsFollowThroughReorder() {
+        let captured = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 0...0, columns: 1...1)],
+            activeCell: cell(0, 1),
+            anchor: cell(0, 1)
+        ))
+
+        let resolved = captured.resolved(order: .unfiltered, rows: storage, columns: columns(order: ["b", "a", "c", "d"]))
+
+        #expect(resolved.rectangles == [GridRect(rows: 0...0, columns: 0...0)])
+        #expect(resolved.activeCell == cell(0, 0))
+    }
+
+    @Test("A column the user hid drops out of the rectangle")
+    func hiddenColumnDrops() {
+        let captured = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 0...1, columns: 1...2)],
+            activeCell: cell(0, 2),
+            anchor: cell(0, 1)
+        ))
+
+        let resolved = captured.resolved(order: .unfiltered, rows: storage, columns: columns(hidden: ["b"]))
+
+        #expect(resolved.rectangles == [GridRect(rows: 0...1, columns: 1...1)])
+        #expect(resolved.activeCell == cell(0, 1))
+        #expect(resolved.anchor == cell(0, 1))
+    }
+
+    @Test("When the active row is gone the cursor moves to the first rectangle")
+    func activeRowGone() {
+        let captured = snapshot(GridSelection(
+            rectangles: [GridRect(rows: 1...1, columns: 0...0), GridRect(rows: 4...4, columns: 2...2)],
+            activeCell: cell(4, 2),
+            anchor: cell(4, 2)
+        ))
+        var shrunk = storage
+        shrunk.remove(rowIDs: [.existing(4)])
+
+        let resolved = captured.resolved(order: .unfiltered, rows: shrunk, columns: columns(in: shrunk))
+
+        #expect(resolved.rectangles == [GridRect(rows: 1...1, columns: 0...0)])
+        #expect(resolved.activeCell == cell(1, 0))
+    }
+
+    @Test("Rows saved without rectangles come back as whole rows")
+    func rowIDsAloneSelectWholeRows() {
+        let captured = GridSelectionSnapshot(rowIDs: [.existing(1), .existing(2), .existing(5)], rectangles: [], activeCell: nil, anchor: nil)
+
+        let resolved = captured.resolved(order: .unfiltered, rows: storage, columns: columns())
+
+        #expect(resolved.rectangles == [GridRect(rows: 1...2, columns: 0...3), GridRect(rows: 5...5, columns: 0...3)])
+        #expect(resolved.activeCell == cell(1, 0))
+    }
+
+    @Test("A picked column keeps its mark by identity")
+    func pickedColumnByIdentity() {
+        let captured = snapshot(.column(3, totalRows: 6))
+
+        let resolved = captured.resolved(order: .unfiltered, rows: storage, columns: columns(order: ["d", "a", "b", "c"]))
+
+        #expect(resolved.columns == IndexSet(integer: 0))
+        #expect(resolved.rectangles == [GridRect(rows: 0...5, columns: 0...0)])
+    }
+
+    @Test("The empty snapshot resolves to no selection")
+    func emptySnapshot() {
+        #expect(GridSelectionSnapshot.empty.isEmpty)
+        #expect(snapshot(.empty) == .empty)
+        #expect(GridSelectionSnapshot.empty.resolved(order: .unfiltered, rows: storage, columns: columns()) == .empty)
+    }
+}
diff --git a/apple/TableProTests/Core/Menu/MainMenuBuilderTests.swift b/apple/TableProTests/Core/Menu/MainMenuBuilderTests.swift
index 32c435490a..b451009d15 100644
--- a/apple/TableProTests/Core/Menu/MainMenuBuilderTests.swift
+++ b/apple/TableProTests/Core/Menu/MainMenuBuilderTests.swift
@@ -2,10 +2,7 @@
 //  MainMenuBuilderTests.swift
 //  TableProTests
 //
-//  Pins the menu bar's structure: HIG menu order, title uniqueness (System
-//  Settings binds an App Shortcut to a menu item's exact literal title), key
-//  equivalent uniqueness (AppKit silently blanks the loser when two items claim
-//  one combo), and complete coverage of every customizable shortcut.
+//  Unique titles (App Shortcuts bind an exact title) and key equivalents (AppKit blanks the loser of a shared combo).
 //
 
 import AppKit
@@ -146,10 +143,7 @@ struct MainMenuStructureTests {
         #expect(duplicates.isEmpty, "AppKit blanks the loser when two items claim one combo: \(duplicates)")
     }
 
-    /// A menu builder that hardcodes a key equivalent takes that combo off the table for every
-    /// `ShortcutAction`, and only `reservedAppShortcuts` tells the recorder so. Nothing else
-    /// forces the two to agree, so a hardcoded item added without a matching entry ships a
-    /// binding the recorder accepts and AppKit then blanks.
+    // Only reservedAppShortcuts tells the recorder a hardcoded combo is taken; unreserved, AppKit blanks the user's binding.
     @Test("Every hardcoded menu key equivalent is reserved against user binding")
     func hardcodedKeyEquivalentsAreReserved() {
         func canonical(_ key: BoundKey) -> String? {
@@ -178,7 +172,7 @@ struct MainMenuStructureTests {
         #expect(dead.isEmpty, "Items without an action can never enable: \(dead)")
     }
 
-    /// Only leaf commands are checked: AppKit points a submenu container at its own `submenuAction:`.
+    // Leaf commands only: AppKit points a submenu container at its own submenuAction:.
     @Test("Every authored command leaves its target nil so the responder chain resolves it")
     func targetsAreNil() {
         let targeted = buildMenu().items
@@ -215,8 +209,7 @@ struct MainMenuShortcutCoverageTests {
         #expect(item?.keyEquivalentModifierMask == [.command, .shift])
     }
 
-    /// `Cmd+Option+F` is Apple's Find and Replace key, so the filter bar moved off it rather than a
-    /// documented text-editing shortcut landing somewhere users would not look for it.
+    // Cmd+Option+F is Apple's Find and Replace key, so the filter bar moved off it.
     @Test("The find keys are Apple's and the filter bar sits beside them")
     func findAndFilterDefaultsHold() {
         #expect(KeyboardSettings.defaultShortcuts[.find] == .character("f", command: true))
@@ -313,9 +306,7 @@ struct MainMenuShortcutCoverageTests {
         #expect(item?.keyEquivalentModifierMask == [.command, .shift])
     }
 
-    /// The eight commands the revamp made rebindable. Each was reachable only by pointer before:
-    /// two segments of a toolbar control, an Edit menu item with no action identifier at all, and
-    /// five buttons inside Agent mode's rail and the assistant pane's header menu.
+    // Each was pointer-only before: two toolbar segments, an Edit item with no action id, five Agent and assistant buttons.
     private static let displacedCommands: [(action: ShortcutAction, title: String)] = [
         (.showTablesList, String(localized: "Show Tables")),
         (.showFavoritesList, String(localized: "Show Favorites")),
@@ -337,9 +328,7 @@ struct MainMenuShortcutCoverageTests {
         }
     }
 
-    /// Shipped unbound on purpose. Every combo a reasonable person would reach for is taken, and a
-    /// default that displaced a shipped one would be a worse trade than an unassigned row in
-    /// Settings, which is where these are now visible for the first time.
+    // Unbound on purpose: every reasonable combo is taken, and displacing a shipped default is worse than an unassigned row.
     @Test("Each newly rebindable command ships with no key equivalent of its own")
     func displacedCommandsShipUnbound() {
         let items = flatten(buildMenu())
@@ -350,8 +339,7 @@ struct MainMenuShortcutCoverageTests {
         }
     }
 
-    /// Settings lists every action by this name, so two sharing one would offer the user two
-    /// identical rows and no way to tell which command they were rebinding.
+    // Settings lists actions by this name, so two sharing one would be indistinguishable rows.
     @Test("No two actions share a display name")
     func displayNamesAreUnique() {
         let names = ShortcutAction.allCases.map(\.displayName)
@@ -372,9 +360,7 @@ struct MainMenuShortcutCoverageTests {
     }
 }
 
-/// Agent mode's sessions and the assistant's conversations had no menu-bar home at all: the rail's
-/// buttons and the trailing pane's header menu were the only routes, so none of the seven commands
-/// could be found by search, rebound, or reached with the rail collapsed or the pane closed.
+// Sessions and conversations had no menu-bar home, so their seven commands couldn't be searched, rebound or reached.
 @MainActor
 struct FileSessionMenuTests {
     private func sessionMenu() -> NSMenu? {
@@ -399,8 +385,7 @@ struct FileSessionMenuTests {
         ])
     }
 
-    /// The two list rows are exempt: AppKit points a submenu container at its own `submenuAction:`,
-    /// and the rows inside are built by the delegate when the list opens.
+    // The list rows are exempt: AppKit points a submenu container at its own submenuAction:, and the delegate builds the rows.
     @Test("Every leaf carries an action and leaves its target nil")
     func everyLeafIsACommand() throws {
         let leaves = try #require(sessionMenu()).items.filter { !$0.isSeparatorItem && $0.submenu == nil }
@@ -411,10 +396,7 @@ struct FileSessionMenuTests {
         }
     }
 
-    /// AppKit ignores a key equivalent on an item that owns a submenu, so the command a user can
-    /// rebind has to be a leaf. Open Session acts on the session the rail has highlighted, and the
-    /// list beside it is how any other session is reached, exactly as Import Data… and Import Data
-    /// From are split.
+    // AppKit ignores a key equivalent on an item that owns a submenu, so the rebindable Open Session must be a leaf.
     @Test("Open Session is a leaf, so a binding it is given can fire")
     func openSessionIsALeaf() throws {
         let item = try #require(
@@ -434,9 +416,7 @@ struct FileSessionMenuTests {
         #expect(submenu.items.isEmpty, "The list is filled when it opens, not at build time")
     }
 
-    /// `AIChatViewModel` is a plain `ObservableObject` and `AgentSessionRegistry` is not a responder,
-    /// so a command named on either would reach nothing and AppKit would draw it dead. Every one of
-    /// these names a window selector instead, including the two lists' rows.
+    // AIChatViewModel and AgentSessionRegistry aren't responders; a command named on either reaches nothing and draws dead.
     @Test("Each command reaches the window rather than a view model nothing can resolve")
     func everyCommandIsAWindowSelector() throws {
         var actions = try #require(sessionMenu()).items
@@ -493,8 +473,7 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.executeQuery(_:)), context))
     }
 
-    /// Redis declares no plan, and the menu item used to validate on the query text alone, so
-    /// `Cmd+Option+E` ran a `DEBUG OBJECT` the server refuses while the bar's button was dimmed.
+    // Redis declares no plan; validating on query text alone let Cmd+Option+E run a DEBUG OBJECT the server refuses.
     @Test("Explain Query needs an engine that declares a plan")
     func explainNeedsADeclaredPlan() {
         var context = MenuValidationContext()
@@ -515,7 +494,7 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.formatQuery(_:)), context))
     }
 
-    /// `runExplain` returns at its first guard while the tab runs, so a lit item did nothing.
+    // runExplain returns at its first guard while the tab runs, so a lit item did nothing.
     @Test("Explain Query dims while the tab is running a query")
     func explainDimsWhileExecuting() {
         var context = MenuValidationContext()
@@ -554,11 +533,7 @@ struct MainMenuValidationTests {
         }
     }
 
-    /// #2172: `paste:` had no window-level implementation at all, so with focus anywhere that does
-    /// not paste, AppKit disabled the item, and a disabled item still owns its key equivalent, so
-    /// Command+V was swallowed for the whole window. Adding the handler without an explicit arm
-    /// here would have been just as wrong in the other direction: `isEnabled` ends in
-    /// `default: return true`, which would have shipped Paste permanently lit.
+    // #2172: a disabled Paste still owns Cmd+V and swallowed it window-wide; isEnabled's default: true would light it forever.
     @Test("Paste needs a connection and somewhere for the rows to land")
     func pasteNeedsSomewhereToLand() {
         var context = MenuValidationContext()
@@ -570,8 +545,7 @@ struct MainMenuValidationTests {
         #expect(!enabled(#selector(MainSplitViewController.paste(_:)), context))
     }
 
-    /// A database view opens as a `.table` tab with `tableContext.isEditable` false, so tab type
-    /// alone would light Paste over content the row paste must never write to.
+    // A view opens as a .table tab with isEditable false, so tab type alone would light Paste over read-only rows.
     @Test("Paste needs the tab to be editable, not merely a table tab")
     func pasteNeedsAnEditableTab() {
         var context = MenuValidationContext()
@@ -596,8 +570,7 @@ struct MainMenuValidationTests {
         #expect(!enabled(#selector(MainSplitViewController.saveDocument(_:)), context))
     }
 
-    /// Both handlers return at their first guard in states the old validation called enabled, so
-    /// the item stayed lit and the click did nothing at all.
+    // Both handlers return at their first guard in states the old validation enabled, so the click did nothing.
     @Test("Save As needs a query tab, not just a connection")
     func saveAsNeedsAQueryTab() {
         var context = MenuValidationContext()
@@ -695,8 +668,7 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.createTableFolder(_:)), context))
     }
 
-    /// A view is a valid selection and a hopeless truncate. The menu bar used to ask only whether
-    /// anything was selected, so it offered Truncate Table for one and the server refused the save.
+    // A view is a valid selection but can't be truncated; asking only for a selection offered Truncate and the server refused.
     @Test("Truncate Table is disabled for a selection holding nothing truncatable")
     func truncateNeedsATruncatableSelection() {
         var context = MenuValidationContext()
@@ -718,8 +690,7 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.cancelQuery(_:)), context))
     }
 
-    /// A batch whose `COMMIT` is on the wire is executing and unstoppable at the same time, and
-    /// `Cmd+.` has to dim rather than fire into work nothing can interrupt.
+    // A batch whose COMMIT is on the wire is executing yet unstoppable, so Cmd+. must dim.
     @Test("Cancel Query dims while a batch is committing")
     func cancelDimsWhileCommitting() {
         var context = MenuValidationContext()
@@ -763,8 +734,7 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.openContainerSwitcher(_:)), context))
     }
 
-    /// Everything a connection-scoped command could also need is switched on, so `isConnected`
-    /// is the only thing left that can disable them.
+    // Everything else is switched on, so isConnected is the only thing left that can disable them.
     private func capableContext(phase: ConnectionWindowPhase, pane: ConnectionWindowPane) -> MenuValidationContext {
         var context = capableContext()
         context.isConnected = MainSplitViewController.isConnected(phase: phase, pane: pane)
@@ -806,8 +776,7 @@ struct MainMenuValidationTests {
         return context
     }
 
-    /// A window whose coordinator is alive is exactly the case the old `coordinator != nil`
-    /// check got wrong, so every phase is resolved with a renderable session behind it.
+    // A live coordinator is the case the old coordinator != nil check got wrong, so every phase gets a renderable session.
     private func livePane(for phase: ConnectionWindowPhase) -> ConnectionWindowPane {
         ConnectionWindowPaneResolver.pane(phase: phase, hasConnection: true, hasRenderableSession: true)
     }
@@ -838,8 +807,7 @@ struct MainMenuValidationTests {
         ]
     }
 
-    /// Gated on a grid, a tab or a sidebar selection the coordinator keeps across a lost session,
-    /// so each one needs the connection too or it stays lit over the unavailable pane.
+    // These gate on state the coordinator keeps across a lost session, so each needs the connection or stays lit.
     private var contentScopedSelectors: [Selector] {
         [
             #selector(MainSplitViewController.addRow(_:)),
@@ -854,8 +822,7 @@ struct MainMenuValidationTests {
         ]
     }
 
-    /// Both commands pre-fill from the schema's account of which columns the server fills in, so
-    /// they stay disabled until it arrives rather than staging NULL into an identity column.
+    // Both pre-fill from the schema's server-filled columns, so they wait for it rather than stage NULL into an identity column.
     @Test("Add Row and Duplicate Row wait for the schema to resolve")
     func rowInsertionWaitsForTheSchema() {
         var context = capableContext()
@@ -897,8 +864,7 @@ struct MainMenuValidationTests {
         #expect(!enabled(#selector(MainSplitViewController.editDocument(_:)), context))
     }
 
-    /// Agent mode keeps the coordinator, and with it the row and the tab the user last had, so
-    /// only the mode can dim these.
+    // Agent mode keeps the coordinator with the user's last row and tab, so only the mode can dim these.
     @Test("Agent mode dims Edit Document and Insert Document over the row the coordinator still holds")
     func documentCommandsDimInAgentMode() {
         var context = capableContext()
@@ -1000,6 +966,20 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.findPrevious(_:)), context))
     }
 
+    // The grid's find bar has a replacement field and reads a selected cell as its term, so both follow Find.
+    @Test("Find and Replace and Use Selection for Find fall back to a mounted data grid")
+    func replaceAndUseSelectionReachTheGrid() {
+        var context = MenuValidationContext()
+        context.isConnected = true
+        #expect(!enabled(#selector(MainSplitViewController.performFindAndReplace(_:)), context))
+        #expect(!enabled(#selector(MainSplitViewController.useSelectionForFind(_:)), context))
+        context.canUseGridFindCommands = true
+        #expect(enabled(#selector(MainSplitViewController.performFindAndReplace(_:)), context))
+        #expect(!enabled(#selector(MainSplitViewController.useSelectionForFind(_:)), context))
+        context.hasDataGridRowSelection = true
+        #expect(enabled(#selector(MainSplitViewController.useSelectionForFind(_:)), context))
+    }
+
     @Test("An unknown selector stays enabled so the chain can answer for it")
     func unknownSelectorsFallThrough() {
         #expect(enabled(#selector(NSWindow.performClose(_:)), MenuValidationContext()))
@@ -1018,8 +998,7 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.editViewDefinition(_:)), context))
     }
 
-    /// The sidebar hides Edit View Definition on a read-only connection. The menu bar used to leave
-    /// it enabled, so it opened the definition and the save then failed at the gate.
+    // The sidebar hides it on a read-only connection; the menu bar left it on and the save then failed at the gate.
     @Test("Editing a view definition is disabled on a read-only connection")
     func editViewDefinitionNeedsWriteAccess() {
         var context = MenuValidationContext()
@@ -1030,8 +1009,7 @@ struct MainMenuValidationTests {
         #expect(!enabled(#selector(MainSplitViewController.editViewDefinition(_:)), context))
     }
 
-    /// Reading a definition writes nothing, so these stay available on a read-only connection,
-    /// exactly as the sidebar offers them there.
+    // Reading a definition writes nothing, so these stay available read-only, as the sidebar offers them.
     @Test("Show DDL and Copy DDL need a view and survive read-only")
     func ddlCommandsFollowTheSelectedObject() {
         var context = MenuValidationContext()
@@ -1085,8 +1063,7 @@ struct MainMenuValidationTests {
         #expect(enabled(#selector(MainSplitViewController.runMaintenanceOperation(_:)), context))
     }
 
-    /// Both are sidebar commands first. They are mirrored here so the feature is reachable from
-    /// the keyboard, and they validate on the same facts the sidebar's own menu reads.
+    // Sidebar commands mirrored for the keyboard; they validate on the same facts as the sidebar's own menu.
     @Test("Copying is offered only on an engine that can copy")
     func copyObjectsNeedsASQLEngine() {
         var context = MenuValidationContext()
@@ -1170,8 +1147,7 @@ struct DatabaseMenuCommandTests {
         #expect(submenu?.items.isEmpty == true, "The submenu is filled when it opens, not at build time")
     }
 
-    /// The keyboard path to database favorites. The row star is hover-revealed and the context
-    /// menus need a right-click, so without this menu the feature is pointer-only.
+    // The keyboard path to favorites: the row star is hover-only and the context menus need a right-click.
     @Test("Favorite Database fills itself when the submenu opens")
     func favoriteDatabaseSubmenuIsDelegateDriven() {
         let container = databaseMenu()?.items.first { $0.title == String(localized: "Favorite Database") }
@@ -1216,8 +1192,7 @@ struct MainMenuBuilderTests {
         return mode.items.filter { $0.action == ContentModeMenuDelegate.action }
     }
 
-    /// A radio pair, never both ticked. With no connection window nothing validates the pair, so a
-    /// fresh menu bar ticks neither; a window that validates it ticks the mode its connection is in.
+    // With no connection window nothing validates the pair, so a fresh menu bar ticks neither.
     @Test("View > Mode never ticks both Browse and Agent")
     func modePairIsNeverBothTicked() throws {
         let items = try modeItems(in: buildMenu())
@@ -1356,7 +1331,9 @@ struct EditSetValueMenuTests {
     func onlyTheGridAnswers() {
         for leaf in Self.leaves {
             let name = NSStringFromSelector(leaf.action)
-            #expect(KeyHandlingTableView.instancesRespond(to: leaf.action), "\(name) reaches no grid")
+            let gridAnswers = DataGridTableView.instancesRespond(to: leaf.action)
+                || DataGridViewController.instancesRespond(to: leaf.action)
+            #expect(gridAnswers, "\(name) reaches no grid")
             #expect(!MainSplitViewController.instancesRespond(to: leaf.action), "\(name) answered by the window")
             #expect(!DataFileSplitViewController.instancesRespond(to: leaf.action), "\(name) answered by the window")
         }
diff --git a/apple/TableProTests/Core/SchemaTracking/StructureChangeManagerTableCommentTests.swift b/apple/TableProTests/Core/SchemaTracking/StructureChangeManagerTableCommentTests.swift
index e1251c4c7e..f393fe706c 100644
--- a/apple/TableProTests/Core/SchemaTracking/StructureChangeManagerTableCommentTests.swift
+++ b/apple/TableProTests/Core/SchemaTracking/StructureChangeManagerTableCommentTests.swift
@@ -36,6 +36,21 @@ struct StructureChangeManagerTableCommentTests {
         }
     }
 
+    private func structureAdapter(_ manager: StructureChangeManager, on tab: StructureTab) -> StructureGridAdapter {
+        let adapter = StructureGridAdapter(
+            structureChangeManager: manager,
+            connection: TestFixtures.makeConnection(type: .postgresql),
+            tableName: "orders",
+            databaseName: "shop",
+            schemaName: nil,
+            objectKind: .table,
+            isSessionBound: false
+        )
+        adapter.store.switchSubTab(to: tab)
+        adapter.refresh()
+        return adapter
+    }
+
     private func rename(_ manager: StructureChangeManager, at row: Int, to name: String) {
         var column = manager.workingColumns[row]
         column.name = name
@@ -186,21 +201,15 @@ struct StructureChangeManagerTableCommentTests {
         let manager = makeManager()
         rename(manager, at: 1, to: "amount")
         manager.stageTableComment("Orders")
-        let delegate = StructureGridDelegate(
-            structureChangeManager: manager,
-            selectedTab: .ddl,
-            connection: TestFixtures.makeConnection(type: .postgresql),
-            tableName: "orders",
-            coordinator: nil
-        )
+        let adapter = structureAdapter(manager, on: .ddl)
 
-        delegate.dataGridUndo()
+        adapter.undo()
         #expect(manager.tableComment.text == "Customer orders")
 
-        delegate.dataGridUndo()
+        adapter.undo()
         #expect(manager.workingColumns[1].name == "amount")
 
-        delegate.dataGridRedo()
+        adapter.redo()
         #expect(manager.tableComment.text == "Orders")
     }
 
@@ -208,15 +217,9 @@ struct StructureChangeManagerTableCommentTests {
     func undoOnTriggersSkipsColumnEdits() {
         let manager = makeManager()
         rename(manager, at: 1, to: "amount")
-        let delegate = StructureGridDelegate(
-            structureChangeManager: manager,
-            selectedTab: .triggers,
-            connection: TestFixtures.makeConnection(type: .postgresql),
-            tableName: "orders",
-            coordinator: nil
-        )
+        let adapter = structureAdapter(manager, on: .triggers)
 
-        delegate.dataGridUndo()
+        adapter.undo()
 
         #expect(manager.workingColumns[1].name == "amount")
     }
diff --git a/apple/TableProTests/Core/Services/DateFormattingServiceTests.swift b/apple/TableProTests/Core/Services/DateFormattingServiceTests.swift
index 19f1a07e98..ecec6574f7 100644
--- a/apple/TableProTests/Core/Services/DateFormattingServiceTests.swift
+++ b/apple/TableProTests/Core/Services/DateFormattingServiceTests.swift
@@ -88,9 +88,7 @@ struct DateFormattingServiceTests {
     }
 }
 
-/// A wall clock alone does not name an instant, so the offset the database sent is printed with it.
-/// The offset is the literal text off the value, never a pattern token: a token prints the
-/// formatter's zone, which for a value carrying none is the reader's own. (#2702)
+// The offset prints as the literal text off the value, never a pattern token, which would print the reader's zone (#2702).
 @MainActor
 struct DateFormattingServiceTimeZoneTests {
     @Test("An offset-bearing timestamp keeps its offset")
@@ -103,9 +101,7 @@ struct DateFormattingServiceTimeZoneTests {
         #expect(result == "2024-12-31 23:59:59+07")
     }
 
-    /// Every spelling measured coming out of PostgreSQL 17, plus the `Z` the MongoDB and Cassandra
-    /// drivers write. Each is printed as the database wrote it rather than normalised, so the grid
-    /// and a `Cmd+C` of the same cell read the same.
+    // Every spelling measured from PostgreSQL 17, plus the MongoDB and Cassandra `Z`, printed as written so grid and Cmd+C agree.
     @Test("Every offset spelling reaches the cell unchanged")
     func offsetSpellingsAreVerbatim() {
         DateFormattingService.shared.updateFormat(.iso8601)
@@ -188,9 +184,7 @@ struct DateFormattingServiceTimeZoneTests {
         #expect(later == "2024-03-15 09:30:00.789012")
     }
 
-    /// MySQL pads a `DATETIME(6)` to its declared precision on every row, so an all-zero fraction
-    /// is the column's shape rather than the value's, and printing it would widen every row of such
-    /// a column for nothing.
+    // MySQL pads `DATETIME(6)` on every row, so an all-zero fraction is the column's shape and would only widen every row.
     @Test("A fraction of nothing but zeros is not printed")
     func allZeroFractionIsDropped() {
         DateFormattingService.shared.updateFormat(.iso8601)
@@ -203,9 +197,7 @@ struct DateFormattingServiceTimeZoneTests {
         }
     }
 
-    /// The Unix Timestamp display format renders an instant through its own formatter, which must
-    /// never carry the slot: a control character is invisible on screen and still reaches the
-    /// clipboard, Find and the value filter.
+    // A control character is invisible on screen but still reaches the clipboard, Find and the value filter.
     @Test("The instant formatter carries no slot")
     func instantFormatterCarriesNoMarker() {
         let marker = String(DateFormatOption.fractionalSecondsMarker)
@@ -229,8 +221,7 @@ struct DateFormattingServiceTimeZoneTests {
         }
     }
 
-    /// A fraction qualifies the seconds, so it goes where the seconds end. Appending would put it
-    /// after the designator, `11:59:59 PM.123456`.
+    // Appending would put the fraction after the designator: `11:59:59 PM.123456`.
     @Test("A 12-hour format keeps the fraction with the seconds")
     func twelveHourFormatPlacesTheFractionAtTheSeconds() {
         DateFormattingService.shared.updateFormat(.usLong)
@@ -271,8 +262,7 @@ struct DateFormattingServiceTimeZoneTests {
         #expect(onShortFormat == "15/03/2024")
     }
 
-    /// The slot is a control character, so a splice that failed to run would be invisible on screen
-    /// and would still reach the clipboard, Find and the value filter.
+    // The slot is a control character: a failed splice is invisible on screen but reaches the clipboard, Find and the value filter.
     @Test("The marker never survives into a cell")
     func markerNeverReachesACell() {
         let marker = String(DateFormatOption.fractionalSecondsMarker)
@@ -291,8 +281,6 @@ struct DateFormattingServiceTimeZoneTests {
         DateFormattingService.shared.updateFormat(.iso8601)
     }
 
-    /// The marked pattern is derived from the plain one, so the two cannot drift: removing the
-    /// quoted slot has to give the pattern back exactly.
     @Test("The marked pattern is the plain pattern plus a slot")
     func markedPatternMatchesThePlainOne() {
         let slot = "'\(DateFormatOption.fractionalSecondsMarker)'"
@@ -309,8 +297,7 @@ struct DateFormattingServiceTimeZoneTests {
         }
     }
 
-    /// A captured `TimeZone.current` never follows a system time zone change, measured, so the one
-    /// formatter that renders an instant holds `.autoupdatingCurrent` instead.
+    // Measured: a captured `TimeZone.current` never follows a system zone change, so it holds `.autoupdatingCurrent`.
     @Test("An instant renders in the reader's live zone")
     func instantRendersInTheLiveZone() {
         DateFormattingService.shared.updateFormat(.iso8601)
@@ -325,8 +312,6 @@ struct DateFormattingServiceTimeZoneTests {
         #expect(DateFormattingService.shared.format(instant) == control.string(from: instant))
     }
 
-    /// Its zone is fixed but its pattern is not: a Unix-timestamp column has to follow the user's
-    /// chosen date format like every other cell.
     @Test("The instant formatter follows the chosen date format")
     func instantFormatterFollowsTheChosenFormat() {
         let instant = Date(timeIntervalSince1970: 1_700_000_000)
@@ -351,29 +336,23 @@ struct DateFormattingServiceTimeZoneTests {
         #expect(DateFormattingService.shared.systemTimeZoneGeneration > before)
     }
 
-    /// The grid keeps a tab's formatted text while the tab is unmounted, so the generation has to be
-    /// part of what the cache was built from or nothing replaces it.
-    @Test("The display identity moves with the generation")
-    func displayIdentityMovesWithTheGeneration() {
-        func identity(generation: Int) -> DataGridDisplayIdentity {
-            DataGridDisplayIdentity(
-                bufferEpoch: 1,
-                resultSetId: nil,
-                columns: ["ts"],
-                columnTypes: [.timestamp(rawType: "TIMESTAMP")],
-                displayFormats: [nil],
+    // A tab's grid model keeps its formatted text while unmounted, so the generation is one of the inputs it checks.
+    @Test("The display inputs move with the generation")
+    func displayInputsMoveWithTheGeneration() {
+        func inputs(generation: Int) -> DataTabDisplayInputs {
+            DataTabDisplayInputs(
                 dateFormat: .iso8601,
                 nullDisplay: "NULL",
                 smartValueDetection: true,
-                systemTimeZoneGeneration: generation
+                systemTimeZoneGeneration: generation,
+                overridesVersion: 0
             )
         }
-        #expect(identity(generation: 1) == identity(generation: 1))
-        #expect(identity(generation: 1) != identity(generation: 2))
+        #expect(inputs(generation: 1) == inputs(generation: 1))
+        #expect(inputs(generation: 1) != inputs(generation: 2))
     }
 
-    /// The grid opens the cell editor on the raw text, so a value it prints has to be the value the
-    /// write-back reproduces. The suffix travels through the layout for both.
+    // The cell editor opens on the raw text, so the printed value must be what the write-back reproduces.
     @Test("The printed offset is the one the write-back writes")
     func displayAgreesWithTheWriteBack() throws {
         DateFormattingService.shared.updateFormat(.iso8601)
diff --git a/apple/TableProTests/Core/Services/Query/UnloadedValuePlanTests.swift b/apple/TableProTests/Core/Services/Query/UnloadedValuePlanTests.swift
index f054727203..cd623b69c1 100644
--- a/apple/TableProTests/Core/Services/Query/UnloadedValuePlanTests.swift
+++ b/apple/TableProTests/Core/Services/Query/UnloadedValuePlanTests.swift
@@ -214,7 +214,7 @@ struct TableRowsUnloadedValueTests {
         let placeholder = DataGridCellContent.placeholder(for: .null, unloadedByteCount: 5_242_880)
         #expect(placeholder == .unloaded(byteCount: 5_242_880))
         let text = DataGridCellContent.resolvedDisplayText(
-            "", placeholder: placeholder, isLargeDataset: false, nullDisplayString: "NULL"
+            "", placeholder: placeholder, nullDisplayString: "NULL"
         )
         #expect(text == ByteCountFormatter.string(fromByteCount: 5_242_880, countStyle: .file))
     }
diff --git a/apple/TableProTests/Core/Services/RowOperationsFieldAbsenceTests.swift b/apple/TableProTests/Core/Services/RowOperationsFieldAbsenceTests.swift
index b9311bca0a..a0e0ecf3b2 100644
--- a/apple/TableProTests/Core/Services/RowOperationsFieldAbsenceTests.swift
+++ b/apple/TableProTests/Core/Services/RowOperationsFieldAbsenceTests.swift
@@ -91,7 +91,7 @@ extension GlobalStateSuites {
             let clipboard = try #require(RecordingClipboard.current)
             let tableRows = rows([["1", "Ada", .null], ["2", "Bo", .null]], absentCells: [1: [2]])
 
-            manager.copySelectedRowsToClipboard(selectedIndices: [0, 1], tableRows: tableRows, visibleColumnIndices: [2, 1])
+            manager.copyRowsToClipboard([.existing(0), .existing(1)], tableRows: tableRows, visibleColumnIndices: [2, 1])
 
             let payload = try #require(clipboard.gridRows)
             #expect(payload.columns == ["deletedAt", "name"])
diff --git a/apple/TableProTests/Core/Services/RowOperationsManagerBinaryCopyTests.swift b/apple/TableProTests/Core/Services/RowOperationsManagerBinaryCopyTests.swift
index 2bc2414ce0..a35537f619 100644
--- a/apple/TableProTests/Core/Services/RowOperationsManagerBinaryCopyTests.swift
+++ b/apple/TableProTests/Core/Services/RowOperationsManagerBinaryCopyTests.swift
@@ -31,10 +31,10 @@ extension GlobalStateSuites {
             return (rowOps, tableRows)
         }
 
-        /// The text a row copy wrote, read only when it went out as rows.
+        // Read only when the copy went out as rows.
         private func copiedText(_ rowOps: RowOperationsManager, _ tableRows: TableRows) throws -> String {
             let clipboard = try #require(RecordingClipboard.current)
-            rowOps.copySelectedRowsToClipboard(selectedIndices: [0], tableRows: tableRows)
+            rowOps.copyRowsToClipboard([.existing(0)], tableRows: tableRows)
             return clipboard.hasGridRows ? clipboard.text ?? "" : ""
         }
 
diff --git a/apple/TableProTests/Core/Services/RowOperationsManagerCopyTests.swift b/apple/TableProTests/Core/Services/RowOperationsManagerCopyTests.swift
index 26f8ff6dc4..8236d2562f 100644
--- a/apple/TableProTests/Core/Services/RowOperationsManagerCopyTests.swift
+++ b/apple/TableProTests/Core/Services/RowOperationsManagerCopyTests.swift
@@ -29,9 +29,18 @@ extension GlobalStateSuites {
             return TableRows.from(queryRows: rows.map { row in row.map(PluginCellValue.fromOptional) }, columns: cols, columnTypes: columnTypes)
         }
 
+        // The rows a grid selection names, in display order, which is how the grid hands them over.
+        private static func rowIDs(
+            _ displayRows: IndexSet,
+            in tableRows: TableRows,
+            displayIDs: [RowID]? = nil
+        ) -> [RowID] {
+            DataGridRowOrder(filteredIDs: displayIDs, revision: 0).rowIDs(atDisplayIndexes: displayRows, in: tableRows)
+        }
+
         private func copyAndCapture(
             manager: RowOperationsManager,
-            indices: Set<Int>,
+            indices: IndexSet,
             rows: [[String?]],
             columns: [String]? = nil,
             includeHeaders: Bool = false,
@@ -39,8 +48,8 @@ extension GlobalStateSuites {
         ) throws -> String? {
             let clipboard = try #require(RecordingClipboard.current)
             let tableRows = makeTableRows(rows: rows, columns: columns ?? Self.defaultColumns)
-            manager.copySelectedRowsToClipboard(
-                selectedIndices: indices,
+            manager.copyRowsToClipboard(
+                Self.rowIDs(indices, in: tableRows),
                 tableRows: tableRows,
                 includeHeaders: includeHeaders,
                 visibleColumnIndices: visibleColumnIndices
@@ -104,10 +113,7 @@ extension GlobalStateSuites {
             let clipboard = try #require(RecordingClipboard.current)
             let tableRows = makeTableRows(rows: rows)
 
-            manager.copySelectedRowsToClipboard(
-                selectedIndices: [],
-                tableRows: tableRows
-            )
+            manager.copyRowsToClipboard([], tableRows: tableRows)
 
             #expect(clipboard.writes.last == nil)
         }
@@ -122,7 +128,7 @@ extension GlobalStateSuites {
 
             let result = try copyAndCapture(
                 manager: manager,
-                indices: Set(0..<count),
+                indices: IndexSet(integersIn: 0..<count),
                 rows: rows
             )
 
@@ -132,7 +138,7 @@ extension GlobalStateSuites {
             #expect(lines.last == "\(count - 1)\tname_\(count - 1)\temail_\(count - 1)")
         }
 
-        @Test("Copied rows are in sorted index order regardless of selection order")
+        @Test("Copied rows follow display order regardless of selection order")
         func rowsInSortedOrder() throws {
             let (manager, _) = makeManager()
             let rows: [[String?]] = [
@@ -165,7 +171,7 @@ extension GlobalStateSuites {
             #expect(lines[1] == "1\tAlice\ta@test.com")
         }
 
-        @Test("Out-of-bounds indices are skipped gracefully")
+        @Test("Display positions past the rows are skipped")
         func outOfBoundsIndicesSkipped() throws {
             let (manager, _) = makeManager()
             let rows: [[String?]] = [["1", "Alice"]]
@@ -249,7 +255,7 @@ extension GlobalStateSuites {
             let clipboard = try #require(RecordingClipboard.current)
             let tableRows = makeTableRows(rows: rows)
 
-            manager.copySelectedRowsToClipboard(selectedIndices: [0], tableRows: tableRows)
+            manager.copyRowsToClipboard([.existing(0)], tableRows: tableRows)
 
             #expect(clipboard.gridRows?.columns == ["id", "name", "email"])
             #expect(clipboard.gridRows?.rows == [[.text("1"), .text("Smith, John"), .null]])
@@ -262,7 +268,7 @@ extension GlobalStateSuites {
             let clipboard = try #require(RecordingClipboard.current)
             let tableRows = makeTableRows(rows: rows)
 
-            manager.copySelectedRowsToClipboard(selectedIndices: [0], tableRows: tableRows, visibleColumnIndices: [2, 0])
+            manager.copyRowsToClipboard([.existing(0)], tableRows: tableRows, visibleColumnIndices: [2, 0])
 
             #expect(clipboard.gridRows?.columns == ["email", "id"])
             #expect(clipboard.gridRows?.rows == [[.text("alice@test.com"), .text("1")]])
@@ -281,11 +287,7 @@ extension GlobalStateSuites {
             let tableRows = makeTableRows(rows: rows)
             let displayIDs: [RowID] = [.existing(0), .existing(2), .existing(3)]
 
-            manager.copySelectedRowsToClipboard(
-                selectedIndices: [1],
-                tableRows: tableRows,
-                displayIDs: displayIDs
-            )
+            manager.copyRowsToClipboard(Self.rowIDs([1], in: tableRows, displayIDs: displayIDs), tableRows: tableRows)
 
             #expect(clipboard.writes.last == "3\tCarol\tc@test.com")
         }
@@ -302,11 +304,7 @@ extension GlobalStateSuites {
             let tableRows = makeTableRows(rows: rows)
             let displayIDs: [RowID] = [.existing(2), .existing(0)]
 
-            manager.copySelectedRowsToClipboard(
-                selectedIndices: [0, 1],
-                tableRows: tableRows,
-                displayIDs: displayIDs
-            )
+            manager.copyRowsToClipboard(Self.rowIDs([0, 1], in: tableRows, displayIDs: displayIDs), tableRows: tableRows)
 
             #expect(clipboard.writes.last == "3\tCarol\tc@test.com\n1\tAlice\ta@test.com")
         }
diff --git a/apple/TableProTests/Core/Services/RowOperationsManagerTests.swift b/apple/TableProTests/Core/Services/RowOperationsManagerTests.swift
index 1d8c2adc48..7358b7b600 100644
--- a/apple/TableProTests/Core/Services/RowOperationsManagerTests.swift
+++ b/apple/TableProTests/Core/Services/RowOperationsManagerTests.swift
@@ -38,6 +38,21 @@ struct RowOperationsManagerTests {
         )
     }
 
+    // With no value filter the display order is the storage order.
+    private func delete(
+        _ displayRows: Set<Int>,
+        with manager: RowOperationsManager,
+        in tableRows: inout TableRows
+    ) -> RowOperationsManager.DeleteRowsResult {
+        let rowIDs = displayRows.sorted().compactMap { tableRows.rows.indices.contains($0) ? tableRows.rows[$0].id : nil }
+        return manager.deleteRows(
+            rowIDs,
+            selectedDisplayIndices: displayRows,
+            displayCount: tableRows.count,
+            tableRows: &tableRows
+        )
+    }
+
     private func emptyTableRows(
         columnDefaults: [String: String?] = [:],
         columnIdentity: [String: IdentityKind] = [:],
@@ -107,10 +122,7 @@ struct RowOperationsManagerTests {
         #expect(result?.values[2] == "__DEFAULT__")
     }
 
-    /// PostgreSQL leaves `column_default` null for an identity column and reports the generation in
-    /// `pg_attribute.attidentity`, so a new row went out carrying an explicit NULL that the server
-    /// refuses: "cannot insert a non-DEFAULT value into column" for GENERATED ALWAYS, and a
-    /// not-null violation for GENERATED BY DEFAULT.
+    // PostgreSQL leaves `column_default` null for an identity column, so a new row sent an explicit NULL it refuses.
     @Test(
         "addNewRow uses DEFAULT marker for an identity column that has no default",
         arguments: [IdentityKind.always, IdentityKind.byDefault]
@@ -125,9 +137,7 @@ struct RowOperationsManagerTests {
         #expect(result?.values[1] == .null)
     }
 
-    /// Read from the rows rather than from the change manager, which `configureForTable` empties on
-    /// every execution and only a schema fetch refills. A rerun answered from cache runs no schema
-    /// fetch, so a generated column pre-filled NULL and then went out in the INSERT.
+    // Read from the rows: `configureForTable` empties the change manager's copy and a cached rerun never refills it.
     @Test("addNewRow uses DEFAULT marker for a generated column carried on the rows")
     func addNewRowUsesDefaultMarkerForGeneratedColumn() {
         let (manager, changeManager) = makeManager()
@@ -140,8 +150,7 @@ struct RowOperationsManagerTests {
         #expect(result?.values[1] == .null)
     }
 
-    /// A nullable MySQL column reads back with a NULL default (#3058), and one whose default was
-    /// dropped reads back the same way while failing an INSERT that omits it with ERROR 1364.
+    // A nullable MySQL column and one whose default was dropped both read back NULL (#3058); omitting the latter is ERROR 1364.
     @Test("addNewRow sends NULL rather than DEFAULT for a column whose default is NULL", arguments: ["NULL", "null"])
     func addNewRowSendsNullForNullDefault(spelling: String) {
         let (manager, _) = makeManager()
@@ -161,9 +170,7 @@ struct RowOperationsManagerTests {
 
         let result = manager.addNewRow(tableRows: &tableRows)
 
-        /// `.null`, not a Swift nil. A column with no default gets an explicit SQL NULL, which is
-        /// what `addNewRow` appends; an absent value and a NULL are different things to the
-        /// statement generator, and only one of them round-trips to the server.
+        // An explicit SQL NULL, not a Swift nil: the statement generator treats an absent value differently.
         #expect(result != nil)
         #expect(result?.values[1] == .null)
         #expect(result?.values[2] == .null)
@@ -182,11 +189,7 @@ struct RowOperationsManagerTests {
     }
 
     @Test("addNewRow increments change manager reload version")
-    /// `reloadVersion` is the signal that tells the grid to throw away what it is showing and fetch
-    /// again. It increments on `clearChanges`, `discardChanges` and `configureForTable`, and
-    /// deliberately not on recording an edit: a reload there would discard the very edit the user
-    /// just made. These asserted the opposite, which is why they sat in the quarantine file, so
-    /// each now pins the real contract from both sides.
+    // `reloadVersion` tells the grid to fetch again, so recording an edit must not move it or the edit is thrown away.
     func addNewRowDoesNotAskTheGridToReload() {
         let (manager, changeManager) = makeManager()
         var tableRows = makeTableRows(rowCount: 2)
@@ -251,8 +254,7 @@ struct RowOperationsManagerTests {
         }
     }
 
-    /// An identity column need not be the primary key, so the primary-key reset alone left one
-    /// carrying the source row's value and the server rejected the copy.
+    // An identity column need not be the primary key, so the key reset alone left it carrying the source's value.
     @Test("duplicateRow sets a non-key identity column to DEFAULT")
     func duplicateRowResetsNonKeyIdentityColumn() {
         let (manager, _) = makeManager()
@@ -278,33 +280,27 @@ struct RowOperationsManagerTests {
         #expect(result == nil)
     }
 
-    @Test("deleteSelectedRows marks existing rows as deleted")
-    func deleteSelectedRowsMarksExistingAsDeleted() {
+    @Test("deleteRows marks existing rows as deleted")
+    func deleteRowsMarksExistingAsDeleted() {
         let (manager, changeManager) = makeManager()
         var tableRows = makeTableRows(rowCount: 5)
 
-        _ = manager.deleteSelectedRows(
-            selectedIndices: [1, 3],
-            tableRows: &tableRows
-        )
+        _ = delete([1, 3], with: manager, in: &tableRows)
 
         #expect(changeManager.hasChanges)
         #expect(changeManager.isRowDeleted(.existing(1)))
         #expect(changeManager.isRowDeleted(.existing(3)))
     }
 
-    @Test("deleteSelectedRows removes inserted rows from tableRows and reports delta")
-    func deleteSelectedRowsRemovesInsertedRows() {
+    @Test("deleteRows removes inserted rows from tableRows and reports delta")
+    func deleteRowsRemovesInsertedRows() {
         let (manager, _) = makeManager()
         var tableRows = makeTableRows(rowCount: 3)
 
         _ = manager.addNewRow(tableRows: &tableRows)
         #expect(tableRows.count == 4)
 
-        let result = manager.deleteSelectedRows(
-            selectedIndices: [3],
-            tableRows: &tableRows
-        )
+        let result = delete([3], with: manager, in: &tableRows)
 
         #expect(tableRows.count == 3)
         if case .rowsRemoved(let indices) = result.delta {
@@ -314,56 +310,53 @@ struct RowOperationsManagerTests {
         }
     }
 
-    @Test("deleteSelectedRows returns correct next selection")
-    func deleteSelectedRowsReturnsNextSelection() {
+    @Test("deleteRows returns correct next selection")
+    func deleteRowsReturnsNextSelection() {
         let (manager, _) = makeManager()
         var tableRows = makeTableRows(rowCount: 5)
 
         _ = manager.addNewRow(tableRows: &tableRows)
         #expect(tableRows.count == 6)
 
-        let result = manager.deleteSelectedRows(
-            selectedIndices: [5],
-            tableRows: &tableRows
-        )
+        let result = delete([5], with: manager, in: &tableRows)
 
         #expect(result.nextRowToSelect >= 0)
         #expect(result.nextRowToSelect < tableRows.count)
     }
 
-    @Test("deleteSelectedRows selects the row after the block, or the one before it at the end")
-    func deleteSelectedRowsNextSelection() {
+    @Test("deleteRows selects the row after the block, or the one before it at the end")
+    func deleteRowsNextSelection() {
         let (manager, _) = makeManager()
 
         var fourRows = makeTableRows(rowCount: 4)
-        #expect(manager.deleteSelectedRows(selectedIndices: [1], tableRows: &fourRows).nextRowToSelect == 2)
+        #expect(delete([1], with: manager, in: &fourRows).nextRowToSelect == 2)
 
         var fromTheEnd = makeTableRows(rowCount: 4)
-        #expect(manager.deleteSelectedRows(selectedIndices: [3], tableRows: &fromTheEnd).nextRowToSelect == 2)
+        #expect(delete([3], with: manager, in: &fromTheEnd).nextRowToSelect == 2)
 
         var block = makeTableRows(rowCount: 6)
-        #expect(manager.deleteSelectedRows(selectedIndices: [1, 2, 3], tableRows: &block).nextRowToSelect == 4)
+        #expect(delete([1, 2, 3], with: manager, in: &block).nextRowToSelect == 4)
     }
 
-    @Test("deleteSelectedRows counts the rows the removal took out before choosing the next one")
-    func deleteSelectedRowsNextSelectionAfterRemovals() {
+    @Test("deleteRows counts the rows the removal took out before choosing the next one")
+    func deleteRowsNextSelectionAfterRemovals() {
         let (manager, _) = makeManager()
         var tableRows = makeTableRows(rowCount: 2)
         _ = manager.addNewRow(tableRows: &tableRows)
         _ = manager.addNewRow(tableRows: &tableRows)
 
-        let result = manager.deleteSelectedRows(selectedIndices: [2, 3], tableRows: &tableRows)
+        let result = delete([2, 3], with: manager, in: &tableRows)
 
         #expect(tableRows.count == 2)
         #expect(result.nextRowToSelect == 1)
     }
 
-    @Test("deleteSelectedRows returns empty result for empty selection")
-    func deleteSelectedRowsEmptySelection() {
+    @Test("deleteRows returns empty result for empty selection")
+    func deleteRowsEmptySelection() {
         let (manager, _) = makeManager()
         var tableRows = makeTableRows(rowCount: 3)
 
-        let result = manager.deleteSelectedRows(selectedIndices: [], tableRows: &tableRows)
+        let result = delete([], with: manager, in: &tableRows)
 
         #expect(result.physicallyRemovedIndices.isEmpty)
         #expect(result.nextRowToSelect == -1)
@@ -371,20 +364,20 @@ struct RowOperationsManagerTests {
         #expect(tableRows.count == 3)
     }
 
-    @Test("deleteSelectedRows: deleting only existing rows leaves physicallyRemovedIndices empty")
-    func deleteSelectedRowsExistingOnly() {
+    @Test("deleteRows: deleting only existing rows leaves physicallyRemovedIndices empty")
+    func deleteRowsExistingOnly() {
         let (manager, _) = makeManager()
         var tableRows = makeTableRows(rowCount: 5)
 
-        let result = manager.deleteSelectedRows(selectedIndices: [1, 3], tableRows: &tableRows)
+        let result = delete([1, 3], with: manager, in: &tableRows)
 
         #expect(result.physicallyRemovedIndices.isEmpty)
         #expect(result.delta == .none)
         #expect(tableRows.count == 5)
     }
 
-    @Test("deleteSelectedRows: deleting only inserted rows reports each in physicallyRemovedIndices")
-    func deleteSelectedRowsInsertedOnly() {
+    @Test("deleteRows: deleting only inserted rows reports each in physicallyRemovedIndices")
+    func deleteRowsInsertedOnly() {
         let (manager, _) = makeManager()
         var tableRows = makeTableRows(rowCount: 2)
 
@@ -393,7 +386,7 @@ struct RowOperationsManagerTests {
         _ = manager.addNewRow(tableRows: &tableRows)
         #expect(tableRows.count == 5)
 
-        let result = manager.deleteSelectedRows(selectedIndices: [2, 3, 4], tableRows: &tableRows)
+        let result = delete([2, 3, 4], with: manager, in: &tableRows)
 
         #expect(result.physicallyRemovedIndices == [4, 3, 2])
         #expect(tableRows.count == 2)
@@ -404,28 +397,27 @@ struct RowOperationsManagerTests {
         }
     }
 
-    @Test("deleteSelectedRows: mixed inserted and existing rows reports only inserted indices")
-    func deleteSelectedRowsMixed() {
+    @Test("deleteRows: mixed inserted and existing rows reports only inserted indices")
+    func deleteRowsMixed() {
         let (manager, _) = makeManager()
         var tableRows = makeTableRows(rowCount: 3)
 
         _ = manager.addNewRow(tableRows: &tableRows)
         #expect(tableRows.count == 4)
 
-        let result = manager.deleteSelectedRows(selectedIndices: [0, 3], tableRows: &tableRows)
+        let result = delete([0, 3], with: manager, in: &tableRows)
 
         #expect(result.physicallyRemovedIndices == [3])
         #expect(tableRows.count == 3)
     }
 
-    @Test("Under a value filter, a selected position deletes the row shown there")
-    func deleteSelectedRowsUnderFilterMarksTheShownRow() {
+    @Test("Under a value filter, the row named by identity is the one deleted")
+    func deleteRowsUnderFilterMarksTheNamedRow() {
         let (manager, changeManager) = makeManager()
         var tableRows = makeTableRows(rowCount: 4)
-        let displayIDs: [RowID] = [.existing(3), .existing(1)]
         let shownRow = Array(tableRows.rows[1].values)
 
-        _ = manager.deleteSelectedRows(selectedIndices: [1], displayIDs: displayIDs, tableRows: &tableRows)
+        _ = manager.deleteRows([.existing(1)], selectedDisplayIndices: [1], displayCount: 2, tableRows: &tableRows)
 
         #expect(changeManager.isRowDeleted(.existing(1)))
         #expect(!changeManager.isRowDeleted(.existing(3)))
@@ -436,16 +428,14 @@ struct RowOperationsManagerTests {
     }
 
     @Test("Under a value filter, a selected inserted row is removed from its storage position")
-    func deleteSelectedRowsUnderFilterRemovesInsertedRow() {
+    func deleteRowsUnderFilterRemovesInsertedRow() {
         let (manager, changeManager) = makeManager()
         var tableRows = makeTableRows(rowCount: 3)
         guard let addResult = manager.addNewRow(tableRows: &tableRows) else {
             Issue.record("addNewRow returned nil")
             return
         }
-        let displayIDs: [RowID] = [.existing(2), addResult.rowID]
-
-        let result = manager.deleteSelectedRows(selectedIndices: [1], displayIDs: displayIDs, tableRows: &tableRows)
+        let result = manager.deleteRows([addResult.rowID], selectedDisplayIndices: [1], displayCount: 2, tableRows: &tableRows)
 
         #expect(tableRows.count == 3)
         #expect(tableRows.index(of: addResult.rowID) == nil)
@@ -473,7 +463,7 @@ struct RowOperationsManagerTests {
             return
         }
 
-        _ = manager.deleteSelectedRows(selectedIndices: [2, 3], tableRows: &tableRows)
+        _ = delete([2, 3], with: manager, in: &tableRows)
         #expect(tableRows.count == 2)
 
         undoManager.undo()
diff --git a/apple/TableProTests/Core/Services/RowOperationsManagerUUIDKeyTests.swift b/apple/TableProTests/Core/Services/RowOperationsManagerUUIDKeyTests.swift
index e104198bee..5601c64f35 100644
--- a/apple/TableProTests/Core/Services/RowOperationsManagerUUIDKeyTests.swift
+++ b/apple/TableProTests/Core/Services/RowOperationsManagerUUIDKeyTests.swift
@@ -241,7 +241,7 @@ extension GlobalStateSuites {
             _ = rows.appendInsertedRow(id: pendingID, values: pendingValues)
             changeManager.recordRowInsertion(rowID: pendingID, values: pendingValues, expressionColumns: [2])
 
-            manager.copySelectedRowsToClipboard(selectedIndices: [0, 1], tableRows: rows)
+            manager.copyRowsToClipboard([.existing(0), pendingID], tableRows: rows)
             let payload = try #require(RecordingClipboard.current?.gridRows)
             #expect(payload.expressionCells == [1: [2]])
 
diff --git a/apple/TableProTests/Core/Utilities/DisplayedResultReaderTests.swift b/apple/TableProTests/Core/Utilities/DisplayedResultReaderTests.swift
index f5f5f0aada..fc8c7f1c37 100644
--- a/apple/TableProTests/Core/Utilities/DisplayedResultReaderTests.swift
+++ b/apple/TableProTests/Core/Utilities/DisplayedResultReaderTests.swift
@@ -64,8 +64,7 @@ struct DisplayedResultReaderTests {
         #expect(texts(output) == [["a", "1"], ["c", "3"]])
     }
 
-    /// The invariant a per-column value filter breaks: `GridSelectionState.indices` are positions on
-    /// screen, and once `displayIDs` reorders or narrows the rows they stop matching array indices.
+    // A grid selection names positions on screen; once `displayIDs` reorders the rows they stop matching array indices.
     @Test("A selected index is a display position, not a storage index")
     func selectionIndicesAreDisplayPositions() {
         let output = read(displayIDs: [.existing(2), .existing(0)], selected: [0])
diff --git a/apple/TableProTests/Models/MultiRowEditStateBinaryRevertTests.swift b/apple/TableProTests/Models/MultiRowEditStateBinaryRevertTests.swift
index d28e06936b..f9c4f44c9b 100644
--- a/apple/TableProTests/Models/MultiRowEditStateBinaryRevertTests.swift
+++ b/apple/TableProTests/Models/MultiRowEditStateBinaryRevertTests.swift
@@ -16,11 +16,9 @@ struct MultiRowEditStateBinaryRevertTests {
     private static let wkbPoint = Data(
         [0x01, 0x01, 0x00, 0x00, 0x00] + [0, 0, 0, 0, 0, 0, 0xF0, 0x3F] + [0, 0, 0, 0, 0, 0, 0, 0x40]
     )
-    /// Every byte value, NUL first.
     private static let everyByte = Data((0 ... 255).map { UInt8($0) })
 
-    /// The handoff the main window does: the typed cells decide which columns are binary, and the
-    /// fields get each cell as text, bytes as one character per byte.
+    // The main window's handoff: typed cells pick the binary columns, and bytes reach the fields one character per byte.
     private func makeSUT(cells: [[PluginCellValue]], columnTypes: [ColumnType]) -> MultiRowEditState {
         let sut = MultiRowEditState()
         let rows: [[String?]] = cells.map { row in
@@ -33,7 +31,6 @@ struct MultiRowEditStateBinaryRevertTests {
             }
         }
         sut.configure(
-            selectedRowIndices: Set(cells.indices),
             rowIDs: cells.indices.map { RowID.existing($0) },
             allRows: rows,
             columns: columnTypes.indices.map { "c\($0)" },
@@ -43,7 +40,7 @@ struct MultiRowEditStateBinaryRevertTests {
         return sut
     }
 
-    /// What Clear in the field's menu does: put the field's own original value back.
+    // What Clear in the field's menu does.
     private func clear(_ sut: MultiRowEditState, at index: Int) {
         sut.updateField(at: index, value: sut.fields[index].originalValue ?? "")
     }
diff --git a/apple/TableProTests/Models/MultiRowEditStateClearedFieldTests.swift b/apple/TableProTests/Models/MultiRowEditStateClearedFieldTests.swift
index b419004bb4..05e863605b 100644
--- a/apple/TableProTests/Models/MultiRowEditStateClearedFieldTests.swift
+++ b/apple/TableProTests/Models/MultiRowEditStateClearedFieldTests.swift
@@ -25,7 +25,6 @@ struct MultiRowEditStateClearedFieldTests {
     private func makeState(_ recorder: StagedFieldRecorder) -> MultiRowEditState {
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: [0],
             rowIDs: [.existing(0)],
             allRows: [["1", "2024-01-01 10:00:00", "Alice", "{\"a\":1}", "2023-12-01 09:00:00"]],
             columns: Self.columns,
diff --git a/apple/TableProTests/Models/MultiRowEditStateFieldAbsenceTests.swift b/apple/TableProTests/Models/MultiRowEditStateFieldAbsenceTests.swift
index 7bb457ddd7..e2e9c45920 100644
--- a/apple/TableProTests/Models/MultiRowEditStateFieldAbsenceTests.swift
+++ b/apple/TableProTests/Models/MultiRowEditStateFieldAbsenceTests.swift
@@ -16,7 +16,6 @@ struct MultiRowEditStateFieldAbsenceTests {
     private func configured(rows: [[String?]], absentCells: [Set<Int>], modified: Set<Int> = []) -> MultiRowEditState {
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: Set(rows.indices),
             rowIDs: Array([rowA, rowB].prefix(rows.count)),
             allRows: rows,
             absentCells: absentCells,
@@ -113,8 +112,7 @@ struct MultiRowEditStateFieldAbsenceTests {
         #expect(reverted == [rowA])
     }
 
-    /// Staging refuses a value for a MongoDB `_id`, so the inspector offered Remove Field, Set NULL
-    /// and typing on a field whose edit then stayed pending and never saved.
+    // Staging refuses a MongoDB `_id`, so an editable field there left an edit pending that never saved.
     @Test("A column the change manager refuses is read-only in the inspector, Remove Field included")
     func unwritableColumnOffersNoEdit() throws {
         let manager = DataChangeManager()
@@ -124,7 +122,6 @@ struct MultiRowEditStateFieldAbsenceTests {
         )
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: [0],
             rowIDs: [rowA],
             allRows: [["1", "Ada"]],
             absentCells: [[]],
diff --git a/apple/TableProTests/Models/MultiRowEditStateSetValueTests.swift b/apple/TableProTests/Models/MultiRowEditStateSetValueTests.swift
index 7f86424148..0989b77300 100644
--- a/apple/TableProTests/Models/MultiRowEditStateSetValueTests.swift
+++ b/apple/TableProTests/Models/MultiRowEditStateSetValueTests.swift
@@ -32,7 +32,6 @@ struct MultiRowEditStateSetValueTests {
     ) -> MultiRowEditState {
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: Set(rows.indices),
             rowIDs: rowIDs,
             allRows: rows,
             expressionCells: expressionCells,
@@ -221,7 +220,7 @@ struct MultiRowEditStateSetValueTests {
         #expect(detached.last?.isExpression == false)
     }
 
-    /// The grid staged `now()`; the inspector shows it, the user types over it and then types it back.
+    // The grid staged `now()`; the user types over it in the inspector, then types it back.
     @Test("Clearing a field back to the SQL its rows held sends it back as SQL, not as text")
     func revertKeepsTheExpression() {
         let rowID = RowID.existing(0)
@@ -362,8 +361,7 @@ struct MultiRowEditStateSetValueTests {
         #expect(reverted == generated)
     }
 
-    /// After a per-row edit the inspector is rebuilt with the column modified and its rows disagreeing.
-    /// `configure` wrote `originalValue ?? ""` as the pending value, so the field showed an empty value.
+    // `configure` wrote `originalValue ?? ""` as the pending value, so rows that disagreed showed an empty value.
     @Test("A modified column the rows disagree on reads Multiple values, not an empty pending value")
     func modifiedMultiValuedFieldReadsMultipleValues() {
         let state = makeState(
diff --git a/apple/TableProTests/Models/MultiRowEditStateTests.swift b/apple/TableProTests/Models/MultiRowEditStateTests.swift
index 47b2dfedd8..311c93b45d 100644
--- a/apple/TableProTests/Models/MultiRowEditStateTests.swift
+++ b/apple/TableProTests/Models/MultiRowEditStateTests.swift
@@ -23,7 +23,7 @@ struct MultiRowEditStateTests {
         let sut = MultiRowEditState()
         let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
         sut.configure(
-            selectedRowIndices: selectedIndices,
+            rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
             allRows: rows,
             columns: columns,
             columnTypes: types
@@ -129,7 +129,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
             sut.configure(
-                selectedRowIndices: selectedIndices,
+                rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
                 allRows: rows,
                 columns: columns,
                 columnTypes: types
@@ -214,7 +214,7 @@ struct MultiRowEditStateTests {
         func missingColumnTypesFallback() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice"]],
                 columns: ["id", "name"],
                 columnTypes: []
@@ -241,7 +241,7 @@ struct MultiRowEditStateTests {
 
             // Reconfigure with name changed in underlying data but id unchanged
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "UpdatedName", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)]
@@ -263,7 +263,7 @@ struct MultiRowEditStateTests {
 
             // Reconfigure with identical data
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)]
@@ -283,7 +283,7 @@ struct MultiRowEditStateTests {
 
             // Reconfigure with different columns
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["x", "y"]],
                 columns: ["col_a", "col_b"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil)]
@@ -301,7 +301,7 @@ struct MultiRowEditStateTests {
 
             // Reconfigure with different selection
             sut.configure(
-                selectedRowIndices: [1],
+                rowIDs: [.existing(1)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)]
@@ -319,7 +319,7 @@ struct MultiRowEditStateTests {
             #expect(sut.fields.first(where: { $0.columnIndex == 1 })?.originalValue == "{\"reached\":\"07:53\"}")
 
             sut.configure(
-                selectedRowIndices: [1],
+                rowIDs: [.existing(1)],
                 allRows: [["2", "{\"reached\":\"08:40\"}"]],
                 columns: ["id", "payload"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil)]
@@ -340,7 +340,7 @@ struct MultiRowEditStateTests {
             #expect(sut.fields[0].hasEdit == true)
 
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "2", "3"]],
                 columns: ["a", "b", "c"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)]
@@ -364,7 +364,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
             sut.configure(
-                selectedRowIndices: selectedIndices,
+                rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
                 allRows: rows,
                 columns: columns,
                 columnTypes: types
@@ -470,7 +470,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
             sut.configure(
-                selectedRowIndices: selectedIndices,
+                rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
                 allRows: rows,
                 columns: columns,
                 columnTypes: types
@@ -558,7 +558,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
             sut.configure(
-                selectedRowIndices: selectedIndices,
+                rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
                 allRows: rows,
                 columns: columns,
                 columnTypes: types
@@ -608,7 +608,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
             sut.configure(
-                selectedRowIndices: selectedIndices,
+                rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
                 allRows: rows,
                 columns: columns,
                 columnTypes: types
@@ -674,7 +674,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
             sut.configure(
-                selectedRowIndices: selectedIndices,
+                rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
                 allRows: rows,
                 columns: columns,
                 columnTypes: types
@@ -788,7 +788,7 @@ struct MultiRowEditStateTests {
             #expect(callbackCalls[0].value == "__DEFAULT__")
         }
 
-        /// `onFieldChanged` carries a literal, so an expression sent through it would be saved as quoted text.
+        // `onFieldChanged` carries a literal, so an expression sent through it would be saved as quoted text.
         @Test("setFieldToExpression sends the SQL through the expression callback, not as a literal")
         func setFieldToExpressionFiresExpressionCallback() {
             let sut = makeSUT()
@@ -848,7 +848,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types = columnTypes ?? columns.map { _ in ColumnType.text(rawType: nil) }
             sut.configure(
-                selectedRowIndices: selectedIndices,
+                rowIDs: selectedIndices.sorted().map { RowID.existing($0) },
                 allRows: rows,
                 columns: columns,
                 columnTypes: types
@@ -860,7 +860,7 @@ struct MultiRowEditStateTests {
         func marksSpecifiedColumnAsModified() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)],
@@ -874,7 +874,7 @@ struct MultiRowEditStateTests {
         func doesNotMarkUnspecifiedColumns() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)],
@@ -888,7 +888,7 @@ struct MultiRowEditStateTests {
         func multipleExternallyModifiedColumnsAllShowHasEdit() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)],
@@ -908,7 +908,7 @@ struct MultiRowEditStateTests {
             #expect(sut.fields[0].pendingValue == "sidebar-edit")
 
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)],
@@ -925,7 +925,7 @@ struct MultiRowEditStateTests {
         func gridStagedNullIsPendingNull() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [[nil, "Alice"]],
                 columns: ["id", "name"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil)],
@@ -940,7 +940,7 @@ struct MultiRowEditStateTests {
         func gridStagedNullBooleanIsPendingNull() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", nil]],
                 columns: ["id", "active"],
                 columnTypes: [.integer(rawType: "INT"), .boolean(rawType: "TINYINT(1)")],
@@ -953,7 +953,7 @@ struct MultiRowEditStateTests {
         func multipleValuesAreNotPendingNull() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0, 1],
+                rowIDs: [.existing(0), .existing(1)],
                 allRows: [["1", "Alice"], ["2", "Bob"]],
                 columns: ["id", "name"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil)],
@@ -972,7 +972,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types: [ColumnType] = [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)]
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: types
@@ -985,7 +985,7 @@ struct MultiRowEditStateTests {
 
             // Reconfigure with same data and NO externallyModifiedColumns
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: types
@@ -1000,7 +1000,7 @@ struct MultiRowEditStateTests {
             let sut = MultiRowEditState()
             let types: [ColumnType] = [.text(rawType: nil), .text(rawType: nil), .text(rawType: nil)]
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: types
@@ -1015,7 +1015,7 @@ struct MultiRowEditStateTests {
 
             // Reconfigure with same selection and rows
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["1", "Alice", "alice@test.com"]],
                 columns: ["id", "name", "email"],
                 columnTypes: types
@@ -1051,7 +1051,7 @@ struct MultiRowEditStateTests {
             #expect(sut.fields.allSatisfy { $0.isSchemaField })
             #expect(sut.fields[2].hasCommittedEdit)
             #expect(sut.fields[0].hasCommittedEdit == false)
-            #expect(sut.selectedRowIndices == [2])
+            #expect(sut.rowIDs.isEmpty)
         }
 
         @Test("A field the owning grid locks is shown without an editor")
@@ -1146,8 +1146,7 @@ struct MultiRowEditStateTests {
             GeometryFieldDescriptor(textEditor: .multiLine, source: .spatialColumn)
         )
 
-        /// The handoff the main window does: the typed cells decide which columns are binary, and
-        /// the fields get each cell as text, bytes as one character per byte.
+        // The main window's handoff: typed cells pick the binary columns, and bytes reach the fields one character per byte.
         private func makeSUT(cells: [[PluginCellValue]], columnTypes: [ColumnType]) -> MultiRowEditState {
             let sut = MultiRowEditState()
             let rows: [[String?]] = cells.map { row in
@@ -1160,7 +1159,7 @@ struct MultiRowEditStateTests {
                 }
             }
             sut.configure(
-                selectedRowIndices: Set(cells.indices),
+                rowIDs: cells.indices.map { RowID.existing($0) },
                 allRows: rows,
                 columns: columnTypes.indices.map { "c\($0)" },
                 columnTypes: columnTypes,
@@ -1175,7 +1174,7 @@ struct MultiRowEditStateTests {
             #expect(MultiRowEditState.binaryColumns(in: cells) == [1])
         }
 
-        /// A binary field commits bytes to every selected row, so one text cell rules the column out.
+        // A binary field commits bytes to every selected row, so one text cell rules the column out.
         @Test("A column mixing bytes and text across the selection is not binary")
         func mixedBytesAndTextIsNotBinary() {
             let cells: [[PluginCellValue]] = [
@@ -1186,7 +1185,6 @@ struct MultiRowEditStateTests {
             #expect(MultiRowEditState.binaryColumns(in: cells) == [0, 2])
         }
 
-        /// NULL in a text geometry column must not turn the field into a hex editor.
         @Test("A column of NULLs alone is not binary")
         func nullOnlyColumnIsNotBinary() {
             #expect(MultiRowEditState.binaryColumns(in: [[.null], [.null]]).isEmpty)
@@ -1212,7 +1210,7 @@ struct MultiRowEditStateTests {
         func binaryColumnsDefaultToNone() {
             let sut = MultiRowEditState()
             sut.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [[String(data: Self.wkbPoint, encoding: .isoLatin1)]],
                 columns: ["geom"],
                 columnTypes: [.spatial(rawType: "POINT")]
@@ -1247,7 +1245,7 @@ struct MultiRowEditStateTests {
             #expect(sut.fields[0].resolvedEditor == Self.geometryHex)
         }
 
-        /// Rows that disagree have no bytes to read, and a blob still never gets a text field.
+        // Rows that disagree have no bytes to read, and a blob still never gets a text field.
         @Test("Binary rows that disagree get the hex editor")
         func disagreeingBinaryRowsResolveToHex() {
             let sut = makeSUT(
diff --git a/apple/TableProTests/Models/Query/QueryResultPresentationTests.swift b/apple/TableProTests/Models/Query/QueryResultPresentationTests.swift
index c8725d7d25..339f6a15d2 100644
--- a/apple/TableProTests/Models/Query/QueryResultPresentationTests.swift
+++ b/apple/TableProTests/Models/Query/QueryResultPresentationTests.swift
@@ -23,8 +23,7 @@ struct QueryResultPresentationTests {
         #expect(presentation.showsErrorBanner == false)
     }
 
-    /// A table tab describes a table whether or not its rows have arrived, so the idle rule above
-    /// must not reach it: retargeting empties the buffer before the replacing fetch starts.
+    // Retargeting empties the buffer before the replacing fetch starts, so the idle rule must not reach a table tab.
     @Test("A table tab with no rows yet still draws its grid")
     func freshTableTabKeepsGrid() {
         var inputs = QueryResultInputs()
@@ -41,9 +40,7 @@ struct QueryResultPresentationTests {
         #expect(QueryResultPresentation(inputs: inputs).content == .executing)
     }
 
-    /// The state every retarget passes through: the buffer was emptied for the new table and its
-    /// first page is in flight. It used to resolve to `.executing`, which drew a blank pane for the
-    /// whole fetch and unmounted the grid.
+    // Every retarget passes through this. It used to resolve to `.executing`, blanking the pane and unmounting the grid.
     @Test("A table tab loading its first page keeps its grid")
     func tableTabLoadingKeepsGrid() {
         var inputs = QueryResultInputs()
@@ -70,8 +67,7 @@ struct QueryResultPresentationTests {
         }
     }
 
-    /// A failed first load leaves no result set, and Dismiss clears the error, which used to leave
-    /// a blank pane that no tab switch reloaded.
+    // A failed first load leaves no result set and Dismiss clears the error; this used to leave a blank pane no tab switch reloaded.
     @Test("A table tab whose failed load was dismissed still draws its grid")
     func dismissedTableFailureKeepsGrid() {
         var inputs = QueryResultInputs()
@@ -90,8 +86,7 @@ struct QueryResultPresentationTests {
         #expect(QueryResultPresentation(inputs: inputs).content == .idle)
     }
 
-    /// Retargeting a tab empties its buffer before the replacing fetch starts. Reporting "no rows"
-    /// there states that the table the reader just opened is empty.
+    // Retargeting empties the buffer first; reporting no rows there says the table just opened is empty.
     @Test("A running fetch over loaded rows keeps drawing them")
     func executingOverLoadedRows() {
         var inputs = QueryResultInputs()
@@ -116,8 +111,7 @@ struct QueryResultPresentationTests {
         #expect(QueryResultPresentation(inputs: inputs).content == .noRows(executionTime: 0.25))
     }
 
-    /// A filter that matched nothing must keep the grid, because the filter chrome above it is the
-    /// only way the reader gets their rows back.
+    // The filter chrome is the only way the reader gets their rows back.
     @Test("A filter that matched nothing keeps the grid")
     func filteredToNothingKeepsGrid() {
         var inputs = QueryResultInputs()
@@ -181,8 +175,7 @@ struct QueryResultPresentationTests {
         #expect(QueryResultPresentation(inputs: inputs).content == .serverOutput(output))
     }
 
-    /// Switching to a result that printed nothing leaves the tab in Output mode until the next install reconciles
-    /// it, and the pane must not go blank in the meantime.
+    // The tab stays in Output mode until the next install reconciles it, and the pane must not go blank meanwhile.
     @Test("Output mode over a result that printed nothing shows the grid")
     func outputModeWithoutOutputFallsBackToTheGrid() {
         var inputs = QueryResultInputs()
@@ -222,16 +215,12 @@ struct QueryResultPresentationTests {
         let presentation = QueryResultPresentation(inputs: inputs)
 
         #expect(presentation.content == .queryPlan)
-        /// The bar stays. It is the only thing carrying the result chooser now, so a plan that
-        /// gave it up could not be switched away from or pinned. What a plan gives up there is the
-        /// row readout, which `ResultStatusModel` drops from `StatusBarSnapshot.isQueryPlan`.
+        // The bar carries the result chooser, so a plan keeps it; `ResultStatusModel` drops only its row readout for a plan.
         #expect(presentation.showsStatusBar)
         #expect(presentation.showsResultSetSelector)
     }
 
-    /// Pin a failure, run something that works, and the tab's own message is cleared while the
-    /// pinned result's is not. Switching back used to resolve the failure as a success, because the
-    /// error result reports no columns.
+    // Switching back used to resolve the pinned failure as a success, because the error result reports no columns.
     @Test("A pinned failure still reads as a failure after a later run succeeds")
     func pinnedFailureStaysAFailure() {
         var inputs = QueryResultInputs()
@@ -249,26 +238,6 @@ struct QueryResultPresentationTests {
         }
     }
 
-    /// The find bar searches the data grid's coordinator. Switching to a mode that unmounts the
-    /// grid left it on screen over nothing to search.
-    @Test("The find bar follows the mode, not just the tab type")
-    func findBarFollowsMode() {
-        var inputs = QueryResultInputs()
-        inputs.tabType = .table
-        inputs.isFindBarVisible = true
-
-        inputs.viewMode = .data
-        #expect(QueryResultPresentation(inputs: inputs).showsFindBar)
-
-        for mode in [ResultsViewMode.chart, .map, .structure] {
-            inputs.viewMode = mode
-            #expect(
-                QueryResultPresentation(inputs: inputs).showsFindBar == mode.showsFindBar,
-                "find bar must follow ResultsViewMode.showsFindBar for \(mode)"
-            )
-        }
-    }
-
     @Test("Structure mode needs a table to show the structure of")
     func structureNeedsATable() {
         var inputs = QueryResultInputs()
@@ -328,17 +297,6 @@ struct QueryResultPresentationTests {
         #expect(QueryResultPresentation(inputs: inputs).showsResultSetSelector == false)
     }
 
-    @Test("The find bar belongs to table tabs")
-    func findBarIsTableOnly() {
-        var inputs = QueryResultInputs()
-        inputs.isFindBarVisible = true
-        inputs.tabType = .query
-        #expect(QueryResultPresentation(inputs: inputs).showsFindBar == false)
-
-        inputs.tabType = .table
-        #expect(QueryResultPresentation(inputs: inputs).showsFindBar)
-    }
-
     @Test("Filter chrome follows the mode that can be filtered")
     func filterChromeFollowsMode() {
         var inputs = QueryResultInputs()
@@ -352,7 +310,6 @@ struct QueryResultPresentationTests {
         #expect(QueryResultPresentation(inputs: inputs).showsFilterChrome == false)
     }
 
-    /// The property the old nested `if/else` only had by accident.
     @Test("Every reachable input resolves to exactly one content case")
     func everyStateResolvesOnce() {
         var seen: Set<String> = []
diff --git a/apple/TableProTests/Models/QueryTabConnectionMoveTests.swift b/apple/TableProTests/Models/QueryTabConnectionMoveTests.swift
index 7c65331481..2b85de1b65 100644
--- a/apple/TableProTests/Models/QueryTabConnectionMoveTests.swift
+++ b/apple/TableProTests/Models/QueryTabConnectionMoveTests.swift
@@ -78,7 +78,7 @@ struct QueryTabConnectionMoveTests {
             columns: [SortColumn(columnIndex: 0, direction: .descending, columnName: "a")],
             source: .user
         )
-        tab.selectedRowIndices = [2]
+        tab.selectionSnapshot = GridSelectionSnapshot(rowIDs: [.existing(2)], rectangles: [], activeCell: nil, anchor: nil)
         tab.pendingChanges.deletedRowIDs = [.existing(0)]
 
         let moved = move(tab)
@@ -89,7 +89,7 @@ struct QueryTabConnectionMoveTests {
         #expect(!moved.sortState.isSorting)
         #expect(moved.pendingRestoredSort == nil)
         #expect(moved.restoredSortSource == .unset)
-        #expect(moved.selectedRowIndices.isEmpty)
+        #expect(moved.selectionSnapshot.isEmpty)
         #expect(!moved.pendingChanges.hasChanges)
         #expect(moved.display.resultSets.isEmpty)
     }
diff --git a/apple/TableProTests/Models/UI/JsonFieldEditingModelTests.swift b/apple/TableProTests/Models/UI/JsonFieldEditingModelTests.swift
index e1a40153ee..73baa1faa3 100644
--- a/apple/TableProTests/Models/UI/JsonFieldEditingModelTests.swift
+++ b/apple/TableProTests/Models/UI/JsonFieldEditingModelTests.swift
@@ -9,18 +9,13 @@ import Testing
 
 @testable import TablePro
 
-/// The regression suite for #3051.
-///
-/// The editor and the store are two mirrors of one value, and the hang was a fixpoint between
-/// them: one keystroke produced 6,944 body evaluations in 30 seconds at 100% CPU, and the typed
-/// character was thrown away. What catches it is ``adoptsRestatement``: the store always answers
-/// with a different string than the editor holds, and adopting that answer is the bug.
+// #3051: adopting the store's restated value looped the editor at 100% CPU (6,944 body evaluations in 30 s).
 @MainActor
 struct JsonFieldEditingModelTests {
     private static func makeState(value: String, type: ColumnType) -> MultiRowEditState {
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: [0],
+            rowIDs: [.existing(0)],
             allRows: [[value]],
             columns: ["payload"],
             columnTypes: [type]
@@ -28,17 +23,7 @@ struct JsonFieldEditingModelTests {
         return state
     }
 
-    /// Whether the editor adopts the store's restatement of what the editor itself just published.
-    ///
-    /// This is the whole of #3051 in one question. `MultiRowEditState` stages a compacted form of
-    /// the text the editor shows, so the store always answers with a *different string* than the
-    /// editor holds. Adopting that answer is what overwrote the keystroke and pushed the overwrite
-    /// back, at about 75 rounds a second.
-    ///
-    /// Asserted directly rather than by looping the pair until it settles: `displayText` and
-    /// `lastSynced` are equal at every exit of both entry points, so a loop that re-publishes
-    /// `model.displayText` can never take a second turn and would report convergence for any model
-    /// at all, including one with the bug.
+    // Asserted directly: displayText and lastSynced match at every exit, so a re-publish loop would always look converged.
     private static func adoptsRestatement(
         _ model: inout JsonFieldEditingModel,
         from state: MultiRowEditState
@@ -64,8 +49,7 @@ struct JsonFieldEditingModelTests {
         #expect(state.fields[0].pendingValue == "{\"a\":2}")
     }
 
-    /// The document is invalid for as long as the user is halfway through typing a value, which is
-    /// where `JsonReindenter`'s parse-failure fallback used to make the two sides disagree.
+    // Halfway through typing a value, where JsonReindenter's parse-failure fallback used to make the two sides disagree.
     @Test("A transiently invalid document keeps every keystroke")
     func invalidIntermediateSettles() {
         let original = "{\"a\": 1}"
@@ -82,8 +66,7 @@ struct JsonFieldEditingModelTests {
         }
     }
 
-    /// The store drops a pending value that matches the stored one again, so the binding answers
-    /// with the original. That is still this editor's own echo and must not be adopted.
+    // The store drops a pending value equal to the stored one, so the binding answers with the original: still our own echo.
     @Test("Editing back to the stored value does not bounce")
     func revertToOriginalSettles() {
         let original = "{\"a\":1}"
@@ -95,8 +78,6 @@ struct JsonFieldEditingModelTests {
 
         state.updateField(at: 0, value: model.typed(JsonReindenter.reindent(original)))
         #expect(!state.fields[0].hasEdit)
-        /// The store dropped the pending value, so it now answers with `originalValue`. That is
-        /// still this editor's own write coming back and must not be adopted.
         let adopted = Self.adoptsRestatement(&model, from: state)
         #expect(!adopted)
     }
@@ -118,14 +99,12 @@ struct JsonFieldEditingModelTests {
         let adopted = model.received("{\"b\":2}")
         #expect(adopted)
         #expect(model.displayText == JsonReindenter.reindent("{\"b\":2}"))
-        /// The adopted value arrived compact and is displayed laid out, so the two differ by more
-        /// than nothing. Republishing it would stage an edit the user never made.
+        // Arrived compact and displays laid out; republishing it would stage an edit the user never made.
         let republished = model.typed(model.displayText)
         #expect(republished == nil, "adopting is not an edit")
     }
 
-    /// Set NULL, Set DEFAULT and Set EMPTY all empty the field's editable text. Adopting that and
-    /// then publishing it again would clear the state the user just asked for.
+    // Set NULL, DEFAULT and EMPTY all empty the text; publishing that back would clear the state the user asked for.
     @Test("An emptied field is adopted once and not published back")
     func emptiedFieldIsNotRepublished() {
         var model = JsonFieldEditingModel(storedValue: "{\"a\":1}")
diff --git a/apple/TableProTests/Models/UI/MultiRowEditStateDetachedCommitTests.swift b/apple/TableProTests/Models/UI/MultiRowEditStateDetachedCommitTests.swift
index 065cc9b87a..c25b6739df 100644
--- a/apple/TableProTests/Models/UI/MultiRowEditStateDetachedCommitTests.swift
+++ b/apple/TableProTests/Models/UI/MultiRowEditStateDetachedCommitTests.swift
@@ -14,7 +14,6 @@ struct MultiRowEditStateDetachedCommitTests {
     private func makeState(rowIDs: [RowID], values: [[String?]]) -> MultiRowEditState {
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: Set(rowIDs.indices),
             rowIDs: rowIDs,
             allRows: values,
             columns: ["id", "name"],
@@ -38,8 +37,7 @@ struct MultiRowEditStateDetachedCommitTests {
         #expect(state.fields[1].pendingValue == "Zed")
     }
 
-    /// The field's id is reissued on every selection change, so the lookup this replaced failed and
-    /// dropped the text with no warning.
+    // The field's id is reissued on every selection change, so a lookup by id dropped the text silently.
     @Test("a commit after the selection moved writes the rows the window was opened for")
     func commitsToTheOpenedRowsAfterTheSelectionMoved() {
         let state = makeState(rowIDs: [.existing(1)], values: [["2", "Bob"]])
@@ -48,7 +46,6 @@ struct MultiRowEditStateDetachedCommitTests {
         state.onDetachedFieldChanged = { columnIndex, value, rowIDs, _ in detached.append((columnIndex, value, rowIDs)) }
 
         state.configure(
-            selectedRowIndices: [0],
             rowIDs: [.existing(2)],
             allRows: [["3", "Carol"]],
             columns: ["id", "name"],
diff --git a/apple/TableProTests/Models/UI/MultiRowEditStateJsonTests.swift b/apple/TableProTests/Models/UI/MultiRowEditStateJsonTests.swift
index 185f0d1143..fd2de9f139 100644
--- a/apple/TableProTests/Models/UI/MultiRowEditStateJsonTests.swift
+++ b/apple/TableProTests/Models/UI/MultiRowEditStateJsonTests.swift
@@ -14,7 +14,7 @@ struct MultiRowEditStateJsonTests {
     private func makeState(value: String, type: ColumnType, column: String = "data") -> MultiRowEditState {
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: [0],
+            rowIDs: [.existing(0)],
             allRows: [[value]],
             columns: [column],
             columnTypes: [type]
diff --git a/apple/TableProTests/Theme/DerivedSlotDrawingTests.swift b/apple/TableProTests/Theme/DerivedSlotDrawingTests.swift
index 12ea1fd2e0..a1e0943574 100644
--- a/apple/TableProTests/Theme/DerivedSlotDrawingTests.swift
+++ b/apple/TableProTests/Theme/DerivedSlotDrawingTests.swift
@@ -1,12 +1,3 @@
-//
-//  DerivedSlotDrawingTests.swift
-//  TableProTests
-//
-//  A theme that sets only the grid background used to stripe its odd rows in the system's opaque
-//  light stripe and keep a white header over its own color. The stripe and header now come from the
-//  theme's background, and the selection text from the theme's own selection and text.
-//
-
 import AppKit
 @testable import TablePro
 import TableProTheme
@@ -14,55 +5,36 @@ import Testing
 
 @MainActor
 struct DerivedSlotDrawingTests {
-    private func stripedTable() -> NSTableView {
+    private func recordsTable() -> (NSTableView, NSScrollView) {
         let tableView = NSTableView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
         tableView.usesAlternatingRowBackgroundColors = true
-        return tableView
+        let scrollView = NSScrollView(frame: tableView.frame)
+        scrollView.documentView = tableView
+        return (tableView, scrollView)
     }
 
-    // MARK: - Grid stripes and header
+    // MARK: - Stripes
 
-    @Test("A background-only light theme stripes and heads the grid from its own background")
-    func backgroundOnlyLightGrid() throws {
+    @Test("A light background-only theme stripes a records table from its own background")
+    func recordsTableStripes() throws {
         try ThemeTestFixture.adopting([.gridBackground: "#FDF6E3"], appearance: .light) {
-            let tableView = stripedTable()
+            let (tableView, scrollView) = recordsTable()
+            let chrome = ThemeTableChrome(tableView: tableView, family: .records)
 
-            #expect(ThemeTestFixture.hex(DataGridBodyChrome.stripeColor(forRow: 0, of: tableView, scope: .live)) == "#FDF6E3")
-            #expect(ThemeTestFixture.hex(DataGridBodyChrome.stripeColor(forRow: 1, of: tableView, scope: .live)) == "#F3ECDA")
-            #expect(ThemeTestFixture.hex(SortableHeaderChrome.backgroundColor(scope: .live)) == "#FDF6E3")
+            #expect(ThemeTestFixture.hex(chrome.rowBackgroundColor(forRow: 1)) == "#F3ECDA")
+            #expect(ThemeTestFixture.hex(chrome.rowBackgroundColor(forRow: 2)) == "#FDF6E3")
+            withExtendedLifetime(scrollView) {}
         }
     }
 
-    @Test("A background-only dark theme stripes toward white")
-    func backgroundOnlyDarkGrid() throws {
+    @Test("A dark background-only theme stripes a records table toward white")
+    func recordsTableStripesTowardWhite() throws {
         try ThemeTestFixture.adopting([.gridBackground: "#282A36"], appearance: .dark) {
-            let tableView = stripedTable()
-
-            #expect(ThemeTestFixture.hex(DataGridBodyChrome.stripeColor(forRow: 1, of: tableView, scope: .live), in: .darkAqua) == "#31333E")
-            #expect(ThemeTestFixture.hex(SortableHeaderChrome.backgroundColor(scope: .live), in: .darkAqua) == "#282A36")
-        }
-    }
-
-    @Test("Under the default pair the stripe and the header stay the system's own objects")
-    func defaultStripeAndHeaderAreNative() throws {
-        try ThemeTestFixture.adopting(.builtIn, appearance: .light) {
-            let tableView = stripedTable()
-
-            #expect(DataGridBodyChrome.stripeColor(forRow: 1, of: tableView, scope: .live) === NativeThemeColors.alternateRow)
-            #expect(SortableHeaderChrome.backgroundColor(scope: .live) === NSColor.controlBackgroundColor)
-        }
-    }
-
-    @Test("A records table stripes a background-only theme from its own background too")
-    func recordsTableStripes() throws {
-        try ThemeTestFixture.adopting([.gridBackground: "#FDF6E3"], appearance: .light) {
-            let tableView = stripedTable()
-            let scrollView = NSScrollView(frame: tableView.frame)
-            scrollView.documentView = tableView
+            let (tableView, scrollView) = recordsTable()
             let chrome = ThemeTableChrome(tableView: tableView, family: .records)
 
-            #expect(ThemeTestFixture.hex(chrome.rowBackgroundColor(forRow: 1)) == "#F3ECDA")
-            #expect(ThemeTestFixture.hex(chrome.rowBackgroundColor(forRow: 2)) == "#FDF6E3")
+            #expect(ThemeTestFixture.hex(chrome.rowBackgroundColor(forRow: 1), in: .darkAqua) == "#31333E")
+            withExtendedLifetime(scrollView) {}
         }
     }
 
@@ -73,30 +45,6 @@ struct DerivedSlotDrawingTests {
         return ThemeScope.live.dataGridCellPalette(in: aqua)
     }
 
-    @Test("Over a themed selection the cell text takes the theme's grid text when it has no selection text")
-    func selectionTextFollowsThemedText() throws {
-        try ThemeTestFixture.adopting([.gridSelection: "#44475A", .gridText: "#F8F8F2"], appearance: .light) {
-            let palette = try cellPalette()
-            #expect(ThemeTestFixture.hex(palette.selectionText) == "#F8F8F2")
-        }
-    }
-
-    @Test("Over a themed selection with native text the cell text is the native label color")
-    func selectionTextFollowsNativeText() throws {
-        try ThemeTestFixture.adopting([.gridSelection: "#44475A"], appearance: .light) {
-            let palette = try cellPalette()
-            #expect(palette.selectionText === NSColor.labelColor)
-        }
-    }
-
-    @Test("A selection text with no themed selection leaves AppKit's white selection text")
-    func selectionTextWithoutASelectionIsNative() throws {
-        try ThemeTestFixture.adopting([.gridSelectionText: "#00FF00", .gridText: "#112233"], appearance: .light) {
-            let palette = try cellPalette()
-            #expect(palette.selectionText === NSColor.alternateSelectedControlTextColor)
-        }
-    }
-
     @Test("Bools follow the theme's grid text")
     func boolsFollowThemedText() throws {
         try ThemeTestFixture.adopting([.gridText: "#112233"], appearance: .light) {
diff --git a/apple/TableProTests/Theme/NativeDefaultsTests.swift b/apple/TableProTests/Theme/NativeDefaultsTests.swift
index 0b7e578f8c..36e88dd397 100644
--- a/apple/TableProTests/Theme/NativeDefaultsTests.swift
+++ b/apple/TableProTests/Theme/NativeDefaultsTests.swift
@@ -1,12 +1,5 @@
-//
-//  NativeDefaultsTests.swift
-//  TableProTests
-//
-//  Default Light and Default Dark have to render exactly like an unthemed NSTextView and
-//  NSTableView, following Accent, Highlight and Increase Contrast. That holds only while every
-//  slot they leave out hands back the system color object itself: a hex default, or a copy
-//  flattened under a hand-built appearance, freezes it.
-//
+// A hex default, or a copy flattened under a hand-built appearance, freezes a system color, so the
+// defaults have to hand back the system color object itself.
 
 import AppKit
 import Foundation
@@ -60,14 +53,10 @@ struct NativeDefaultsTests {
             #expect(theme.color(for: .editorSelection) === NSColor.selectedTextBackgroundColor)
             #expect(theme.color(for: .gridBackground) === NSColor.controlBackgroundColor)
             #expect(theme.color(for: .gridLine) === NSColor.separatorColor)
-            #expect(theme.color(for: .gridHeaderText) === NSColor.headerTextColor)
-            #expect(theme.color(for: .gridSelection) === NSColor.selectedContentBackgroundColor)
-            #expect(theme.color(for: .gridInactiveSelection) === NSColor.unemphasizedSelectedContentBackgroundColor)
-            #expect(theme.color(for: .gridFocusBorder) === NSColor.keyboardFocusIndicatorColor)
+            #expect(theme.color(for: .gridText) === NSColor.labelColor)
         }
     }
 
-    /// macOS 14 draws the caret in the Highlight color, not in the text color.
     @Test("The default caret is the system insertion point color")
     func caretIsTheSystemInsertionPoint() {
         guard #available(macOS 14.0, *) else { return }
@@ -96,11 +85,10 @@ struct NativeDefaultsTests {
         #expect(Self.hex(theme.color(for: .editorBackground)) == "#282A36")
         #expect(theme.color(for: .editorSelection) === NSColor.selectedTextBackgroundColor)
         #expect(theme.color(for: .editorCursor) === ThemeSlot.editorCursor.nativeColor)
-        #expect(theme.color(for: .gridSelection) === NSColor.selectedContentBackgroundColor)
+        #expect(theme.color(for: .gridLine) === NSColor.separatorColor)
         #expect(theme.color(for: .gridBackground) === NSColor.controlBackgroundColor)
     }
 
-    /// Syntax has no system color, so a theme that leaves one out takes its own appearance's default.
     @Test("A syntax slot a theme leaves out takes the same-appearance default")
     func missingSyntaxTakesTheSameAppearanceDefault() throws {
         let dark = try Self.theme(.dark, overriding: [.editorBackground: "#282A36"])
@@ -126,8 +114,8 @@ struct NativeDefaultsTests {
         let partial = ResolvedTheme(definition: try Self.theme(.dark, overriding: [.gridBackground: "#282A36"]))
         #expect(partial.isOverridden(.gridBackground))
         #expect(Self.hex(partial[.gridBackground]) == "#282A36")
-        #expect(!partial.isOverridden(.gridSelection))
-        #expect(partial[.gridSelection] === NSColor.selectedContentBackgroundColor)
+        #expect(!partial.isOverridden(.gridLine))
+        #expect(partial[.gridLine] === NSColor.separatorColor)
     }
 
     @Test("cgColor resolves a system slot inside the appearance it is given")
@@ -199,7 +187,7 @@ struct NativeDefaultsTests {
         }
         aqua.performAsCurrentDrawingAppearance {
             #expect(Self.hex(palette[.editorBackground]) == Self.hex(NSColor.textBackgroundColor))
-            #expect(Self.hex(palette[.gridSelection]) == Self.hex(NSColor.selectedContentBackgroundColor))
+            #expect(Self.hex(palette[.gridBackground]) == Self.hex(NSColor.controlBackgroundColor))
         }
     }
 
@@ -229,7 +217,7 @@ struct NativeDefaultsTests {
 
     // MARK: - Fallback colors
 
-    /// The fallback is not the slot's own native color, so a match proves the fallback is what draws.
+    // The fallback is not the slot's own native color, so a match proves the fallback is what draws.
     @Test("Under the default pair the palette fallback draws the fallback in every appearance")
     func paletteFallbackUnderTheDefaultPair() throws {
         let palette = ThemePalette(revision: 910_004, source: ThemeSource())
@@ -264,8 +252,7 @@ struct NativeDefaultsTests {
         }
     }
 
-    /// `NSAppearance(named:)` hands back plain Dark Aqua for the high-contrast names; only the system
-    /// setting produces one, so the rule is held here rather than through a drawing appearance.
+    // `NSAppearance(named:)` hands back plain Dark Aqua for the high-contrast names.
     @Test("Under Increase Contrast the window background yields to the system and content slots keep the theme")
     func windowBackgroundYieldsToIncreasedContrast() throws {
         let dracula = try Self.bundledTheme("tablepro.dracula")
diff --git a/apple/TableProTests/Theme/ThemeScopeTests.swift b/apple/TableProTests/Theme/ThemeScopeTests.swift
index c4bda84df1..ee7ebc6582 100644
--- a/apple/TableProTests/Theme/ThemeScopeTests.swift
+++ b/apple/TableProTests/Theme/ThemeScopeTests.swift
@@ -1,10 +1,4 @@
-//
-//  ThemeScopeTests.swift
-//  TableProTests
-//
-//  A fixed scope is how the theme editor renders a draft through the real carriers. It has to draw
-//  the draft whatever the engine holds, and leave the engine exactly as it was.
-//
+// The theme editor renders a draft through a fixed scope: it draws the draft and leaves the engine alone.
 
 import AppKit
 import Combine
@@ -20,7 +14,7 @@ struct ThemeScopeTests {
         let tableView: NSTableView
     }
 
-    /// Never ordered front and never closed: `close()` on a test window over-releases it.
+    // Never ordered front and never closed: `close()` on a test window over-releases it.
     private func makeTable() -> Table {
         let tableView = NSTableView(frame: NSRect(x: 0, y: 0, width: 240, height: 120))
         tableView.headerView = nil
@@ -50,7 +44,7 @@ struct ThemeScopeTests {
             appearance: .dark,
             overrides: [
                 .gridBackground: try ThemeColor(validating: "#282A36"),
-                .gridSelection: try ThemeColor(validating: "#44475A"),
+                .editorSelection: try ThemeColor(validating: "#44475A"),
                 .editorBackground: try ThemeColor(validating: "#1B3A2C"),
                 .editorText: try ThemeColor(validating: "#F8F8F2"),
             ]
@@ -73,7 +67,7 @@ struct ThemeScopeTests {
             #expect(ThemeTestFixture.hex(table.tableView.backgroundColor, in: .aqua) == "#282A36")
             #expect(ThemeTestFixture.hex(table.tableView.backgroundColor, in: .darkAqua) == "#282A36")
             #expect(ThemeTestFixture.hex(chrome.rowBackgroundColor(forRow: 1), in: .aqua) == "#31333E")
-            #expect(ThemeTestFixture.hex(chrome.selectionColor(emphasized: true)) == "#44475A")
+            #expect(chrome.selectionColor(emphasized: true) == nil)
             #expect(!table.scrollView.drawsBackground)
             #expect(engine.pair == pairBefore)
             #expect(engine.revision == revisionBefore)
@@ -96,6 +90,18 @@ struct ThemeScopeTests {
         }
     }
 
+    @Test("A fixed scope drives a code table's selection from its definition")
+    func fixedScopeDrivesACodeTableSelection() throws {
+        try ThemeTestFixture.adopting(.builtIn, appearance: .light) {
+            let table = makeTable()
+            let chrome = ThemeTableChrome(tableView: table.tableView, family: .code, scope: .fixed(try Self.draft()))
+
+            #expect(ThemeTestFixture.hex(chrome.selectionColor(emphasized: true)) == "#44475A")
+            #expect(ThemeTestFixture.hex(table.tableView.backgroundColor, in: .aqua) == "#1B3A2C")
+            withExtendedLifetime(chrome) {}
+        }
+    }
+
     @Test("A fixed scope drives a text view's colors")
     func fixedScopeDrivesATextView() throws {
         try ThemeTestFixture.adopting(.builtIn, appearance: .light) {
diff --git a/apple/TableProTests/Theme/ThemeTableChromeTests.swift b/apple/TableProTests/Theme/ThemeTableChromeTests.swift
index 3e0fb340ec..8ad61d9af2 100644
--- a/apple/TableProTests/Theme/ThemeTableChromeTests.swift
+++ b/apple/TableProTests/Theme/ThemeTableChromeTests.swift
@@ -1,13 +1,3 @@
-//
-//  ThemeTableChromeTests.swift
-//  TableProTests
-//
-//  A content table under a default theme has to stay AppKit's own: its background, stripes, grid
-//  color, scroll view material, row view class and selection. Under a theme it takes the theme's
-//  colors, its selection keeps the shape the table style gives it, and its records cells take the
-//  theme's text.
-//
-
 import AppKit
 import SwiftUI
 @testable import TablePro
@@ -16,11 +6,8 @@ import Testing
 
 @MainActor
 private final class ChromeTableSource: NSObject, NSTableViewDataSource, NSTableViewDelegate {
-    static let cellIdentifier = NSUserInterfaceItemIdentifier("value")
-
     weak var chrome: ThemeTableChrome?
     var rowCount = 3
-    var vendsCells = false
 
     func numberOfRows(in tableView: NSTableView) -> Int { rowCount }
 
@@ -28,13 +15,10 @@ private final class ChromeTableSource: NSObject, NSTableViewDataSource, NSTableV
         chrome?.makeRowView(in: tableView)
     }
 
-    func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
-        guard vendsCells else { return nil }
-        return ThemeTableChrome.HostingCell.make(Self.cellIdentifier, in: tableView, showing: Text("Row \(row)"))
-    }
+    func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? { nil }
 }
 
-/// The table every content table was before the theme reached it: no row view delegate at all.
+// No row view delegate at all, as every content table was before the theme reached it.
 @MainActor
 private final class StockTableSource: NSObject, NSTableViewDataSource, NSTableViewDelegate {
     func numberOfRows(in tableView: NSTableView) -> Int { 3 }
@@ -42,9 +26,7 @@ private final class StockTableSource: NSObject, NSTableViewDataSource, NSTableVi
     func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? { nil }
 }
 
-/// The themed row recolors what `drawSelection(in:)` draws, so the selection's shape is held to that
-/// method's own output. A row without the override draws through its layer, which a bitmap cache
-/// captures at full width.
+// A row without a `drawSelection(in:)` override draws through its layer, which a bitmap cache captures at full width.
 @MainActor
 private final class DrawPathTableRowView: NSTableRowView {
     // swiftlint:disable:next unneeded_override
@@ -62,8 +44,7 @@ private final class DrawPathTableSource: NSObject, NSTableViewDataSource, NSTabl
     func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? { nil }
 }
 
-/// A bitmap cache converts through its own color space, so a theme color is held to the same color
-/// drawn by a plain fill into the same kind of cache.
+// A bitmap cache converts through its own color space, so a theme color is held to a plain fill in the same cache.
 @MainActor
 private final class FillView: NSView {
     let color: NSColor
@@ -82,8 +63,7 @@ private final class FillView: NSView {
     }
 }
 
-/// Each test adopts a pair on the shared `ThemeEngine` and restores it in a `defer`. The bodies are
-/// synchronous and `@MainActor`, so nothing else on the main actor runs between the two.
+// Each body is synchronous and `@MainActor`, so nothing else runs under the pair it adopts on the shared engine.
 @MainActor
 struct ThemeTableChromeTests {
     private struct Table {
@@ -97,7 +77,7 @@ struct ThemeTableChromeTests {
 
     private static let rowFrame = NSRect(x: 0, y: 0, width: 160, height: 24)
 
-    /// Never ordered front and never closed: `close()` on a test window over-releases it.
+    // Never ordered front and never closed: `close()` on a test window over-releases it.
     private func makeTable(
         style: NSTableView.Style = .inset,
         alternates: Bool = true,
@@ -204,7 +184,7 @@ struct ThemeTableChromeTests {
         }
     }
 
-    @Test("A records table takes the grid's background, stripes and grid line, and gets its own back")
+    @Test("A records table takes the grid's background, stripes and grid line, keeps AppKit's selection, and gets its own back")
     func recordsFamilyThemesAndRestores() throws {
         try ThemeTestFixture.preservingEngine {
             try ThemeTestFixture.adopt([:], appearance: .light)
@@ -218,8 +198,7 @@ struct ThemeTableChromeTests {
                 .gridBackground: "#FAFAFA",
                 .gridAlternateRow: "#F0F0F0",
                 .gridLine: "#DDDDDD",
-                .gridSelection: "#C8E1FF",
-                .gridInactiveSelection: "#E0E0E0",
+                .editorSelection: "#C8E1FF",
             ], appearance: .light)
             #expect(try hex(table.tableView.backgroundColor) == "#FAFAFA")
             #expect(try hex(table.tableView.gridColor) == "#DDDDDD")
@@ -227,8 +206,8 @@ struct ThemeTableChromeTests {
             #expect(!table.scrollView.drawsBackground)
             #expect(try hex(chrome.rowBackgroundColor(forRow: 0)) == "#FAFAFA")
             #expect(try hex(chrome.rowBackgroundColor(forRow: 1)) == "#F0F0F0")
-            #expect(try hex(chrome.selectionColor(emphasized: true)) == "#C8E1FF")
-            #expect(try hex(chrome.selectionColor(emphasized: false)) == "#E0E0E0")
+            #expect(chrome.selectionColor(emphasized: true) == nil)
+            #expect(chrome.selectionColor(emphasized: false) == nil)
 
             try ThemeTestFixture.adopt([:], appearance: .light)
             #expect(table.tableView.backgroundColor == background)
@@ -298,7 +277,7 @@ struct ThemeTableChromeTests {
         }
     }
 
-    @Test("A theme that draws the rows swaps in the themed row class, and a default theme swaps AppKit's back")
+    @Test("A theme that colors the rows swaps in the themed row class, and a default theme swaps AppKit's back")
     func rowClassFollowsTheTheme() throws {
         try ThemeTestFixture.preservingEngine {
             try ThemeTestFixture.adopt([:], appearance: .light)
@@ -313,7 +292,7 @@ struct ThemeTableChromeTests {
             #expect(origin.y > 0)
             #expect(type(of: try #require(table.tableView.rowView(atRow: 12, makeIfNecessary: true))) == NSTableRowView.self)
 
-            for overrides in [[ThemeSlot.gridSelection: "#C8E1FF"], [.gridInactiveSelection: "#E0E0E0"], [.gridBackground: "#FAFAFA"]] {
+            for overrides in [[ThemeSlot.gridBackground: "#FAFAFA"], [.gridAlternateRow: "#F0F0F0"]] {
                 try ThemeTestFixture.adopt(overrides, appearance: .light)
                 #expect(chrome.themesRows)
                 let themedRow = try #require(table.tableView.rowView(atRow: 12, makeIfNecessary: true) as? ThemeTableRowView)
@@ -330,25 +309,25 @@ struct ThemeTableChromeTests {
         }
     }
 
-    @Test("A theme that only colors the grid text or lines keeps AppKit's row view")
+    @Test("A theme that only colors the grid text, lines or the editor's selection keeps AppKit's row view in a records table")
     func textOnlyThemeKeepsNativeRows() throws {
         try ThemeTestFixture.preservingEngine {
             try ThemeTestFixture.adopt([:], appearance: .light)
             let table = makeTable()
             let chrome = attach(.records, to: table)
 
-            try ThemeTestFixture.adopt([.gridText: "#112233", .gridLine: "#DDDDDD", .gridSelectionText: "#FFFFFF"], appearance: .light)
+            try ThemeTestFixture.adopt([.gridText: "#112233", .gridLine: "#DDDDDD", .editorSelection: "#FF00FF"], appearance: .light)
             #expect(!chrome.themesRows)
             #expect(type(of: try #require(table.tableView.rowView(atRow: 0, makeIfNecessary: true))) == NSTableRowView.self)
         }
     }
 
-    @Test("A theme's selection fills the row and keeps the row's text unflipped")
+    @Test("A theme's selection fills a code table's row and keeps the row's text unflipped")
     func themedSelectionDraws() throws {
         try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt([.gridSelection: "#FF00FF"], appearance: .light)
+            try ThemeTestFixture.adopt([.editorSelection: "#FF00FF"], appearance: .light)
             let table = makeTable()
-            let chrome = attach(.records, to: table)
+            let chrome = attach(.code, to: table)
             let row = ThemeTableRowView(frame: Self.rowFrame)
             row.chrome = chrome
 
@@ -361,8 +340,6 @@ struct ThemeTableChromeTests {
         }
     }
 
-    /// The theme recolors AppKit's selection rather than replacing it, so an inset table's rounded,
-    /// inset selection covers the same pixels with either color.
     @Test("A themed selection covers the same pixels as AppKit's in an inset table")
     func themedSelectionKeepsTheInsetShape() throws {
         try ThemeTestFixture.preservingEngine {
@@ -373,9 +350,9 @@ struct ThemeTableChromeTests {
             let native = try selectedRowPixels(in: nativeTable)
             let accent = try color(in: native, x: native.pixelsWide / 2, y: native.pixelsHigh / 2)
 
-            try ThemeTestFixture.adopt([.gridSelection: "#FF00FF"], appearance: .light)
+            try ThemeTestFixture.adopt([.editorSelection: "#FF00FF"], appearance: .light)
             let themedTable = makeTable(style: .inset, alternates: false)
-            let themedChrome = attach(.records, to: themedTable)
+            let themedChrome = attach(.code, to: themedTable)
             let themed = try selectedRowPixels(in: themedTable)
             withExtendedLifetime(themedChrome) {}
             let magenta = try color(in: themed, x: themed.pixelsWide / 2, y: themed.pixelsHigh / 2)
@@ -397,6 +374,31 @@ struct ThemeTableChromeTests {
         }
     }
 
+    @Test("Under a theme a records table's selection is still AppKit's, and its text still flips")
+    func recordsSelectionStaysNative() throws {
+        try ThemeTestFixture.preservingEngine {
+            try ThemeTestFixture.adopt([:], appearance: .light)
+            let nativeTable = makeTable(style: .inset, alternates: false, source: DrawPathTableSource())
+            nativeTable.tableView.reloadData()
+            nativeTable.tableView.layoutSubtreeIfNeeded()
+            let native = try selectedRowPixels(in: nativeTable)
+
+            try ThemeTestFixture.adopt([.gridBackground: "#FAFAFA", .gridText: "#112233", .editorSelection: "#FF00FF"], appearance: .light)
+            let themedTable = makeTable(style: .inset, alternates: false)
+            let chrome = attach(.records, to: themedTable)
+            defer { withExtendedLifetime(chrome) {} }
+            let themed = try selectedRowPixels(in: themedTable)
+            let row = try #require(themedTable.tableView.rowView(atRow: 0, makeIfNecessary: true) as? ThemeTableRowView)
+
+            #expect(chrome.selectionColor(emphasized: true) == nil)
+            #expect(chrome.selectionColor(emphasized: false) == nil)
+            let x = native.pixelsWide / 2
+            let y = native.pixelsHigh / 2
+            #expect(matches(try color(in: themed, x: x, y: y), try color(in: native, x: x, y: y)))
+            #expect(row.interiorBackgroundStyle == .emphasized)
+        }
+    }
+
     private func selectedRowPixels(in table: Table) throws -> NSBitmapImageRep {
         table.tableView.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
         let row = try #require(table.tableView.rowView(atRow: 0, makeIfNecessary: true))
@@ -409,7 +411,7 @@ struct ThemeTableChromeTests {
 
     private static let swatchID = NSUserInterfaceItemIdentifier("swatch")
 
-    /// A shape fills with the foreground style, so its pixels are the text color without glyph edges.
+    // A shape fills with the foreground style, so its pixels are the text color without glyph edges.
     private func swatchCell(in table: Table) -> ThemeTableChrome.HostingCell {
         ThemeTableChrome.HostingCell.make(Self.swatchID, in: table.tableView, showing: Rectangle().frame(width: 8, height: 8))
     }
@@ -426,22 +428,15 @@ struct ThemeTableChromeTests {
         Rectangle().frame(width: 8, height: 8)
     }
 
-    @Test("Text slots resolve: grid text by default, selection text on a theme's selection, none on AppKit's")
+    @Test("Text slots resolve: grid text by default, none on AppKit's emphasized selection")
     func recordsTextSlotFollowsTheRow() throws {
         try ThemeTestFixture.preservingEngine {
             try ThemeTestFixture.adopt([:], appearance: .light)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: false, onEmphasizedSelection: false, highContrast: false) == nil)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: true, onEmphasizedSelection: false, highContrast: false) == nil)
+            #expect(ThemeTableChrome.recordsTextSlot(onEmphasizedSelection: false, highContrast: false) == nil)
 
             try ThemeTestFixture.adopt([.gridText: "#FF0000"], appearance: .light)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: false, onEmphasizedSelection: false, highContrast: false) == .gridText)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: true, onEmphasizedSelection: false, highContrast: false) == .gridText)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: false, onEmphasizedSelection: true, highContrast: false) == nil)
-
-            try ThemeTestFixture.adopt([.gridText: "#FF0000", .gridSelection: "#C8E1FF", .gridSelectionText: "#00AA00"], appearance: .light)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: true, onEmphasizedSelection: false, highContrast: false) == .gridSelectionText)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: false, onEmphasizedSelection: false, highContrast: false) == .gridText)
-            #expect(ThemeTableChrome.recordsTextSlot(onThemedSelection: false, onEmphasizedSelection: true, highContrast: false) == nil)
+            #expect(ThemeTableChrome.recordsTextSlot(onEmphasizedSelection: false, highContrast: false) == .gridText)
+            #expect(ThemeTableChrome.recordsTextSlot(onEmphasizedSelection: true, highContrast: false) == nil)
         }
     }
 
@@ -451,30 +446,17 @@ struct ThemeTableChromeTests {
             try ThemeTestFixture.adopt([:], appearance: .light)
             let cell = swatchCell(in: makeTable())
             #expect(matches(try center(cell.rootView), try center(plainSwatch)))
-
-            cell.isOnThemedSelection = true
-            #expect(matches(try center(cell.rootView), try center(plainSwatch)))
         }
     }
 
-    @Test("A records cell takes the theme's grid text, and its selection text on the theme's selection")
+    @Test("A records cell takes the theme's grid text")
     func cellTextFollowsTheTheme() throws {
         guard #available(macOS 14, *) else { return }
         try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt(ThemeTestFixture.pair([.gridText: "#FF0000", .gridSelection: "#C8E1FF", .gridSelectionText: "#00AA00"]), appearance: .light)
+            try ThemeTestFixture.adopt(ThemeTestFixture.pair([.gridText: "#FF0000"]), appearance: .light)
             let cell = swatchCell(in: makeTable())
-            let red = try reference("#FF0000")
-            let green = try reference("#00AA00")
-
-            let unselected = try center(cell.rootView)
-            #expect(matches(unselected, red), "drew \(unselected)")
-
-            cell.isOnThemedSelection = true
-            let selected = try center(cell.rootView)
-            #expect(matches(selected, green), "drew \(selected)")
-
-            cell.isOnThemedSelection = false
-            #expect(matches(try center(cell.rootView), red))
+            let drawn = try center(cell.rootView)
+            #expect(matches(drawn, try reference("#FF0000")), "drew \(drawn)")
         }
     }
 
@@ -494,23 +476,12 @@ struct ThemeTableChromeTests {
         }
     }
 
-    @Test("Without a selection text a theme's selection keeps the grid text")
-    func themedSelectionWithoutSelectionTextKeepsGridText() throws {
-        guard #available(macOS 14, *) else { return }
-        try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt(ThemeTestFixture.pair([.gridText: "#FF0000", .gridSelection: "#C8E1FF"]), appearance: .light)
-            let cell = swatchCell(in: makeTable())
-            cell.isOnThemedSelection = true
-            #expect(matches(try center(cell.rootView), try reference("#FF0000")))
-        }
-    }
-
-    /// AppKit's emphasized selection is the accent color, which a theme's text is not chosen to sit on.
+    // AppKit's emphasized selection is the accent color, which a theme's text is not chosen to sit on.
     @Test("On AppKit's emphasized selection a records cell keeps its own text, which flips with the row")
     func nativeEmphasizedSelectionKeepsTheFlip() throws {
         guard #available(macOS 14, *) else { return }
         try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt(ThemeTestFixture.pair([.gridText: "#FF0000", .gridSelectionText: "#00AA00"]), appearance: .light)
+            try ThemeTestFixture.adopt(ThemeTestFixture.pair([.gridText: "#FF0000"]), appearance: .light)
             let cell = swatchCell(in: makeTable())
 
             let flipped = try center(cell.rootView.environment(\.backgroundProminence, .increased))
@@ -519,78 +490,4 @@ struct ThemeTableChromeTests {
             #expect(!matches(flipped, try reference("#FF0000")))
         }
     }
-
-    @Test("A themed row tells its records cells when they sit on the theme's selection")
-    func themedRowPublishesItsSelection() throws {
-        try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt([.gridSelection: "#C8E1FF"], appearance: .light)
-            let source = ChromeTableSource()
-            source.vendsCells = true
-            let table = makeTable(source: source)
-            let chrome = attach(.records, to: table)
-            defer { withExtendedLifetime(chrome) {} }
-
-            table.tableView.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
-            let row = try #require(table.tableView.rowView(atRow: 0, makeIfNecessary: true) as? ThemeTableRowView)
-            row.isEmphasized = true
-            let cell = try #require(table.tableView.view(atColumn: 0, row: 0, makeIfNecessary: true) as? ThemeTableChrome.HostingCell)
-            let other = try #require(table.tableView.view(atColumn: 0, row: 1, makeIfNecessary: true) as? ThemeTableChrome.HostingCell)
-            #expect(cell.isOnThemedSelection)
-            #expect(!other.isOnThemedSelection)
-
-            row.isEmphasized = false
-            #expect(!cell.isOnThemedSelection)
-
-            row.isEmphasized = true
-            table.tableView.deselectAll(nil)
-            #expect(!cell.isOnThemedSelection)
-        }
-    }
-
-    @Test("A records cell reused into AppKit's row view after the theme stops forgets the theme's selection")
-    func reusedCellForgetsTheThemedSelection() throws {
-        try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt([.gridSelection: "#C8E1FF"], appearance: .light)
-            let source = ChromeTableSource()
-            source.vendsCells = true
-            let table = makeTable(source: source)
-            let chrome = attach(.records, to: table)
-            defer { withExtendedLifetime(chrome) {} }
-            table.tableView.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
-            let row = try #require(table.tableView.rowView(atRow: 0, makeIfNecessary: true) as? ThemeTableRowView)
-            row.isEmphasized = true
-            let themedCell = try #require(table.tableView.view(atColumn: 0, row: 0, makeIfNecessary: true) as? ThemeTableChrome.HostingCell)
-            #expect(themedCell.isOnThemedSelection)
-
-            try ThemeTestFixture.adopt([.gridText: "#FF0000", .gridSelectionText: "#00AA00"], appearance: .light)
-            let nativeRow = try #require(table.tableView.rowView(atRow: 0, makeIfNecessary: true))
-            nativeRow.isEmphasized = true
-            #expect(type(of: nativeRow) == NSTableRowView.self)
-            #expect(table.tableView.selectedRowIndexes == IndexSet(integer: 0))
-            for row in 0 ..< table.tableView.numberOfRows {
-                let cell = try #require(table.tableView.view(atColumn: 0, row: row, makeIfNecessary: true) as? ThemeTableChrome.HostingCell)
-                #expect(!cell.isOnThemedSelection)
-            }
-            #expect(!themedCell.isOnThemedSelection)
-        }
-    }
-
-    @Test("Under the default theme no records cell is told it sits on a theme's selection")
-    func defaultRowsNeverMarkCells() throws {
-        try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt([:], appearance: .light)
-            let source = ChromeTableSource()
-            source.vendsCells = true
-            let table = makeTable(source: source)
-            let chrome = attach(.records, to: table)
-            defer { withExtendedLifetime(chrome) {} }
-
-            table.tableView.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
-            let row = try #require(table.tableView.rowView(atRow: 0, makeIfNecessary: true))
-            row.isEmphasized = true
-            let cell = try #require(table.tableView.view(atColumn: 0, row: 0, makeIfNecessary: true) as? ThemeTableChrome.HostingCell)
-            #expect(type(of: row) == NSTableRowView.self)
-            #expect(!cell.isOnThemedSelection)
-        }
-    }
 }
diff --git a/apple/TableProTests/Theme/ThemeTableHeaderTests.swift b/apple/TableProTests/Theme/ThemeTableHeaderTests.swift
index 7519e7717b..3a28462b8b 100644
--- a/apple/TableProTests/Theme/ThemeTableHeaderTests.swift
+++ b/apple/TableProTests/Theme/ThemeTableHeaderTests.swift
@@ -1,12 +1,3 @@
-//
-//  ThemeTableHeaderTests.swift
-//  TableProTests
-//
-//  A records table (the query plan outline, the privilege tree) kept AppKit's header band over a
-//  themed body, while the data grid's header took the theme. Its chrome now puts a themed header in
-//  while the theme colors the grid's header, and hands the owner's own header back when it stops.
-//
-
 import AppKit
 @testable import TablePro
 import TableProTheme
@@ -19,33 +10,6 @@ private final class HeaderTableSource: NSObject, NSTableViewDataSource, NSTableV
     func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? { nil }
 }
 
-@MainActor
-private final class FillHeaderSwatch: NSView {
-    private let color: NSColor
-
-    init(color: NSColor) {
-        self.color = color
-        super.init(frame: NSRect(x: 0, y: 0, width: 4, height: 4))
-    }
-
-    @available(*, unavailable)
-    required init?(coder: NSCoder) { nil }
-
-    override func draw(_ dirtyRect: NSRect) {
-        color.setFill()
-        dirtyRect.fill()
-    }
-}
-
-private final class SortIndicatorRecordingCell: NSTableHeaderCell {
-    var drawnIndicators: [Bool] = []
-
-    override func drawSortIndicator(withFrame cellFrame: NSRect, in controlView: NSView, ascending: Bool, priority: Int) {
-        drawnIndicators.append(ascending)
-        super.drawSortIndicator(withFrame: cellFrame, in: controlView, ascending: ascending, priority: priority)
-    }
-}
-
 @MainActor
 struct ThemeTableHeaderTests {
     private struct Table {
@@ -56,6 +20,7 @@ struct ThemeTableHeaderTests {
         let source: HeaderTableSource
     }
 
+    // Never ordered front and never closed: `close()` on a test window over-releases it.
     private func makeTable() -> Table {
         let tableView = NSTableView(frame: NSRect(x: 0, y: 0, width: 320, height: 160))
         let header = NSTableHeaderView()
@@ -85,159 +50,47 @@ struct ThemeTableHeaderTests {
         return Table(window: window, tableView: tableView, header: header, corner: tableView.cornerView, source: source)
     }
 
-    private func scope(_ overrides: [ThemeSlot: String]) throws -> ThemeScope {
-        var theme = try ThemeTestFixture.theme(.light, overrides)
-        theme.id = "test.records-header.\(UUID().uuidString)"
-        return .fixed(theme)
-    }
-
-    /// The view's `draw(_:)` called straight into an sRGB bitmap, so the theme's hex reads back as
-    /// written. Row 0 of the bitmap is the top of the view.
-    private func raster(_ view: NSView) throws -> NSBitmapImageRep {
-        let space = try #require(CGColorSpace(name: CGColorSpace.sRGB))
-        let cgContext = try #require(CGContext(
-            data: nil,
-            width: Int(view.bounds.width),
-            height: Int(view.bounds.height),
-            bitsPerComponent: 8,
-            bytesPerRow: 0,
-            space: space,
-            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
-        ))
-        if view.isFlipped {
-            cgContext.translateBy(x: 0, y: view.bounds.height)
-            cgContext.scaleBy(x: 1, y: -1)
-        }
-        NSGraphicsContext.saveGraphicsState()
-        NSGraphicsContext.current = NSGraphicsContext(cgContext: cgContext, flipped: view.isFlipped)
-        view.effectiveAppearance.performAsCurrentDrawingAppearance {
-            view.draw(view.bounds)
-        }
-        NSGraphicsContext.restoreGraphicsState()
-        return NSBitmapImageRep(cgImage: try #require(cgContext.makeImage()))
-    }
-
-    private func hex(_ rep: NSBitmapImageRep, x: Int, y: Int) throws -> String {
-        ThemeColor(try #require(rep.colorAt(x: x, y: y)?.usingColorSpace(.sRGB))).hex
-    }
-
-    /// Held to the expected color as a plain fill drawn the same way, so the conversion on the way
-    /// into the bitmap cancels out.
-    private func isNear(_ drawn: String, _ expected: String) -> Bool {
-        guard let lhs = ThemeColor(hex: drawn), let color = ThemeColor(hex: expected)?.nsColor else { return false }
-        let fill = FillHeaderSwatch(color: color)
-        guard let rep = try? raster(fill), let reference = try? hex(rep, x: 1, y: 1),
-              let rhs = ThemeColor(hex: reference) else { return false }
-        return abs(Int(lhs.red) - Int(rhs.red)) <= 3
-            && abs(Int(lhs.green) - Int(rhs.green)) <= 3
-            && abs(Int(lhs.blue) - Int(rhs.blue)) <= 3
-            && abs(Int(lhs.alpha) - Int(rhs.alpha)) <= 3
-    }
-
-    @Test("Under the default theme a records table keeps the header and corner its owner installed")
+    private static let fullTheme: [ThemeSlot: String] = [
+        .gridBackground: "#21222C",
+        .gridText: "#F8F8F2",
+        .gridAlternateRow: "#282A36",
+        .gridLine: "#44475A",
+        .editorBackground: "#282A36",
+        .editorText: "#F8F8F2",
+        .editorSelection: "#44475A",
+    ]
+
+    @Test("Under the default theme a table keeps the header and corner its owner installed")
     func defaultThemeKeepsTheOwnersHeader() throws {
-        let table = makeTable()
-        let chrome = ThemeTableChrome(tableView: table.tableView, family: .records, scope: .fixed(BuiltInThemes.light))
-
-        #expect(table.tableView.headerView === table.header)
-        #expect(table.tableView.cornerView === table.corner)
-        #expect(!chrome.isHeaderThemed)
-        withExtendedLifetime(table.window) {}
-    }
-
-    @Test("A theme that colors the grid's header themes a records table's header, band and titles")
-    func themedHeaderDrawsTheTheme() throws {
-        let table = makeTable()
-        let chrome = ThemeTableChrome(
-            tableView: table.tableView,
-            family: .records,
-            scope: try scope([.gridHeaderBackground: "#21222C", .gridHeaderText: "#F8F8F2", .gridLine: "#44475A"])
-        )
-        let header = try #require(table.tableView.headerView as? ThemeTableHeaderView)
-        #expect(chrome.isHeaderThemed)
-        #expect(header.chrome === chrome)
-        #expect(header !== table.header)
-        #expect(table.tableView.cornerView is ThemeTableCornerView)
-
-        let rep = try raster(header)
-        let firstHeading = header.headerRect(ofColumn: 0)
-        let band = try hex(rep, x: Int(firstHeading.maxX) - 12, y: 3)
-        let past = try hex(rep, x: Int(header.bounds.maxX) - 4, y: 3)
-        #expect(isNear(band, "#21222C"), "the band drew \(band)")
-        #expect(isNear(past, "#21222C"), "past the last heading drew \(past)")
-
-        var titleInk = 0
-        for y in 0 ..< rep.pixelsHigh - 1 {
-            for x in Int(firstHeading.minX) ..< Int(firstHeading.midX) {
-                guard let pixel = rep.colorAt(x: x, y: y)?.usingColorSpace(.sRGB) else { continue }
-                if ThemeColor(pixel).relativeLuminance > 0.5 { titleInk += 1 }
-            }
-        }
-        #expect(titleInk > 0, "the title is not in the theme's light header text")
-        withExtendedLifetime(table.window) {}
-    }
-
-    @Test("A themed header still draws the sort indicator of the primary sort column, and only that one")
-    func themedHeaderDrawsTheSortIndicator() throws {
-        let table = makeTable()
-        let cells = table.tableView.tableColumns.map { column -> SortIndicatorRecordingCell in
-            let cell = SortIndicatorRecordingCell(textCell: column.title)
-            column.headerCell = cell
-            column.sortDescriptorPrototype = NSSortDescriptor(key: column.identifier.rawValue, ascending: true)
-            return cell
-        }
-        table.tableView.sortDescriptors = [
-            NSSortDescriptor(key: "Cost", ascending: false),
-            NSSortDescriptor(key: "Operation", ascending: true),
-        ]
-        let chrome = ThemeTableChrome(tableView: table.tableView, family: .records, scope: try scope([.gridHeaderBackground: "#21222C"]))
-        let header = try #require(table.tableView.headerView as? ThemeTableHeaderView)
-
-        _ = try raster(header)
-
-        #expect(chrome.isHeaderThemed)
-        #expect(cells[0].drawnIndicators.isEmpty)
-        #expect(cells[1].drawnIndicators == [false])
-        withExtendedLifetime(table.window) {}
-    }
-
-    @Test("A background-only theme heads a records table in that background, as the grid does")
-    func backgroundOnlyThemeHeadsTheTable() throws {
-        let table = makeTable()
-        let chrome = ThemeTableChrome(tableView: table.tableView, family: .records, scope: try scope([.gridBackground: "#FDF6E3"]))
-        let header = try #require(table.tableView.headerView as? ThemeTableHeaderView)
-
-        #expect(chrome.isHeaderThemed)
-        let past = try hex(raster(header), x: Int(header.bounds.maxX) - 4, y: 3)
-        #expect(isNear(past, "#FDF6E3"), "drew \(past)")
-        withExtendedLifetime(table.window) {}
-    }
-
-    @Test("A code table's header stays AppKit's, since the editor family has no header slots")
-    func codeTablesKeepTheirHeader() throws {
-        let table = makeTable()
-        let chrome = ThemeTableChrome(tableView: table.tableView, family: .code, scope: try scope([.gridHeaderBackground: "#21222C"]))
-
-        #expect(!chrome.isHeaderThemed)
-        #expect(table.tableView.headerView === table.header)
-        withExtendedLifetime(table.window) {}
-    }
-
-    @Test("When the theme stops coloring the header the owner's header and corner come back")
-    func themeStopRestoresTheOwnersHeader() throws {
-        try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt([.gridHeaderBackground: "#21222C"], appearance: .light)
+        for family in [ThemeTableChrome.Family.records, .code] {
             let table = makeTable()
-            let chrome = ThemeTableChrome(tableView: table.tableView, family: .records)
-            #expect(table.tableView.headerView is ThemeTableHeaderView)
+            let chrome = ThemeTableChrome(tableView: table.tableView, family: family, scope: .fixed(BuiltInThemes.light))
 
-            ThemeTestFixture.adopt(.builtIn, appearance: .light)
-            chrome.apply()
-
-            #expect(!chrome.isHeaderThemed)
             #expect(table.tableView.headerView === table.header)
             #expect(table.tableView.cornerView === table.corner)
+            withExtendedLifetime(chrome) {}
             withExtendedLifetime(table.window) {}
         }
     }
+
+    @Test("A theme that colors every content slot leaves the header and corner to AppKit")
+    func themeLeavesTheHeaderToAppKit() throws {
+        try ThemeTestFixture.preservingEngine {
+            for family in [ThemeTableChrome.Family.records, .code] {
+                try ThemeTestFixture.adopt(Self.fullTheme, appearance: .light)
+                let table = makeTable()
+                let chrome = ThemeTableChrome(tableView: table.tableView, family: family)
+
+                #expect(chrome.isBackgroundThemed)
+                #expect(table.tableView.headerView === table.header)
+                #expect(table.tableView.cornerView === table.corner)
+
+                ThemeTestFixture.adopt(.builtIn, appearance: .light)
+                chrome.apply()
+                #expect(table.tableView.headerView === table.header)
+                #expect(table.tableView.cornerView === table.corner)
+                withExtendedLifetime(table.window) {}
+            }
+        }
+    }
 }
diff --git a/apple/TableProTests/ViewModels/TableListingViewModelTests.swift b/apple/TableProTests/ViewModels/TableListingViewModelTests.swift
index 5172b46db9..8440368d9a 100644
--- a/apple/TableProTests/ViewModels/TableListingViewModelTests.swift
+++ b/apple/TableProTests/ViewModels/TableListingViewModelTests.swift
@@ -1,6 +1,4 @@
-// Show All Tables used to hand the listing statement to an editor tab and run nothing. A listing tab
-// now loads its own rows over a metadata connection, built from the plugin each time, so these cases
-// pin what it asks for, what it commits, and what a refresh, a failure and a late answer leave behind.
+// A listing tab loads its own rows over a metadata connection; these pin what a refresh, a failure and a late answer leave.
 
 import Combine
 import Foundation
@@ -11,7 +9,7 @@ import Testing
 
 private enum ListingReply: Sendable {
     case names([String])
-    /// One page of a listing the driver answers in pages, the way Redis answers `SCAN`.
+    // One page of a listing the driver answers in pages, the way Redis answers `SCAN`.
     case page([String], status: String?)
     case failure(any Error)
 }
@@ -20,8 +18,7 @@ private struct ListingRefused: Error, LocalizedError {
     var errorDescription: String? { "permission denied for view pg_stat_user_tables" }
 }
 
-/// The statements the stub driver was asked to run. The driver runs off the main actor, so the log is
-/// locked rather than isolated.
+// The driver runs off the main actor, so the log is locked rather than isolated.
 private final class ListingQueryLog: @unchecked Sendable {
     private let lock = NSLock()
     private var queries: [String] = []
@@ -35,8 +32,7 @@ private final class ListingQueryLog: @unchecked Sendable {
     }
 }
 
-/// Answers each read with the next scripted reply, and can hold the next read until the test releases
-/// it, the way a driver blocked on the wire holds one.
+// Can hold the next read until the test releases it, the way a driver blocked on the wire holds one.
 @MainActor
 private final class ScriptedListingProvider: ScopedMetadataProviding {
     private let connection: DatabaseConnection
@@ -216,8 +212,7 @@ struct TableListingViewModelTests {
         #expect(names(viewModel.state) == ["customers"])
     }
 
-    /// A driver blocked on the wire finishes after a newer load has, and cancelling its task cannot stop
-    /// it. Whatever it comes back with is older than what is on screen.
+    // A blocked read can finish after a newer load, and cancelling its task cannot stop it.
     @Test("A load a newer one superseded commits nothing, whatever it returns")
     func supersededLoadCommitsNothing() async {
         let outcomes: [ListingReply] = [.names(["stale"]), .failure(ListingRefused()), .failure(CancellationError())]
@@ -238,8 +233,7 @@ struct TableListingViewModelTests {
         }
     }
 
-    /// The pane leaving cancels the load, and coming back has to run it again rather than find a spinner
-    /// with nothing behind it, or an empty grid that reads as no tables.
+    // Coming back must run the load again, not find a spinner with nothing behind it.
     @Test("A cancelled first load settles back to idle and loads again when asked")
     func cancelledLoadRunsAgain() async throws {
         let (viewModel, provider) = makeViewModel()
@@ -264,8 +258,7 @@ struct TableListingViewModelTests {
         #expect(provider.executedQueries.count == 1)
     }
 
-    /// A page passed off as the whole listing read as every table there is, and an empty first page as
-    /// none at all.
+    // A page passed off as the whole listing read as every table there is.
     @Test("A partial listing says so, in the driver's words when it has some")
     func partialListingSaysSo() async {
         let (viewModel, provider) = makeViewModel(databaseType: .redis, slot: .database, pluginListsTables: false)
@@ -289,8 +282,7 @@ struct TableListingViewModelTests {
         #expect(TableListing(rows: TableRows(), isIncomplete: false, statusMessage: "").notice == nil)
     }
 
-    /// Refresh reaches a listing whose tab is not on screen too: asking again for a listing behind
-    /// another tab selects it and refreshes it in the same turn, before its view exists.
+    // A refresh reaches a listing behind another tab before its view exists.
     @Test("A refresh for this tab reloads it, and one for another tab does not")
     func refreshRequestReloadsOnlyThisTab() async throws {
         let (viewModel, provider) = makeViewModel()
@@ -306,8 +298,7 @@ struct TableListingViewModelTests {
         #expect(provider.executedQueries.count == 2)
     }
 
-    /// A closed tab's read can still be blocked on the wire when the tab goes. Whatever it brings back
-    /// belongs to nobody.
+    // A closed tab's read can still be blocked on the wire; whatever it brings back belongs to nobody.
     @Test("A cancelled load commits nothing when its read returns, and loads again when asked")
     func cancelledLoadCommitsNothing() async throws {
         let (viewModel, provider) = makeViewModel()
@@ -356,6 +347,55 @@ struct TableListingViewModelTests {
         #expect(closing.state.erased == .idle)
         #expect(store.model(forTab: openId) { closing } === open)
     }
+
+    // MARK: - Grid
+
+    private func gridNames(_ viewModel: TableListingViewModel) -> [String] {
+        viewModel.grid.model.rows.rows.map { $0.values.first.flatMap { $0.asText } ?? "" }
+    }
+
+    @Test("A landed listing reaches the tab's grid")
+    func listingReachesTheGrid() async {
+        let (viewModel, provider) = makeViewModel()
+        provider.answer(with: .names(["orders", "customers"]))
+
+        await viewModel.reload().value
+
+        #expect(gridNames(viewModel) == ["orders", "customers"])
+        #expect(viewModel.grid.model.rowCount == 2)
+        #expect(viewModel.grid.model.store.layoutScope == .ephemeral)
+    }
+
+    @Test("A header sort orders the listed tables, and the selection stays on the same table")
+    func headerSortOrdersTheHeldRows() async throws {
+        let (viewModel, provider) = makeViewModel()
+        provider.answer(with: .names(["orders", "customers", "accounts"]))
+        await viewModel.reload().value
+        let model = viewModel.grid.model
+        let orders = try #require(model.rowID(at: 0))
+        model.selectRows([orders])
+
+        model.setSort(SortState(columns: [SortColumn(columnIndex: 0, direction: .ascending)], source: .user))
+
+        #expect(gridNames(viewModel) == ["accounts", "customers", "orders"])
+        #expect(model.selectedRowIDs == [orders])
+        #expect(model.displayIndex(of: orders) == 2)
+    }
+
+    @Test("The sort the reader chose orders the next listing too")
+    func sortSurvivesARefresh() async {
+        let (viewModel, provider) = makeViewModel()
+        provider.answer(with: .names(["orders", "customers"]))
+        await viewModel.reload().value
+        let descending = SortState(columns: [SortColumn(columnIndex: 0, direction: .descending)], source: .user)
+        viewModel.grid.model.setSort(descending)
+
+        provider.answer(with: .names(["accounts", "orders", "zones"]))
+        await viewModel.reload().value
+
+        #expect(gridNames(viewModel) == ["zones", "orders", "accounts"])
+        #expect(viewModel.grid.model.store.sortState == descending)
+    }
 }
 
 private final class ListingPluginDriver: PluginDriverStub, @unchecked Sendable {
diff --git a/apple/TableProTests/Views/Agent/AgentResultRowsGridTests.swift b/apple/TableProTests/Views/Agent/AgentResultRowsGridTests.swift
new file mode 100644
index 0000000000..77e2693d1b
--- /dev/null
+++ b/apple/TableProTests/Views/Agent/AgentResultRowsGridTests.swift
@@ -0,0 +1,136 @@
+//
+//  AgentResultRowsGridTests.swift
+//  TableProTests
+//
+//  The rows an agent session read are held in full, so the pane's grid sorts them itself.
+//
+
+import AppKit
+import Combine
+import SwiftUI
+@testable import TablePro
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+@MainActor
+private final class AgentRunList: ObservableObject {
+    @Published var runs: [AgentQueryRun]
+
+    init(_ runs: [AgentQueryRun]) {
+        self.runs = runs
+    }
+}
+
+private struct AgentRunsHarness: View {
+    @ObservedObject var list: AgentRunList
+    let artifacts: AgentArtifactCache
+
+    var body: some View {
+        AgentResultRowsView(runs: list.runs, artifacts: artifacts, connection: nil)
+    }
+}
+
+@MainActor
+struct AgentResultRowsGridTests {
+    private func run(_ id: String, names: [String]) -> AgentQueryRun {
+        let rows = names.map { "[\"\($0)\"]" }.joined(separator: ",")
+        return AgentQueryRun(id: id, sql: "select name from users", resultJSON: #"{"columns":["name"],"rows":["# + rows + "]}")
+    }
+
+    private func host(_ list: AgentRunList) async -> NSWindow {
+        let window = ThemeTestFixture.host(
+            AgentRunsHarness(list: list, artifacts: AgentArtifactCache()),
+            size: NSSize(width: 600, height: 300)
+        )
+        await settle(window)
+        return window
+    }
+
+    // SwiftUI applies a change on a later run-loop turn, so each pass lays out and waits one main-queue turn.
+    private func settle(_ window: NSWindow) async {
+        for _ in 0 ..< 10 {
+            window.contentView?.layoutSubtreeIfNeeded()
+            await withCheckedContinuation { continuation in
+                DispatchQueue.main.async { continuation.resume() }
+            }
+        }
+    }
+
+    private func gridModel(in window: NSWindow) throws -> DataGridModel {
+        let table = try #require(Self.mainTable(in: window.contentView))
+        return try #require(table.controller?.model)
+    }
+
+    private func names(_ model: DataGridModel) -> [String] {
+        (0..<model.rowCount).compactMap { model.row(at: $0)?.values.first?.asText }
+    }
+
+    private static func mainTable(in view: NSView?) -> DataGridTableView? {
+        guard let view else { return nil }
+        if let table = view as? DataGridTableView, table.paneKind == .main { return table }
+        return view.subviews.lazy.compactMap { mainTable(in: $0) }.first
+    }
+
+    @Test("A header sort orders the run's rows, and the selection stays on the same row")
+    func headerSortOrdersTheHeldRows() async throws {
+        let list = AgentRunList([run("1", names: ["carol", "alice", "bob"])])
+        let window = await host(list)
+        defer { window.contentView = nil }
+        let model = try gridModel(in: window)
+        try #require(names(model) == ["carol", "alice", "bob"])
+        let carol = try #require(model.rowID(at: 0))
+        model.selectRows([carol])
+
+        model.setSort(SortState(columns: [SortColumn(columnIndex: 0, direction: .ascending)], source: .user))
+
+        #expect(names(model) == ["alice", "bob", "carol"])
+        #expect(model.selectedRowIDs == [carol])
+        #expect(model.displayIndex(of: carol) == 2)
+        #expect(model.store.layoutScope == .ephemeral)
+    }
+
+    @Test("Another run starts with no selection and no sort")
+    func anotherRunStartsOver() async throws {
+        let first = run("1", names: ["carol", "alice"])
+        let list = AgentRunList([first])
+        let window = await host(list)
+        defer { window.contentView = nil }
+        let model = try gridModel(in: window)
+        model.setSort(SortState(columns: [SortColumn(columnIndex: 0, direction: .ascending)], source: .user))
+        let selected = try #require(model.rowID(at: 0))
+        model.selectRows([selected])
+
+        list.runs = [first, run("2", names: ["zed", "amy"])]
+        try await waitUntil(timeout: .seconds(5)) {
+            window.contentView?.layoutSubtreeIfNeeded()
+            return names(model) == ["zed", "amy"]
+        }
+
+        #expect(names(model) == ["zed", "amy"])
+        #expect(model.selection.isEmpty)
+        #expect(!model.store.sortState.isSorting)
+    }
+
+    @Test("Another run draws raw values, not the formats picked on the previous run")
+    func anotherRunDropsDisplayFormats() async throws {
+        let first = run("1", names: ["carol", "alice"])
+        let list = AgentRunList([first])
+        let window = await host(list)
+        defer { window.contentView = nil }
+        let model = try gridModel(in: window)
+        let column = try #require(model.columns.columns.first)
+        model.setDisplayFormat(.json, for: column)
+        try #require(model.displayFormat(for: column) == .json)
+
+        list.runs = [first, run("2", names: ["zed", "amy"])]
+        try await waitUntil(timeout: .seconds(5)) {
+            window.contentView?.layoutSubtreeIfNeeded()
+            return names(model) == ["zed", "amy"]
+        }
+
+        let next = try #require(model.columns.columns.first)
+        #expect(model.displayFormat(for: next) == nil)
+        #expect(model.store.displayFormats.allSatisfy { $0 == nil })
+    }
+}
diff --git a/apple/TableProTests/Views/Compare/CompareRowGridModelTests.swift b/apple/TableProTests/Views/Compare/CompareRowGridModelTests.swift
index 806a0e552b..7cf21cbf62 100644
--- a/apple/TableProTests/Views/Compare/CompareRowGridModelTests.swift
+++ b/apple/TableProTests/Views/Compare/CompareRowGridModelTests.swift
@@ -1,4 +1,5 @@
 import AppKit
+import SwiftUI
 import TableProPluginKit
 import Testing
 
@@ -73,8 +74,7 @@ struct CompareRowGridModelTests {
         #expect(state.vocabulary == .comparison)
     }
 
-    /// The grid puts Include, Change and Side ahead of the plan's columns, so `email` at plan index 1
-    /// is grid column 4.
+    // Include, Change and Side lead the plan's columns, so `email` at plan index 1 is grid column 4.
     @Test func testAnUpdateMarksTheSourceModifiedAndTheTargetStruckAtTheDifferingGridColumn() {
         let lines = CompareRowGridModel.lines(for: entry(.update, key: "k1", differingIn: ["email"]))
         let expectedColumn = 1 + CompareRowGridModel.leadingColumnCount
@@ -190,17 +190,17 @@ struct CompareRowGridModelTests {
         #expect(model.lines.count == 3)
     }
 
-    @Test func testTheDelegateHandsBackEachLinesVisualState() throws {
+    @Test func testTheGridIsHandedEachLinesVisualState() throws {
         let session = try makeSession()
         let model = CompareRowGridModel()
         let entries = [entry(.insert, key: "k1"), entry(.update, key: "k2", differingIn: ["email"])]
         _ = model.ensureLoaded(key: key(entryCount: 2), plan: plan(), entries: entries, session: session)
 
-        #expect(model.dataGridVisualState(forRow: 0)?.isInserted == true)
-        #expect(model.dataGridVisualState(forRow: 1)?.modifiedColumns == Set([4]))
-        #expect(model.dataGridVisualState(forRow: 2)?.struckColumns == Set([4]))
-        #expect(model.dataGridVisualState(forRow: 3) == nil)
-        #expect(model.dataGridVisualState(forRow: -1) == nil)
+        #expect(visualState(model, row: 0)?.isInserted == true)
+        #expect(visualState(model, row: 1)?.modifiedColumns == Set([4]))
+        #expect(visualState(model, row: 2)?.struckColumns == Set([4]))
+        #expect(visualState(model, row: 3) == nil)
+        #expect(model.grid.gridVisualState(for: .existing(-1)) == nil)
     }
 
     @Test func testTheIncludeCheckboxShowsOnlyOnTheOpeningLineOfADifference() throws {
@@ -219,9 +219,10 @@ struct CompareRowGridModelTests {
         let session = try makeSession()
         let model = loadedModel(session: session)
 
-        #expect(model.dataGridCheckboxState(row: 0, column: 1) == nil)
-        #expect(model.dataGridCheckboxState(row: 0, column: 4) == nil)
+        #expect(checkboxState(model, row: 0, column: 1) == nil)
+        #expect(checkboxState(model, row: 0, column: 4) == nil)
         #expect(includeState(model, row: 99) == nil)
+        #expect(model.model.configuration.checkboxColumns == [CompareRowGridModel.includeColumn])
     }
 
     @Test func testTheIncludeCheckboxReflectsARowExcludedInTheSession() throws {
@@ -255,13 +256,13 @@ struct CompareRowGridModelTests {
         let session = try makeSession()
         let model = loadedModel(session: session)
 
-        model.dataGridSetCheckbox(false, rows: IndexSet([0, 1]), column: CompareRowGridModel.includeColumn)
+        setCheckbox(model, false, rows: [0, 1], column: CompareRowGridModel.includeColumn)
 
         #expect(session.dataPlans.first?.excludedRowKeys == Set(["k1", "k2"]))
         #expect(includeState(model, row: 0) == false)
         #expect(includeState(model, row: 1) == false)
 
-        model.dataGridSetCheckbox(true, rows: IndexSet(integer: 0), column: CompareRowGridModel.includeColumn)
+        setCheckbox(model, true, rows: [0], column: CompareRowGridModel.includeColumn)
 
         #expect(session.dataPlans.first?.excludedRowKeys == Set(["k2"]))
         #expect(includeState(model, row: 0) == true)
@@ -271,7 +272,7 @@ struct CompareRowGridModelTests {
         let session = try makeSession()
         let model = loadedModel(session: session)
 
-        model.dataGridSetCheckbox(false, rows: IndexSet([0, 1]), column: 1)
+        setCheckbox(model, false, rows: [0, 1], column: 1)
 
         #expect(session.dataPlans.first?.excludedRowKeys == Set<String>())
     }
@@ -280,11 +281,132 @@ struct CompareRowGridModelTests {
         let session = try makeSession()
         let model = loadedModel(session: session)
 
-        model.dataGridSetCheckbox(false, rows: IndexSet([3, 4, 5]), column: CompareRowGridModel.includeColumn)
+        setCheckbox(model, false, rows: [3, 4, 5], column: CompareRowGridModel.includeColumn)
 
         #expect(session.dataPlans.first?.excludedRowKeys == Set<String>())
     }
 
+    // D6: a toggle redraws the checkbox cells; a content replace there used to drop the selection.
+    @Test func testTogglingTheIncludeCheckboxKeepsTheRowsAndTheSelection() throws {
+        let session = try makeSession()
+        let model = loadedModel(session: session)
+        let grid = model.model
+        let first = try #require(grid.rowID(at: 0))
+        let second = try #require(grid.rowID(at: 1))
+        let selected = [first, second]
+        grid.selectRows(selected)
+        let selection = grid.selection
+        let selectionRevision = grid.selectionRevision
+        let displayRevision = grid.displayRevision
+
+        setCheckbox(model, false, rows: [0, 1], column: CompareRowGridModel.includeColumn)
+
+        #expect(session.dataPlans.first?.excludedRowKeys == Set(["k1", "k2"]))
+        #expect(grid.selection == selection)
+        #expect(grid.selectionRevision == selectionRevision)
+        #expect(grid.displayRevision == displayRevision)
+        #expect(grid.selectedRowIDs == selected)
+    }
+
+    @Test func testANewLoadClearsASelectionMadeAgainstTheOldOne() throws {
+        let session = try makeSession()
+        let model = loadedModel(session: session)
+        let first = try #require(model.model.rowID(at: 0))
+        model.model.selectRows([first])
+
+        model.ensureLoaded(
+            key: key(entryCount: 1), plan: plan(), entries: [entry(.delete, key: "k9")], session: session
+        )
+
+        #expect(model.model.selection.isEmpty)
+        #expect(model.model.rowCount == 1)
+    }
+
+    @Test func testTheRowMenuOffersCopyAsAndAColumnHeaderOffersDisplayAs() throws {
+        let session = try makeSession()
+        let model = loadedModel(session: session)
+        let controller = DataGridViewController(model: model.model)
+        let email = try #require(gridColumn(model, dataIndex: 4))
+
+        let rowMenu = controller.rowMenu(forRow: 0, displayColumn: 4, in: .main)
+        let headerMenu = controller.headerMenu(for: email)
+
+        #expect(rowMenu?.items.contains { $0.title == String(localized: "Copy as") } == true)
+        #expect(headerMenu?.items.contains { $0.title == String(localized: "Display As") } == true)
+    }
+
+    @Test func testAnotherTablesColumnsStartWithRawValues() throws {
+        let session = try makeSession()
+        let model = loadedModel(session: session)
+        let email = try #require(gridColumn(model, dataIndex: 4))
+        model.model.setDisplayFormat(.json, for: email)
+
+        model.ensureLoaded(
+            key: key(entryCount: 1), plan: plan(), entries: [entry(.delete, key: "k9")], session: session
+        )
+        #expect(model.model.displayFormat(for: email) == .json, "the same table keeps its formats")
+
+        let other = DataComparePlan(
+            table: "users",
+            schema: nil,
+            columns: ["id", "login"].map { CompareColumn(name: $0) },
+            scope: DataTableScope(keyColumns: ["id"]),
+            isEnabled: true
+        )
+        model.ensureLoaded(
+            key: CompareRowGridModel.LoadKey(
+                planId: other.id, answer: nil, columns: other.columnNames, filter: .all, entryCount: 1
+            ),
+            plan: other,
+            entries: [entry(.insert, key: "k1")],
+            session: session
+        )
+
+        let login = try #require(gridColumn(model, dataIndex: 4))
+        #expect(model.model.displayFormat(for: login) == nil)
+    }
+
+    @Test func testSpaceOnSelectedLinesTogglesTheirCheckboxesAndKeepsTheSelection() async throws {
+        let session = try makeSession()
+        let entries = [
+            entry(.insert, key: "k1"),
+            entry(.update, key: "k2", differingIn: ["email"]),
+            entry(.identical, key: "k3"),
+            entry(.conflict, key: "k4")
+        ]
+        let window = ThemeTestFixture.host(
+            CompareGridHarness(session: session, entries: entries),
+            size: NSSize(width: 800, height: 300)
+        )
+        defer { window.contentView = nil }
+        await Self.settle(window)
+        let table = try #require(Self.mainTable(in: window.contentView))
+        try #require(table.numberOfRows == 6)
+        table.selectRowIndexes(IndexSet([0, 1]), byExtendingSelection: false)
+        let model = try #require(table.controller?.model)
+        try #require(model.selection.affectedRows == IndexSet([0, 1]))
+
+        let space = try #require(NSEvent.keyEvent(
+            with: .keyDown,
+            location: .zero,
+            modifierFlags: [],
+            timestamp: 0,
+            windowNumber: window.windowNumber,
+            context: nil,
+            characters: " ",
+            charactersIgnoringModifiers: " ",
+            isARepeat: false,
+            keyCode: KeyCode.space.rawValue
+        ))
+        table.keyDown(with: space)
+        await Self.settle(window)
+
+        #expect(session.dataPlans.first?.excludedRowKeys == Set(["k1", "k2"]))
+        #expect(model.selection.affectedRows == IndexSet([0, 1]))
+        #expect(table.selectedRowIndexes == IndexSet([0, 1]))
+        #expect(table.numberOfRows == 6)
+    }
+
     @Test func testSameListsTheRetainedIdenticalRows() {
         let fixture = summaryFixture()
 
@@ -444,7 +566,7 @@ struct CompareRowGridModelTests {
         )
     }
 
-    /// Lines 0 insert, 1 and 2 update, 3 identical, 4 and 5 conflict.
+    // Lines 0 insert, 1 and 2 update, 3 identical, 4 and 5 conflict.
     private func loadedModel(session: CompareSyncSession) -> CompareRowGridModel {
         let model = CompareRowGridModel()
         let entries = [
@@ -458,8 +580,47 @@ struct CompareRowGridModelTests {
         return model
     }
 
+    private func gridColumn(_ model: CompareRowGridModel, dataIndex: Int) -> DataGridColumn? {
+        model.model.columns.columns.first { $0.dataIndex == dataIndex }
+    }
+
+    private func visualState(_ model: CompareRowGridModel, row: Int) -> RowVisualState? {
+        model.model.rowID(at: row).flatMap { model.grid.gridVisualState(for: $0) }
+    }
+
+    private func checkboxState(_ model: CompareRowGridModel, row: Int, column dataIndex: Int) -> Bool? {
+        guard let rowID = model.model.rowID(at: row), let column = gridColumn(model, dataIndex: dataIndex) else { return nil }
+        return model.grid.gridCheckboxState(for: rowID, column: column)
+    }
+
     private func includeState(_ model: CompareRowGridModel, row: Int) -> Bool? {
-        model.dataGridCheckboxState(row: row, column: CompareRowGridModel.includeColumn)
+        checkboxState(model, row: row, column: CompareRowGridModel.includeColumn)
+    }
+
+    // The grid's own path: the model hands the selected rows to its actions.
+    private func setCheckbox(_ model: CompareRowGridModel, _ isOn: Bool, rows: [Int], column dataIndex: Int) {
+        guard let column = gridColumn(model, dataIndex: dataIndex) else {
+            Issue.record("No column at data index \(dataIndex)")
+            return
+        }
+        let rowIDs = rows.compactMap { model.model.rowID(at: $0) }
+        model.model.actions?.gridSetCheckbox(isOn, rowIDs: rowIDs, column: column)
+    }
+
+    // SwiftUI applies a change on a later run-loop turn, so each pass lays out and waits one main-queue turn.
+    private static func settle(_ window: NSWindow) async {
+        for _ in 0 ..< 10 {
+            window.contentView?.layoutSubtreeIfNeeded()
+            await withCheckedContinuation { continuation in
+                DispatchQueue.main.async { continuation.resume() }
+            }
+        }
+    }
+
+    private static func mainTable(in view: NSView?) -> DataGridTableView? {
+        guard let view else { return nil }
+        if let table = view as? DataGridTableView, table.paneKind == .main { return table }
+        return view.subviews.lazy.compactMap { mainTable(in: $0) }.first
     }
 
     private func comparisonState(
@@ -552,9 +713,7 @@ struct CompareRowGridModelTests {
             ),
             state: DataGridCellState(
                 visualState: .empty,
-                isFocused: false,
                 isEditable: false,
-                isLargeDataset: false,
                 row: 0,
                 columnIndex: CompareRowGridModel.includeColumn
             ),
@@ -573,8 +732,19 @@ struct CompareRowGridModelTests {
             ),
             nullDisplayString: "NULL",
             onEmphasizedSelection: false,
-            hasOverlay: false,
             checkboxMark: checkboxMark
         )
     }
 }
+
+// The plan is read from the session on every render, as the compare window hands the grid the current plan.
+private struct CompareGridHarness: View {
+    @ObservedObject var session: CompareSyncSession
+    let entries: [RowDiffEntry]
+
+    var body: some View {
+        if let plan = session.dataPlans.first {
+            CompareRowGrid(session: session, plan: plan, filter: .all, entries: entries)
+        }
+    }
+}
diff --git a/apple/TableProTests/Views/DataFiles/DataFileStateThemeTests.swift b/apple/TableProTests/Views/DataFiles/DataFileStateThemeTests.swift
index c2e7fed6c6..a3c9c3e152 100644
--- a/apple/TableProTests/Views/DataFiles/DataFileStateThemeTests.swift
+++ b/apple/TableProTests/Views/DataFiles/DataFileStateThemeTests.swift
@@ -10,15 +10,14 @@ import SwiftUI
 import TableProTheme
 import Testing
 
-/// The Data File window's content sits on the window backdrop, and its loading and failure states
-/// stand in for the grid, so they take the grid's background while a theme sets it.
+// The loading and failure states stand in for the grid, so they take the grid's background.
 @MainActor
 struct DataFileStateThemeTests {
     private static let size = CGSize(width: 320, height: 240)
     private static let body = CGPoint(x: 0.03, y: 0.05)
 
     private func content(_ controller: DataFileController) -> some View {
-        DataFileContentView(controller: controller, gridDelegate: DataFileGridDelegate(controller: controller))
+        DataFileContentView(controller: controller)
             .frame(width: Self.size.width, height: Self.size.height)
     }
 
diff --git a/apple/TableProTests/Views/DataGrid/DataGridActiveCellBorderTests.swift b/apple/TableProTests/Views/DataGrid/DataGridActiveCellBorderTests.swift
new file mode 100644
index 0000000000..46680b4e19
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridActiveCellBorderTests.swift
@@ -0,0 +1,133 @@
+//
+//  DataGridActiveCellBorderTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import Testing
+
+@MainActor
+struct DataGridActiveCellBorderTests {
+    // Whole-point widths, so every column edge lands on a pixel of a 1x bitmap.
+    private func makeGrid() -> HostedDataGrid {
+        var layout = ColumnLayoutState()
+        layout.columnWidths = ["id": 80, "name": 120, "age": 80]
+        let grid = HostedDataGrid(
+            rows: GridFixtureRows.people,
+            store: InMemoryDataGridStateStore(columnLayout: layout)
+        )
+        grid.model.setSelection(GridSelectionReducer.single(GridCoord(row: 0, displayColumn: 1)))
+        grid.layout()
+        return grid
+    }
+
+    // Drawn the way the row view draws itself, into a flipped bitmap rather than through cacheDisplay.
+    private func render(row: Int, in grid: HostedDataGrid) throws -> (rowView: DataGridRowView, bitmap: NSBitmapImageRep) {
+        let rowView = try #require(grid.main.rowView(atRow: row, makeIfNecessary: true) as? DataGridRowView)
+        let content = try #require(rowView.subviews.first { $0 is DataGridRowContentView })
+        let bounds = rowView.bounds
+        let bitmap = try #require(NSBitmapImageRep(
+            bitmapDataPlanes: nil,
+            pixelsWide: Int(bounds.width.rounded(.up)),
+            pixelsHigh: Int(bounds.height.rounded(.up)),
+            bitsPerSample: 8,
+            samplesPerPixel: 4,
+            hasAlpha: true,
+            isPlanar: false,
+            colorSpaceName: .deviceRGB,
+            bytesPerRow: 0,
+            bitsPerPixel: 0
+        ))
+        let context = try #require(NSGraphicsContext(bitmapImageRep: bitmap))
+        let aqua = try #require(NSAppearance(named: .aqua))
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = context
+        context.cgContext.translateBy(x: 0, y: bounds.height)
+        context.cgContext.scaleBy(x: 1, y: -1)
+        aqua.performAsCurrentDrawingAppearance {
+            rowView.drawBackground(in: bounds)
+            rowView.drawSelection(in: bounds)
+            content.draw(content.bounds)
+        }
+        NSGraphicsContext.restoreGraphicsState()
+        return (rowView, bitmap)
+    }
+
+    private func leadingEdge(ofDisplayPosition position: Int, in grid: HostedDataGrid, rowView: NSView) throws -> Int {
+        let index = try #require(grid.tableIndex(ofDisplayPosition: position))
+        return Int(rowView.convert(grid.main.rect(ofColumn: index), from: grid.main).minX)
+    }
+
+    private func pixel(_ bitmap: NSBitmapImageRep, x: Int) throws -> NSColor {
+        try #require(bitmap.colorAt(x: x, y: bitmap.pixelsHigh / 2)?.usingColorSpace(.sRGB))
+    }
+
+    private func differs(_ lhs: NSColor, _ rhs: NSColor) -> Bool {
+        max(
+            abs(lhs.redComponent - rhs.redComponent),
+            abs(lhs.greenComponent - rhs.greenComponent),
+            abs(lhs.blueComponent - rhs.blueComponent)
+        ) > 0.08
+    }
+
+    @Test("The active cell draws a 2 pt inner border while the grid has focus")
+    func focusedBorderIsTwoPoints() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+        #expect(grid.focus())
+        #expect(grid.controller.gridHasFocus)
+
+        let (rowView, bitmap) = try render(row: 0, in: grid)
+        try #require(rowView.isSelected)
+        let edge = try leadingEdge(ofDisplayPosition: 1, in: grid, rowView: rowView)
+
+        let outer = try pixel(bitmap, x: edge)
+        let inner = try pixel(bitmap, x: edge + 1)
+        let fill = try pixel(bitmap, x: edge + 2)
+        #expect(!differs(outer, inner))
+        #expect(differs(inner, fill))
+    }
+
+    @Test("The active cell draws a 1 pt inner border while the grid does not have focus")
+    func unfocusedBorderIsOnePoint() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+        #expect(!grid.controller.gridHasFocus)
+
+        let (rowView, bitmap) = try render(row: 0, in: grid)
+        let edge = try leadingEdge(ofDisplayPosition: 1, in: grid, rowView: rowView)
+
+        let outer = try pixel(bitmap, x: edge)
+        let inner = try pixel(bitmap, x: edge + 1)
+        let fill = try pixel(bitmap, x: edge + 2)
+        #expect(differs(outer, inner))
+        #expect(!differs(inner, fill))
+    }
+
+    @Test("A cell beside the active cell draws no border")
+    func otherCellsDrawNoBorder() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+
+        let (rowView, bitmap) = try render(row: 0, in: grid)
+        let edge = try leadingEdge(ofDisplayPosition: 2, in: grid, rowView: rowView)
+
+        let border = try pixel(bitmap, x: edge)
+        let fill = try pixel(bitmap, x: edge + 2)
+        #expect(!differs(border, fill))
+    }
+
+    @Test("A row without the active cell draws no border at its column")
+    func otherRowsDrawNoBorder() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+
+        let (rowView, bitmap) = try render(row: 2, in: grid)
+        let edge = try leadingEdge(ofDisplayPosition: 1, in: grid, rowView: rowView)
+
+        let border = try pixel(bitmap, x: edge)
+        let fill = try pixel(bitmap, x: edge + 2)
+        #expect(!differs(border, fill))
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridBodyChromeTests.swift b/apple/TableProTests/Views/DataGrid/DataGridBodyChromeTests.swift
new file mode 100644
index 0000000000..5abaf3b1ef
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridBodyChromeTests.swift
@@ -0,0 +1,264 @@
+//
+//  DataGridBodyChromeTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import TableProTheme
+import Testing
+
+// gridStyleMask stays empty (#2381), so these measure the separators the grid draws itself, through
+// rect(ofColumn:) and the pixels rather than the chrome's own arithmetic.
+@MainActor
+struct DataGridBodyChromeTests {
+    private func makeGrid(columns: [String], rows: Int = 3) -> HostedDataGrid {
+        let queryRows = (0 ..< rows).map { row in
+            columns.map { PluginCellValue.text("\($0)-\(row)") }
+        }
+        let tableRows = TableRows.from(
+            queryRows: queryRows,
+            columns: columns,
+            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
+        )
+        var layout = ColumnLayoutState()
+        for column in columns {
+            layout.columnWidths[column] = 120
+        }
+        return HostedDataGrid(rows: tableRows, store: InMemoryDataGridStateStore(columnLayout: layout))
+    }
+
+    private func bitmap(width: CGFloat, height: CGFloat) throws -> NSBitmapImageRep {
+        try #require(NSBitmapImageRep(
+            bitmapDataPlanes: nil,
+            pixelsWide: Int(width.rounded(.up)),
+            pixelsHigh: Int(height.rounded(.up)),
+            bitsPerSample: 8,
+            samplesPerPixel: 4,
+            hasAlpha: true,
+            isPlanar: false,
+            colorSpaceName: .deviceRGB,
+            bytesPerRow: 0,
+            bitsPerPixel: 0
+        ))
+    }
+
+    // Flipped, as the table and its row views are, so a rect's minY is the bitmap's top row.
+    private func drawFlipped(into rep: NSBitmapImageRep, height: CGFloat, appearance: NSAppearance, _ draw: () -> Void) throws {
+        let context = try #require(NSGraphicsContext(bitmapImageRep: rep))
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = context
+        context.cgContext.translateBy(x: 0, y: height)
+        context.cgContext.scaleBy(x: 1, y: -1)
+        appearance.performAsCurrentDrawingAppearance(draw)
+        NSGraphicsContext.restoreGraphicsState()
+    }
+
+    // A partial repaint invalidates one cell, and rect(ofColumn:) includes the intercell spacing the next separator sits in.
+    @Test("Repainting one cell redraws the separator standing inside its rect")
+    func partialRepaintRedrawsTheSeparatorInsideIt() throws {
+        let grid = makeGrid(columns: ["id", "name", "total"])
+        defer { grid.close() }
+        let table = grid.main
+        let first = try #require(grid.tableIndex(ofDisplayPosition: 0))
+        let next = try #require(grid.tableIndex(ofDisplayPosition: 1))
+        let cellRect = table.rect(ofColumn: first)
+        let neighbourSeparator = table.rect(ofColumn: next).minX - DataGridBodyChrome.separatorThickness
+
+        #expect(neighbourSeparator >= cellRect.minX && neighbourSeparator < cellRect.maxX)
+
+        let separators = DataGridBodyChrome.separatorRects(in: cellRect, of: table, tableView: table)
+
+        #expect(separators.contains { $0.minX == neighbourSeparator })
+    }
+
+    @Test("A separator stands at the leading edge of every column after the first")
+    func separatorsSitAtLeadingEdges() {
+        let grid = makeGrid(columns: ["id", "name", "total"])
+        defer { grid.close() }
+        let table = grid.main
+
+        let separators = DataGridBodyChrome.separatorRects(in: table.bounds, of: table, tableView: table)
+
+        let expected = table.tableColumns.indices
+            .map { table.rect(ofColumn: $0) }
+            .filter { $0.minX > 0 }
+            .map { $0.minX - DataGridBodyChrome.separatorThickness }
+        #expect(expected.count == table.tableColumns.count - 1)
+        #expect(separators.map { $0.minX } == expected)
+        #expect(separators.allSatisfy { $0.width == DataGridBodyChrome.separatorThickness })
+    }
+
+    @Test("The row-number column, first in the table, is given no separator of its own")
+    func rowNumberColumnHasNoSeparator() throws {
+        let grid = makeGrid(columns: ["id", "name"])
+        defer { grid.close() }
+        let table = grid.main
+        let rowNumber = try #require(grid.controller.main.rowNumberTableColumn)
+        let rowNumberIndex = table.column(withIdentifier: rowNumber.identifier)
+
+        #expect(rowNumberIndex == 0)
+        let separators = DataGridBodyChrome.separatorRects(in: table.bounds, of: table, tableView: table)
+        #expect(!separators.contains { $0.maxX <= 0 })
+        #expect(separators.first?.maxX == table.rect(ofColumn: 1).minX)
+    }
+
+    // NSTableView's own grid color is separatorColor, not NSColor.gridColor, which in dark mode is darker than the rows.
+    @Test("Without a theme override the table keeps AppKit's own grid and background colours")
+    func defaultThemeKeepsTheTableDefaults() {
+        let engine = ThemeEngine.shared
+        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
+        defer { engine.adopt(restore) }
+        engine.adopt(ThemeSelection(pair: .builtIn, effectiveAppearance: .light))
+
+        let tableView = NSTableView()
+        let stock = NSTableView()
+        tableView.gridColor = .systemRed
+        tableView.backgroundColor = .systemRed
+        DataGridBodyChrome.applyThemeColors(to: tableView, scope: .live)
+
+        #expect(tableView.gridColor == .separatorColor)
+        #expect(tableView.gridColor == stock.gridColor)
+        #expect(tableView.backgroundColor == .controlBackgroundColor)
+        #expect(tableView.backgroundColor == stock.backgroundColor)
+    }
+
+    @Test("A theme's grid line and background become the table's colours")
+    func themeOverridesBecomeTheTableColors() throws {
+        let engine = ThemeEngine.shared
+        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
+        defer { engine.adopt(restore) }
+        var theme = BuiltInThemes.light
+        theme.id = "test.body-chrome"
+        theme.overrides[.gridLine] = try ThemeColor(validating: "#FF0000")
+        theme.overrides[.gridBackground] = try ThemeColor(validating: "#102030")
+        engine.adopt(ThemeSelection(pair: ThemePair(light: theme, dark: BuiltInThemes.dark), effectiveAppearance: .light))
+
+        let tableView = NSTableView()
+        DataGridBodyChrome.applyThemeColors(to: tableView, scope: .live)
+
+        #expect(tableView.gridColor == engine.resolved[.gridLine])
+        #expect(tableView.backgroundColor == engine.resolved[.gridBackground])
+        #expect(tableView.gridColor != .separatorColor)
+    }
+
+    // The table's gridColor is the dynamic catalog color, so an appearance change carries the separator with it.
+    @Test("The separator is drawn in the table view's own grid colour")
+    func separatorUsesTheTableViewGridColor() throws {
+        let grid = makeGrid(columns: ["id", "name"])
+        defer { grid.close() }
+        let table = grid.main
+        table.gridColor = .systemRed
+        let rowView = try #require(table.rowView(atRow: 0, makeIfNecessary: true) as? DataGridRowView)
+        let content = try #require(rowView.subviews.first { $0 is DataGridRowContentView })
+        let bounds = rowView.bounds
+        let rep = try bitmap(width: bounds.width, height: bounds.height)
+        let aqua = try #require(NSAppearance(named: .aqua))
+        try drawFlipped(into: rep, height: bounds.height, appearance: aqua) {
+            rowView.drawBackground(in: bounds)
+            content.draw(content.bounds)
+        }
+
+        let firstData = try #require(grid.tableIndex(ofDisplayPosition: 0))
+        let boundary = rowView.convert(table.rect(ofColumn: firstData), from: table).minX
+        let sampled = try #require(rep.colorAt(x: Int(boundary - 0.5), y: rep.pixelsHigh / 2)?.usingColorSpace(.deviceRGB))
+        let expected = try #require(NSColor.systemRed.usingColorSpace(.deviceRGB))
+
+        #expect(abs(sampled.redComponent - expected.redComponent) < 0.15)
+        #expect(sampled.redComponent > sampled.greenComponent + 0.3)
+    }
+
+    @Test("Past the last row, bands continue one row apart, numbered on from the last row")
+    func bandsContinuePastTheLastRow() throws {
+        let grid = makeGrid(columns: ["id", "name"], rows: 3)
+        defer { grid.close() }
+        let table = grid.main
+        let bounds = table.bounds
+        let bands = DataGridBodyChrome.rowBands(in: bounds, of: table, tableView: table)
+
+        let rows = Array(bands.prefix(3))
+        let past = Array(bands.dropFirst(3))
+        let rowIndexes = rows.map { $0.row }
+        let rowsAreTableRows = rows.allSatisfy { $0.isTableRow }
+        let pastIndexes = past.map { $0.row }
+        let pastAreTableRows = past.contains { $0.isTableRow }
+
+        #expect(rowIndexes == [0, 1, 2])
+        #expect(rowsAreTableRows)
+        #expect(!past.isEmpty)
+        #expect(pastIndexes == Array(3..<(3 + past.count)))
+        #expect(!pastAreTableRows)
+        let lastRowBottom = table.rect(ofRow: 2).maxY
+        for (offset, band) in past.enumerated() {
+            #expect(band.rect.minY == lastRowBottom + CGFloat(offset) * table.rowHeight)
+            #expect(band.rect.height == table.rowHeight)
+        }
+        let lastBand = try #require(past.last)
+        #expect(lastBand.rect.maxY >= bounds.maxY)
+    }
+
+    // NSTableView blends the dark alternate stripe in twice past the last row; the grid blends it once, as a row does.
+    @Test("Past the last row the table blends each stripe once, as a row does")
+    func stripesPastTheLastRowAreBlendedOnce() throws {
+        let grid = makeGrid(columns: ["id", "name"], rows: 1)
+        defer { grid.close() }
+        let table = grid.main
+        table.usesAlternatingRowBackgroundColors = true
+        let dark = try #require(NSAppearance(named: .darkAqua))
+        let bounds = table.bounds
+        let bands = DataGridBodyChrome.rowBands(in: bounds, of: table, tableView: table)
+        let oddBand = try #require(bands.first { !$0.isTableRow && !$0.row.isMultiple(of: 2) })
+
+        let rep = try bitmap(width: bounds.width, height: bounds.height)
+        try drawFlipped(into: rep, height: bounds.height, appearance: dark) {
+            DataGridBodyChrome.drawTableBackground(in: bounds, of: table, scope: .live)
+        }
+
+        let sampled = try #require(rep.colorAt(x: 300, y: Int(oddBand.rect.midY))?.usingColorSpace(.sRGB))
+        let expected = try #require(singleBlend(over: .controlBackgroundColor, of: oddBand.row, appearance: dark))
+
+        #expect(abs(sampled.redComponent - expected.redComponent) < 0.02, "sampled \(sampled), expected \(expected)")
+        #expect(abs(sampled.greenComponent - expected.greenComponent) < 0.02)
+        #expect(abs(sampled.blueComponent - expected.blueComponent) < 0.02)
+    }
+
+    @Test("Stripes follow the alternating rows setting and the theme's pair")
+    func stripeColorFollowsTheSettingAndTheme() {
+        let tableView = NSTableView()
+        tableView.usesAlternatingRowBackgroundColors = false
+        #expect(DataGridBodyChrome.stripeColor(forRow: 1, of: tableView, scope: .live) == nil)
+
+        tableView.usesAlternatingRowBackgroundColors = true
+        let resolved = ThemeScope.live.resolved
+        #expect(DataGridBodyChrome.stripeColor(forRow: 0, of: tableView, scope: .live) == resolved[.gridBackground])
+        #expect(DataGridBodyChrome.stripeColor(forRow: 1, of: tableView, scope: .live) == resolved[.gridAlternateRow])
+    }
+
+    private func singleBlend(over background: NSColor, of row: Int, appearance: NSAppearance) -> NSColor? {
+        guard let rep = NSBitmapImageRep(
+            bitmapDataPlanes: nil,
+            pixelsWide: 1,
+            pixelsHigh: 1,
+            bitsPerSample: 8,
+            samplesPerPixel: 4,
+            hasAlpha: true,
+            isPlanar: false,
+            colorSpaceName: .deviceRGB,
+            bytesPerRow: 0,
+            bitsPerPixel: 0
+        ), let context = NSGraphicsContext(bitmapImageRep: rep) else { return nil }
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = context
+        appearance.performAsCurrentDrawingAppearance {
+            let pixel = NSRect(x: 0, y: 0, width: 1, height: 1)
+            background.setFill()
+            pixel.fill()
+            let stripes = NSColor.alternatingContentBackgroundColors
+            stripes[row % stripes.count].setFill()
+            pixel.fill(using: .sourceOver)
+        }
+        NSGraphicsContext.restoreGraphicsState()
+        return rep.colorAt(x: 0, y: 0)?.usingColorSpace(.sRGB)
+    }
+}
diff --git a/apple/TableProTests/Views/Results/DataGridCellAppearanceTests.swift b/apple/TableProTests/Views/DataGrid/DataGridCellAppearanceTests.swift
similarity index 70%
rename from apple/TableProTests/Views/Results/DataGridCellAppearanceTests.swift
rename to apple/TableProTests/Views/DataGrid/DataGridCellAppearanceTests.swift
index 7fc0f2ef12..5303847a7f 100644
--- a/apple/TableProTests/Views/Results/DataGridCellAppearanceTests.swift
+++ b/apple/TableProTests/Views/DataGrid/DataGridCellAppearanceTests.swift
@@ -2,15 +2,11 @@
 //  DataGridCellAppearanceTests.swift
 //  TableProTests
 //
-//  The grid draws its cells rather than mounting one view per cell, so what a cell looks like is
-//  decided here rather than by a view configuring itself. These are the decisions: which font a
-//  placeholder takes, when a tint survives, what colour text turns on a selected row.
-//
 
 import AppKit
-import Testing
-
 @testable import TablePro
+import TableProPluginKit
+import Testing
 
 @MainActor
 struct DataGridCellAppearanceTests {
@@ -39,9 +35,7 @@ struct DataGridCellAppearanceTests {
         rowNumberText: .systemTeal,
         deletedRowText: .systemRed,
         modifiedColumnTint: .systemYellow,
-        findMatchTint: .systemOrange,
-        selectionText: .systemIndigo,
-        focusRing: .systemMint
+        findMatchTint: .systemOrange
     )
 
     private func resolve(
@@ -50,13 +44,12 @@ struct DataGridCellAppearanceTests {
         rawValue: String? = "value",
         placeholder: DataGridCellPlaceholder? = nil,
         visualState: RowVisualState = .empty,
-        isFocused: Bool = false,
         isEditable: Bool = true,
-        isLargeDataset: Bool = false,
         isCurrentFindMatch: Bool = false,
         columnIndex: Int = 0,
         onEmphasizedSelection: Bool = false,
-        hasOverlay: Bool = false,
+        checkboxMark: DataGridCheckboxMark? = nil,
+        textTone: NSColor? = nil,
         palette: DataGridCellPalette? = nil
     ) -> DataGridCellAppearance {
         DataGridCellAppearance.resolve(
@@ -64,9 +57,7 @@ struct DataGridCellAppearanceTests {
             content: DataGridCellContent(displayText: text, rawValue: rawValue, placeholder: placeholder),
             state: DataGridCellState(
                 visualState: visualState,
-                isFocused: isFocused,
                 isEditable: isEditable,
-                isLargeDataset: isLargeDataset,
                 isCurrentFindMatch: isCurrentFindMatch,
                 row: 0,
                 columnIndex: columnIndex
@@ -74,7 +65,8 @@ struct DataGridCellAppearanceTests {
             palette: palette ?? self.palette,
             nullDisplayString: "NULL",
             onEmphasizedSelection: onEmphasizedSelection,
-            hasOverlay: hasOverlay
+            checkboxMark: checkboxMark,
+            textTone: textTone
         )
     }
 
@@ -97,6 +89,7 @@ struct DataGridCellAppearanceTests {
         #expect(null.textColor == .secondaryLabelColor)
         #expect(null.text == "NULL")
         #expect(empty.font == palette.italicFont)
+        #expect(empty.text == String(localized: "Empty"))
     }
 
     @Test("A server default draws in the medium font, tinted")
@@ -127,11 +120,41 @@ struct DataGridCellAppearanceTests {
         #expect(literal.textColor == .labelColor)
     }
 
-    /// A large result blanks its placeholders rather than formatting every one of them.
-    @Test("A large result draws no placeholder text")
-    func largeDatasetBlanksPlaceholders() {
-        #expect(resolve(text: "", placeholder: .null, isLargeDataset: true).text.isEmpty)
-        #expect(resolve(text: "", placeholder: .empty, isLargeDataset: true).text.isEmpty)
+    // Changed on purpose: a result past 5,000 rows used to draw its placeholders blank.
+    @Test("A NULL far down a large result still shows its placeholder text")
+    func largeResultShowsPlaceholders() throws {
+        let rowCount = 6_000
+        let nullRow = 5_500
+        let rows = TableRows.from(
+            queryRows: (0..<rowCount).map { index -> [PluginCellValue] in
+                [.text("\(index)"), index == nullRow ? .null : .text("v")]
+            },
+            columns: ["id", "note"],
+            columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
+        )
+        let owner = GridTestOwner(rows)
+        defer { withExtendedLifetime(owner) {} }
+        let model = DataGridModel()
+        model.dataSource = owner
+        model.reloadRows()
+        let presenter = DataGridCellPresenter(model: model)
+        let aqua = try #require(NSAppearance(named: .aqua))
+        let pass = try #require(presenter.makePass(in: aqua))
+        let row = try #require(model.row(at: nullRow))
+        let column = try #require(model.columns.column(at: 1))
+
+        let appearance = try #require(presenter.appearance(
+            of: row,
+            displayRow: nullRow,
+            column: column,
+            visualState: .empty,
+            pass: pass,
+            onEmphasizedSelection: false
+        ))
+
+        #expect(appearance.text == pass.nullDisplayString)
+        #expect(!appearance.text.isEmpty)
+        #expect(appearance.font == pass.palette.italicFont)
     }
 
     @Test("A deleted row recolours its text and keeps no modified tint")
@@ -151,8 +174,7 @@ struct DataGridCellAppearanceTests {
         #expect(palette.findMatchText == DataGridCellPalette.findMatchTextColor)
     }
 
-    /// `findHighlightColor` is a light yellow in both appearances, so text on it has to stay dark
-    /// in Dark Mode too, where the label color is white.
+    // findHighlightColor is light yellow in both appearances, where the label color is white in Dark Mode.
     @Test("Find match text stays dark in both appearances")
     func findMatchTextStaysDark() throws {
         for name in [NSAppearance.Name.aqua, .darkAqua] {
@@ -166,11 +188,11 @@ struct DataGridCellAppearanceTests {
         }
     }
 
-    /// The selection paints the whole row, so a modified cell's tint would be painted over it.
-    @Test("A selected row drops the modified tint and takes the selection's text colour")
+    @Test("A selected cell drops the modified tint and takes the selection's text colour")
     func selectionSuppressesTheModifiedTint() {
-        let unselected = resolve(visualState: RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [0]), columnIndex: 0)
-        let selected = resolve(visualState: RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [0]), columnIndex: 0, onEmphasizedSelection: true)
+        let modified = RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [0])
+        let unselected = resolve(visualState: modified, columnIndex: 0)
+        let selected = resolve(visualState: modified, columnIndex: 0, onEmphasizedSelection: true)
 
         #expect(unselected.backgroundTint == palette.modifiedColumnTint)
         #expect(selected.backgroundTint == nil)
@@ -179,39 +201,10 @@ struct DataGridCellAppearanceTests {
 
     @Test("Only the modified column carries the tint")
     func onlyTheModifiedColumnIsTinted() {
-        #expect(resolve(visualState: RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [2]), columnIndex: 2).backgroundTint != nil)
-        #expect(resolve(visualState: RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [2]), columnIndex: 3).backgroundTint == nil)
-    }
-
-    // MARK: - The cell cursor
-
-    /// A mounted cell got its ring from AppKit. A drawn cell has no view to hang one on, so the
-    /// appearance has to say which of the two shapes to draw.
-    @Test("The cell cursor draws a ring on an unselected row and a border on a selected one")
-    func cursorShape() {
-        let unselected = resolve(isFocused: true)
-        let selected = resolve(isFocused: true, onEmphasizedSelection: true)
+        let state = RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [2])
 
-        #expect(unselected.drawsFocusRing)
-        #expect(!unselected.drawsFocusBorder)
-        #expect(selected.drawsFocusBorder)
-        #expect(!selected.drawsFocusRing)
-    }
-
-    @Test("An open editor hides the cell cursor behind it")
-    func overlayHidesTheCursor() {
-        let appearance = resolve(isFocused: true, hasOverlay: true)
-
-        #expect(!appearance.drawsFocusRing)
-        #expect(!appearance.drawsFocusBorder)
-    }
-
-    @Test("An unfocused cell draws no cursor")
-    func unfocusedDrawsNothing() {
-        let appearance = resolve()
-
-        #expect(!appearance.drawsFocusRing)
-        #expect(!appearance.drawsFocusBorder)
+        #expect(resolve(visualState: state, columnIndex: 2).backgroundTint != nil)
+        #expect(resolve(visualState: state, columnIndex: 3).backgroundTint == nil)
     }
 
     // MARK: - Accessories
@@ -230,6 +223,12 @@ struct DataGridCellAppearanceTests {
             resolve(kind: .foreignKey, rawValue: "42", onEmphasizedSelection: true).accessoryRole
                 == .foreignKeyEmphasized
         )
+        #expect(
+            resolve(
+                kind: .date,
+                visualState: RowVisualState(isDeleted: true, isInserted: false, modifiedColumns: [])
+            ).accessoryRole == .chevronDisabled
+        )
     }
 
     @Test("A cell with no accessory resolves no symbol")
@@ -237,6 +236,40 @@ struct DataGridCellAppearanceTests {
         #expect(resolve().accessoryRole == nil)
     }
 
+    @Test("A read-only cell shows no chevron, a foreign key keeps its arrow")
+    func readOnlyCellsKeepOnlyTheArrow() {
+        #expect(resolve(kind: .date, isEditable: false).accessory == .none)
+        #expect(resolve(kind: .date, isEditable: true).accessory == .chevron)
+        #expect(resolve(kind: .foreignKey, rawValue: "42", isEditable: false).accessory == .foreignKey)
+    }
+
+    // MARK: - Checkboxes and owner tone
+
+    @Test("A checkbox cell draws its mark and no text")
+    func checkboxDrawsTheMarkOnly() {
+        let checked = resolve(kind: .checkbox, text: "1", rawValue: "1", checkboxMark: .checked)
+        let plain = resolve(kind: .text, text: "1", rawValue: "1", checkboxMark: .checked)
+
+        #expect(checked.text.isEmpty)
+        #expect(checked.checkboxMark == .checked)
+        #expect(plain.checkboxMark == nil)
+        #expect(plain.text == "1")
+    }
+
+    @Test("An owner's text tone colors a value but not a placeholder or a deleted row")
+    func textToneColorsValuesOnly() {
+        let toned = resolve(textTone: .systemGreen)
+        let null = resolve(text: "", placeholder: .null, textTone: .systemGreen)
+        let deleted = resolve(
+            visualState: RowVisualState(isDeleted: true, isInserted: false, modifiedColumns: []),
+            textTone: .systemGreen
+        )
+
+        #expect(toned.textColor == .systemGreen)
+        #expect(null.textColor == .secondaryLabelColor)
+        #expect(deleted.textColor == palette.deletedRowText)
+    }
+
     // MARK: - Highlight rules
 
     private func highlighted(
@@ -342,6 +375,7 @@ struct DataGridCellAppearanceTests {
         #expect(appearance.textColor == .labelColor)
     }
 
+    // Changed on purpose: the selected text is always the system's, so it no longer takes a theme color.
     @Test("Selection, deletion and a find match outrank the boolean color")
     func booleanColorYieldsToState() {
         let selected = resolve(kind: .boolean, text: "1", rawValue: "1", onEmphasizedSelection: true, palette: themedPalette)
@@ -354,31 +388,33 @@ struct DataGridCellAppearanceTests {
         )
         let found = resolve(kind: .boolean, text: "1", rawValue: "1", isCurrentFindMatch: true, palette: themedPalette)
 
-        #expect(selected.textColor == .systemIndigo)
+        #expect(selected.textColor == .alternateSelectedControlTextColor)
         #expect(deleted.textColor == .systemRed)
         #expect(found.textColor == themedPalette.findMatchText)
     }
 
     // MARK: - Selection
 
-    @Test("Without a theme override, a selected cell and its cursor take the system's colors")
+    @Test("A selected cell's text takes the system's selected text color")
     func nativeSelectionColors() {
-        let selected = resolve(isFocused: true, onEmphasizedSelection: true)
-        let unselected = resolve(isFocused: true)
+        let selected = resolve(onEmphasizedSelection: true)
+        let unselected = resolve()
 
         #expect(selected.textColor == .alternateSelectedControlTextColor)
-        #expect(selected.focusColor == .alternateSelectedControlTextColor)
-        #expect(unselected.focusColor == .keyboardFocusIndicatorColor)
+        #expect(unselected.textColor == .labelColor)
     }
 
-    @Test("A theme's selection text reaches a selected cell's text and its cursor")
-    func themedSelectionColors() {
-        let selected = resolve(isFocused: true, onEmphasizedSelection: true, palette: themedPalette)
-        let unselected = resolve(isFocused: true, palette: themedPalette)
+    // Changed on purpose: the selection text slot is gone, so a theme cannot reach a selected cell.
+    @Test("A theme that overrides every slot leaves the selected text to the system")
+    func themeNeverReachesSelectedText() throws {
+        let aqua = try #require(NSAppearance(named: .aqua))
+        let palette = try ThemeTestFixture.withEverySlotOverridden {
+            ThemeScope.live.dataGridCellPalette(in: aqua)
+        }
+        let selected = resolve(onEmphasizedSelection: true, palette: palette)
 
-        #expect(selected.textColor == .systemIndigo)
-        #expect(selected.focusColor == .systemIndigo)
-        #expect(unselected.textColor == .systemPurple)
-        #expect(unselected.focusColor == .systemMint)
+        #expect(palette.selectionText == .alternateSelectedControlTextColor)
+        #expect(selected.textColor == .alternateSelectedControlTextColor)
+        #expect(resolve(palette: palette).textColor != .alternateSelectedControlTextColor)
     }
 }
diff --git a/apple/TableProTests/Views/DataGrid/DataGridColumnOrderTests.swift b/apple/TableProTests/Views/DataGrid/DataGridColumnOrderTests.swift
new file mode 100644
index 0000000000..0c66471d11
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridColumnOrderTests.swift
@@ -0,0 +1,171 @@
+//
+//  DataGridColumnOrderTests.swift
+//  TableProTests
+//
+
+import AppKit
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct DataGridColumnOrderTests {
+    private static func rows(_ columns: [String], count: Int = 3) -> TableRows {
+        TableRows.from(
+            queryRows: (0..<count).map { row in columns.map { PluginCellValue.text("\($0)\(row)") } },
+            columns: columns,
+            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count)
+        )
+    }
+
+    private static let base = ["id", "notes", "email"]
+
+    private func tableIndex(of name: String, in grid: HostedDataGrid) throws -> Int {
+        let column = try #require(grid.tableColumn(named: name))
+        return grid.main.column(withIdentifier: column.identifier)
+    }
+
+    // Dragging a header moves the table column first; AppKit then posts the move the grid writes back.
+    private func moveColumn(named name: String, toDisplayPosition position: Int, in grid: HostedDataGrid) throws {
+        let from = try tableIndex(of: name, in: grid)
+        let leading = grid.controller.main.hasRowNumberColumn ? 1 : 0
+        grid.main.moveColumn(from, toColumn: leading + position)
+    }
+
+    // MARK: - Display positions
+
+    @Test("Every display position maps to the table column after the row numbers")
+    func displayPositionsFollowTheRowNumbers() {
+        let grid = HostedDataGrid(rows: Self.rows(Self.base))
+        defer { grid.close() }
+
+        #expect(grid.tableIndex(ofDisplayPosition: 0) == 1)
+        #expect(grid.tableIndex(ofDisplayPosition: 1) == 2)
+        #expect(grid.tableIndex(ofDisplayPosition: 2) == 3)
+        for _ in 0..<5 {
+            #expect(grid.tableIndex(ofDisplayPosition: 1) == 2)
+        }
+    }
+
+    @Test("A position past the presented columns maps to no table column")
+    func outOfRangePositionResolvesNothing() {
+        let grid = HostedDataGrid(rows: Self.rows(["only"]))
+        defer { grid.close() }
+
+        #expect(grid.tableIndex(ofDisplayPosition: 5) == nil)
+        #expect(grid.model.columns.column(at: 5) == nil)
+    }
+
+    @Test("A result with fewer columns drops the positions it no longer has")
+    func narrowerResultDropsPositions() {
+        let grid = HostedDataGrid(rows: Self.rows(["a", "b"]))
+        defer { grid.close() }
+        #expect(grid.tableIndex(ofDisplayPosition: 1) == 2)
+
+        grid.owner.tableRows = Self.rows(["a"])
+        grid.model.reloadRows()
+
+        #expect(grid.tableIndex(ofDisplayPosition: 1) == nil)
+        #expect(grid.main.tableColumns.count == 2)
+    }
+
+    @Test("A header drag reorders the model's columns, and positions follow the drawn order")
+    func headerDragReordersColumns() throws {
+        let grid = HostedDataGrid(rows: Self.rows(Self.base))
+        defer { grid.close() }
+        #expect(grid.model.columns.orderedNames == ["id", "notes", "email"])
+
+        try moveColumn(named: "email", toDisplayPosition: 0, in: grid)
+
+        #expect(grid.model.columns.orderedNames == ["email", "id", "notes"])
+        #expect(grid.model.columns.dataIndex(atDisplayPosition: 0) == 2)
+        #expect(grid.model.columns.displayPosition(ofDataIndex: 2) == 0)
+        #expect(grid.model.store.columnLayout.columnOrder == ["email", "id", "notes"])
+        let emailIndex = try tableIndex(of: "email", in: grid)
+        let idIndex = try tableIndex(of: "id", in: grid)
+        #expect(emailIndex == 1)
+        #expect(grid.tableIndex(ofDisplayPosition: 0) == emailIndex)
+        #expect(grid.tableIndex(ofDisplayPosition: 1) == idIndex)
+    }
+
+    @Test("A swept block names the columns it crossed in the drawn order")
+    func sweptBlockNamesTheColumnsCrossed() throws {
+        let grid = HostedDataGrid(rows: Self.rows(Self.base))
+        defer { grid.close() }
+        try moveColumn(named: "email", toDisplayPosition: 0, in: grid)
+
+        let names = GridRect(rows: 0...0, columns: 0...1).columns.compactMap { grid.model.columns.column(at: $0)?.name }
+
+        #expect(names == ["email", "id"])
+    }
+
+    @Test("The presented count is the columns on screen")
+    func presentedCountIsTheColumnsOnScreen() {
+        let grid = HostedDataGrid(rows: Self.rows(Self.base))
+        defer { grid.close() }
+
+        #expect(grid.model.columns.count == 3)
+        #expect(grid.model.columns.count == grid.model.rows.columns.count)
+        #expect(grid.main.tableColumns.count == 4)
+    }
+
+    @Test("A hidden column leaves the display run and the table")
+    func hiddenColumnLeavesTheRun() {
+        let grid = HostedDataGrid(rows: Self.rows(Self.base))
+        defer { grid.close() }
+
+        grid.model.updateColumnLayout { $0.hiddenColumns = ["notes"] }
+
+        #expect(grid.model.columns.orderedNames == ["id", "email"])
+        #expect(grid.model.columns.count == 2)
+        #expect(grid.model.columns.dataIndex(atDisplayPosition: 1) == 2)
+        #expect(grid.model.columns.displayPosition(ofDataIndex: 1) == nil)
+        #expect(grid.tableColumn(named: "notes") == nil)
+        #expect(grid.main.tableColumns.count == 3)
+    }
+
+    // MARK: - Resolving a table column
+
+    @Test("Every table column resolves to its own data column by identity")
+    func everyColumnRoundTrips() throws {
+        let names = ["id", "name", "customer_id", "total"]
+        let grid = HostedDataGrid(rows: Self.rows(names))
+        defer { grid.close() }
+
+        for (dataIndex, name) in names.enumerated() {
+            let column = try #require(grid.tableColumn(named: name))
+            let id = try #require(grid.controller.main.columnID(of: column))
+            #expect(id == DataGridColumnID(name: name, occurrence: 0))
+            #expect(grid.model.columns.column(id: id)?.dataIndex == dataIndex)
+        }
+    }
+
+    @Test("A moved column still resolves to the data column it shows")
+    func movedColumnResolvesByIdentity() throws {
+        let grid = HostedDataGrid(rows: Self.rows(["id", "name", "customer_id"]))
+        defer { grid.close() }
+        let before = try tableIndex(of: "customer_id", in: grid)
+
+        try moveColumn(named: "customer_id", toDisplayPosition: 0, in: grid)
+
+        let after = try tableIndex(of: "customer_id", in: grid)
+        let id = try #require(grid.controller.main.columnID(of: grid.main.tableColumns[after]))
+        #expect(after != before)
+        #expect(grid.model.columns.column(id: id)?.dataIndex == 2)
+        #expect(grid.model.columns.displayPosition(of: id) == 0)
+    }
+
+    @Test("The row-number column is not a data column")
+    func rowNumberColumnIsNotData() {
+        let grid = HostedDataGrid(rows: Self.rows(["id", "name"]))
+        defer { grid.close() }
+        let pane = grid.controller.main
+
+        let chrome = grid.main.tableColumns.indices.filter { pane.slot(atTableIndex: $0, columns: grid.model.columns) == .rowNumber }
+
+        #expect(chrome == [0])
+        #expect(pane.columnID(of: grid.main.tableColumns[0]) == nil)
+        #expect(pane.isRowNumber(grid.main.tableColumns[0]))
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridColumnWidthCalculatorTests.swift b/apple/TableProTests/Views/DataGrid/DataGridColumnWidthCalculatorTests.swift
new file mode 100644
index 0000000000..d165c7e4c6
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridColumnWidthCalculatorTests.swift
@@ -0,0 +1,353 @@
+//
+//  DataGridColumnWidthCalculatorTests.swift
+//  TableProTests
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct DataGridColumnWidthCalculatorTests {
+    private func calculator(for rows: TableRows, revealsInvisibleCharacters: Bool = false) -> DataGridColumnWidthCalculator {
+        DataGridColumnWidthCalculator(
+            rows: rows,
+            databaseType: nil,
+            nullDisplayString: AppSettingsManager.shared.dataGrid.nullDisplay,
+            revealsInvisibleCharacters: revealsInvisibleCharacters,
+            fonts: ThemeEngine.shared.dataGridFonts
+        )
+    }
+
+    private func input(
+        _ name: String,
+        dataIndex: Int = 0,
+        in rows: TableRows,
+        accessory: DataGridCellAccessory = .none
+    ) -> DataGridColumnWidthCalculator.Input {
+        DataGridColumnWidthCalculator.Input(
+            column: DataGridColumn(
+                id: DataGridColumnID(name: name, occurrence: 0),
+                dataIndex: dataIndex,
+                type: dataIndex < rows.columnTypes.count ? rows.columnTypes[dataIndex] : nil,
+                comment: nil
+            ),
+            accessory: accessory,
+            displayFormat: nil
+        )
+    }
+
+    private func singleValueRows(
+        _ value: String,
+        columnType: ColumnType,
+        foreignKey: ForeignKeyInfo? = nil
+    ) -> TableRows {
+        TableRows.from(
+            queryRows: [[.text(value)]],
+            columns: ["x"],
+            columnTypes: [columnType],
+            columnForeignKeys: foreignKey.map { ["x": $0] } ?? [:],
+            foreignKeysFetched: foreignKey != nil
+        )
+    }
+
+    private func automaticWidth(of rows: TableRows, column: String = "x", accessory: DataGridCellAccessory = .none) -> CGFloat {
+        calculator(for: rows).automaticWidth(input(column, in: rows, accessory: accessory))
+    }
+
+    private func fittedWidth(
+        of rows: TableRows,
+        column: String = "data",
+        availableWidth: CGFloat,
+        accessory: DataGridCellAccessory = .none
+    ) -> CGFloat {
+        calculator(for: rows).fittedWidth(input(column, in: rows, accessory: accessory), availableWidth: availableWidth)
+    }
+
+    private func textRows(_ values: [String?], column: String = "data") -> TableRows {
+        TableRows.from(
+            queryRows: values.map { [PluginCellValue.fromOptional($0)] },
+            columns: [column],
+            columnTypes: [.text(rawType: nil)]
+        )
+    }
+
+    // MARK: - Automatic width
+
+    @Test("An automatic width stays within its bounds")
+    func automaticWidthWithinBounds() {
+        let rows = TestFixtures.makeTableRows(rowCount: 10)
+
+        for (index, column) in rows.columns.enumerated() {
+            let width = calculator(for: rows).automaticWidth(input(column, dataIndex: index, in: rows))
+            #expect(width >= 60)
+            #expect(width <= 800)
+        }
+    }
+
+    @Test("A header-only column gets a reasonable width")
+    func headerOnlyColumnWidth() {
+        let width = automaticWidth(of: textRows([], column: "username"), column: "username")
+
+        #expect(width >= 60)
+        #expect(width <= 800)
+    }
+
+    @Test("An empty header with no rows gets the minimum width")
+    func emptyHeaderNoRowsReturnsMinWidth() {
+        #expect(automaticWidth(of: textRows([], column: ""), column: "") >= 60)
+    }
+
+    @Test("Very long cell content caps the width at the maximum")
+    func longContentCapsAtMax() {
+        let rows = textRows([String(repeating: "X", count: 5_000)])
+
+        #expect(automaticWidth(of: rows, column: "data") <= 800)
+    }
+
+    @Test("Many columns still produce valid widths")
+    func manyColumnsProduceValidWidths() {
+        let columnCount = 60
+        let columns = (0..<columnCount).map { "col_\($0)" }
+        let values: [[PluginCellValue]] = (0..<100).map { row in
+            columns.map { PluginCellValue.text("\($0)_val_\(row)") }
+        }
+        let rows = TableRows.from(
+            queryRows: values,
+            columns: columns,
+            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columnCount)
+        )
+
+        for (index, column) in columns.enumerated() {
+            let width = calculator(for: rows).automaticWidth(input(column, dataIndex: index, in: rows))
+            #expect(width >= 60)
+            #expect(width <= 800)
+        }
+    }
+
+    @Test("NULL values do not break the width calculation")
+    func nullValuesAreSafe() {
+        let width = automaticWidth(of: textRows([nil, "hello", nil], column: "name"), column: "name")
+
+        #expect(width >= 60)
+        #expect(width <= 800)
+    }
+
+    @Test("An automatic width includes the exact trailing accessory footprint")
+    func automaticWidthIncludesTrailingAccessory() {
+        let value = String(repeating: "M", count: 20)
+        let plain = automaticWidth(of: singleValueRows(value, columnType: .text(rawType: "TEXT")))
+        let date = automaticWidth(of: singleValueRows(value, columnType: .date(rawType: "DATE")), accessory: .chevron)
+        let foreignKey = automaticWidth(
+            of: singleValueRows(
+                value,
+                columnType: .text(rawType: "TEXT"),
+                foreignKey: TestFixtures.makeForeignKeyInfo(column: "x")
+            ),
+            accessory: .foreignKey
+        )
+
+        #expect(date == plain + 16)
+        #expect(foreignKey == plain + 20)
+    }
+
+    @Test("An automatic width measures the displayed empty placeholder beside an accessory")
+    func automaticWidthMeasuresEmptyPlaceholder() {
+        let width = automaticWidth(of: singleValueRows("", columnType: .date(rawType: "DATE")), accessory: .chevron)
+        let displayedWidth = CGFloat((String(localized: "Empty") as NSString).length)
+            * ThemeEngine.shared.dataGridFonts.monoCharWidth
+
+        #expect(width - DataGridCellAccessory.chevron.measurementPadding >= displayedWidth)
+    }
+
+    @Test("An explicit fit measures a value the automatic sample steps over")
+    func explicitFitMeasuresValueTheSampleSkips() {
+        let short = String(repeating: "M", count: 10)
+        let long = String(repeating: "M", count: 60)
+        var values = Array(repeating: short, count: 1_000)
+        values[5] = long
+        let rows = TableRows.from(
+            queryRows: values.map { [PluginCellValue.text($0)] },
+            columns: ["title"],
+            columnTypes: [.text(rawType: "TEXT")]
+        )
+        let charWidth = ThemeEngine.shared.dataGridFonts.monoCharWidth
+
+        let automatic = automaticWidth(of: rows, column: "title")
+        let fitted = fittedWidth(of: rows, column: "title", availableWidth: 4_000)
+
+        #expect(automatic < CGFloat(long.count) * charWidth)
+        #expect(fitted >= CGFloat(long.count) * charWidth + DataGridCellAccessory.none.measurementPadding)
+    }
+
+    // MARK: - Column presentation
+
+    @Test("An enum column reserves its dropdown before the allowed values arrive")
+    func enumColumnReservesDropdownBeforeValuesArrive() {
+        let presentation = DataGridColumnPresentation.resolve(
+            columnType: .enumType(rawType: "ENUM", values: nil),
+            isForeignKey: false,
+            isDropdown: false,
+            isTypePicker: false,
+            isEnumOrSet: false,
+            isEditable: true
+        )
+
+        #expect(presentation.kind == .dropdown)
+        #expect(presentation.accessory == .chevron)
+    }
+
+    @Test("A SET column reserves its dropdown before the allowed values arrive")
+    func setColumnReservesDropdownBeforeValuesArrive() {
+        let presentation = DataGridColumnPresentation.resolve(
+            columnType: .set(rawType: "SET", values: nil),
+            isForeignKey: false,
+            isDropdown: false,
+            isTypePicker: false,
+            isEnumOrSet: false,
+            isEditable: true
+        )
+
+        #expect(presentation.kind == .dropdown)
+        #expect(presentation.accessory == .chevron)
+    }
+
+    @Test("A read-only enum column reserves nothing")
+    func readOnlyEnumColumnReservesNothing() {
+        let presentation = DataGridColumnPresentation.resolve(
+            columnType: .enumType(rawType: "ENUM", values: nil),
+            isForeignKey: false,
+            isDropdown: false,
+            isTypePicker: false,
+            isEnumOrSet: false,
+            isEditable: false
+        )
+
+        #expect(presentation.accessory == .none)
+    }
+
+    @Test("A checkbox column draws a checkbox whatever its type")
+    func checkboxColumnIsACheckbox() {
+        let presentation = DataGridColumnPresentation.resolve(
+            columnType: .boolean(rawType: "BOOL"),
+            isForeignKey: true,
+            isDropdown: false,
+            isTypePicker: false,
+            isEnumOrSet: false,
+            isEditable: true,
+            isCheckbox: true
+        )
+
+        #expect(presentation.kind == .checkbox)
+        #expect(presentation.accessory == .none)
+    }
+
+    // MARK: - Fit to content
+
+    @Test("A very long value is capped instead of stretching the column")
+    func longValueIsCapped() {
+        let width = fittedWidth(of: textRows([String(repeating: "X", count: 5_000)]), availableWidth: 1_600)
+
+        #expect(width == 800)
+    }
+
+    @Test("No column takes more than half the visible grid")
+    func capIsHalfTheVisibleGrid() {
+        let width = fittedWidth(of: textRows([String(repeating: "X", count: 5_000)]), availableWidth: 1_000)
+
+        #expect(width == 500)
+    }
+
+    @Test("The cap holds at 300 pt in a narrow window")
+    func capFloorsInNarrowWindow() {
+        let rows = textRows([String(repeating: "X", count: 5_000)])
+
+        #expect(fittedWidth(of: rows, availableWidth: 200) == 300)
+        #expect(fittedWidth(of: rows, availableWidth: 0) == 300)
+    }
+
+    @Test("Short values still size to their content, not to the cap")
+    func shortValuesSizeToContent() {
+        let width = fittedWidth(of: textRows(["ok", "fine"], column: "status"), column: "status", availableWidth: 1_600)
+
+        #expect(width >= 60)
+        #expect(width < 300)
+    }
+
+    @Test("A fitted width never exceeds the data column ceiling")
+    func fittedWidthStaysUnderColumnCeiling() {
+        let rows = textRows([String(repeating: "X", count: 20_000)])
+        for availableWidth in [CGFloat](stride(from: 0, through: 4_000, by: 250)) {
+            #expect(fittedWidth(of: rows, availableWidth: availableWidth) <= DataGridMetrics.dataColumnMaxWidth)
+        }
+    }
+
+    @Test("A long header alone does not stretch the column")
+    func longHeaderIsCapped() {
+        let column = String(repeating: "column_name_", count: 200)
+
+        #expect(fittedWidth(of: textRows([], column: column), column: column, availableWidth: 1_600) == 800)
+    }
+
+    @Test("Fit to content includes the exact trailing accessory footprint")
+    func fitToContentIncludesTrailingAccessory() {
+        let value = String(repeating: "M", count: 20)
+        let plain = singleValueRows(value, columnType: .text(rawType: "TEXT"))
+        let date = singleValueRows(value, columnType: .date(rawType: "DATE"))
+        let foreignKey = singleValueRows(
+            value,
+            columnType: .text(rawType: "TEXT"),
+            foreignKey: TestFixtures.makeForeignKeyInfo(column: "x")
+        )
+
+        let plainWidth = fittedWidth(of: plain, column: "x", availableWidth: 1_600)
+        #expect(fittedWidth(of: date, column: "x", availableWidth: 1_600, accessory: .chevron) == plainWidth + 16)
+        #expect(fittedWidth(of: foreignKey, column: "x", availableWidth: 1_600, accessory: .foreignKey) == plainWidth + 20)
+    }
+
+    @Test("Fitting every column shares one budget, so a wide result is still measured whole")
+    func fittingManyColumnsStillReadsTheLongValue() {
+        let short = String(repeating: "M", count: 10)
+        let long = String(repeating: "M", count: 60)
+        var values = Array(repeating: short, count: 1_000)
+        values[5] = long
+        let rows = TableRows.from(
+            queryRows: values.map { [PluginCellValue.text($0)] },
+            columns: ["title"],
+            columnTypes: [.text(rawType: "TEXT")]
+        )
+        let charWidth = ThemeEngine.shared.dataGridFonts.monoCharWidth
+
+        let fitted = calculator(for: rows).fittedWidth(
+            input("title", in: rows),
+            availableWidth: 4_000,
+            fittedColumnCount: 100
+        )
+
+        #expect(fitted >= CGFloat(long.count) * charWidth)
+    }
+
+    // MARK: - Change tracking
+
+    // A reload would discard the very edit the user just made.
+    @Test("Recording an edit does not ask the grid to reload, discarding does")
+    func recordingAnEditDoesNotAskTheGridToReload() {
+        let manager = DataChangeManager()
+        let initialVersion = manager.reloadVersion
+
+        manager.recordCellChange(
+            rowID: .existing(0),
+            columnIndex: 0,
+            columnName: "name",
+            oldValue: "old",
+            newValue: "new"
+        )
+
+        #expect(manager.reloadVersion == initialVersion)
+
+        manager.discardChanges()
+
+        #expect(manager.reloadVersion == initialVersion + 1)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridColumnWidthTests.swift b/apple/TableProTests/Views/DataGrid/DataGridColumnWidthTests.swift
new file mode 100644
index 0000000000..36f4aac059
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridColumnWidthTests.swift
@@ -0,0 +1,326 @@
+//
+//  DataGridColumnWidthTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct DataGridColumnWidthTests {
+    private static let longValue = String(repeating: "M", count: 20)
+
+    private static func rows(
+        _ columns: [String],
+        types: [ColumnType]? = nil,
+        value: String = longValue,
+        rowCount: Int = 1,
+        foreignKeys: [String: ForeignKeyInfo] = [:]
+    ) -> TableRows {
+        TableRows.from(
+            queryRows: (0..<rowCount).map { _ in columns.map { _ in PluginCellValue.text(value) } },
+            columns: columns,
+            columnTypes: types ?? Array(repeating: .text(rawType: "TEXT"), count: columns.count),
+            columnForeignKeys: foreignKeys,
+            foreignKeysFetched: !foreignKeys.isEmpty
+        )
+    }
+
+    private static func editable() -> DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        return configuration
+    }
+
+    // A drag on the divider: AppKit sets the width, then reports the resize.
+    private func resize(_ column: NSTableColumn, to width: CGFloat, in grid: HostedDataGrid) {
+        let oldWidth = column.width
+        column.width = width
+        grid.controller.tableViewColumnDidResize(Notification(
+            name: NSTableView.columnDidResizeNotification,
+            object: grid.main,
+            userInfo: ["NSTableColumn": column, "NSOldWidth": oldWidth]
+        ))
+    }
+
+    private func width(of name: String, in grid: HostedDataGrid) throws -> CGFloat {
+        try #require(grid.tableColumn(named: name)).width
+    }
+
+    private func applyMetadata(
+        to grid: HostedDataGrid,
+        foreignKeys: [String: ForeignKeyInfo]? = nil,
+        enumValues: [String: [String]]? = nil
+    ) {
+        let delta = grid.owner.tableRows.updateDisplayMetadata(
+            columnForeignKeys: foreignKeys,
+            columnEnumValues: enumValues
+        )
+        grid.model.apply(delta)
+    }
+
+    // MARK: - Ownership
+
+    @Test("Automatic widths stay out of the saved layout")
+    func automaticWidthsStayOutOfTheLayout() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+
+        #expect(grid.model.store.columnLayout.columnWidths.isEmpty)
+        #expect(grid.model.store.columnLayout.columnContentWidths == nil)
+    }
+
+    @Test("A resize the reader makes is saved as a width they own")
+    func userResizeTakesOwnership() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let column = try #require(grid.tableColumn(named: "name"))
+        let target = column.width + 60
+
+        resize(column, to: target, in: grid)
+
+        let layout = grid.model.store.columnLayout
+        #expect(layout.columnWidths == ["name": target])
+        #expect(layout.columnContentWidths == ["name": target])
+        #expect(try width(of: "name", in: grid) == target)
+    }
+
+    @Test("A resize of the row-number column saves nothing")
+    func rowNumberResizeIsIgnored() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let rowNumbers = try #require(grid.main.tableColumns.first { $0.identifier == DataGridPane.rowNumberIdentifier })
+
+        grid.controller.tableViewColumnDidResize(Notification(
+            name: NSTableView.columnDidResizeNotification,
+            object: grid.main,
+            userInfo: ["NSTableColumn": rowNumbers, "NSOldWidth": rowNumbers.width - 10]
+        ))
+
+        #expect(grid.model.store.columnLayout.columnWidths.isEmpty)
+    }
+
+    @Test("A new result measured by the grid takes no ownership")
+    func newResultMeasuresWithoutOwnership() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+
+        grid.owner.tableRows = Self.rows(["code", "label"])
+        grid.model.reloadRows()
+
+        #expect(grid.model.store.columnLayout.columnWidths.isEmpty)
+        #expect(grid.tableColumn(named: "code") != nil)
+    }
+
+    @Test("Hiding, showing and moving columns keeps the widths the reader sees")
+    func widthsSurviveHideShowAndMove() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let nameWidth = try width(of: "name", in: grid)
+        let idWidth = try width(of: "id", in: grid)
+
+        grid.model.updateColumnLayout { $0.hiddenColumns = ["id"] }
+        #expect(grid.tableColumn(named: "id") == nil)
+        #expect(try width(of: "name", in: grid) == nameWidth)
+
+        grid.model.updateColumnLayout { $0.hiddenColumns = [] }
+        grid.model.updateColumnLayout { $0.columnOrder = ["age", "name", "id"] }
+
+        #expect(try width(of: "name", in: grid) == nameWidth)
+        #expect(try width(of: "id", in: grid) == idWidth)
+        #expect(grid.model.store.columnLayout.columnWidths.isEmpty)
+    }
+
+    @Test("A reload over the same columns keeps the widths it measured")
+    func sameColumnsKeepTheirWidths() throws {
+        let grid = HostedDataGrid(rows: Self.rows(["note"], value: "short"))
+        defer { grid.close() }
+        let measured = try width(of: "note", in: grid)
+
+        grid.owner.tableRows = Self.rows(["note"], value: String(repeating: "W", count: 45))
+        grid.model.reloadRows()
+
+        #expect(try width(of: "note", in: grid) == measured)
+    }
+
+    @Test("Columns whose rows land after them are measured again once the rows arrive")
+    func rowsArrivingLateMeasureAgain() throws {
+        let grid = HostedDataGrid(rows: Self.rows(["note"], rowCount: 0))
+        defer { grid.close() }
+        let headingOnly = try width(of: "note", in: grid)
+
+        grid.owner.tableRows = Self.rows(["note"], value: String(repeating: "W", count: 45))
+        grid.model.reloadRows()
+
+        #expect(try width(of: "note", in: grid) > headingOnly)
+    }
+
+    @Test("Reset gives a column the reader sized back its automatic width")
+    func resetReturnsToAutomaticWidth() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let column = try #require(grid.tableColumn(named: "name"))
+        let automatic = column.width
+        resize(column, to: automatic + 80, in: grid)
+        try #require(grid.model.store.columnLayout.columnWidths["name"] == automatic + 80)
+
+        grid.model.updateColumnLayout { $0.resetGeometry() }
+
+        #expect(grid.model.store.columnLayout.columnWidths.isEmpty)
+        #expect(try width(of: "name", in: grid) == automatic)
+    }
+
+    // MARK: - Saved widths
+
+    @Test("A width the reader set is applied as saved, before and after its accessory is known")
+    func ownedWidthIgnoresTheAccessory() throws {
+        var layout = ColumnLayoutState()
+        layout.columnWidths = ["parent_id": 200]
+        layout.columnContentWidths = ["parent_id": 200]
+        let grid = HostedDataGrid(
+            rows: Self.rows(["parent_id"]),
+            store: InMemoryDataGridStateStore(columnLayout: layout)
+        )
+        defer { grid.close() }
+        #expect(try width(of: "parent_id", in: grid) == 200)
+
+        applyMetadata(to: grid, foreignKeys: ["parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id")])
+
+        #expect(grid.controller.presenter.presentation(forDataIndex: 0).accessory == .foreignKey)
+        #expect(try width(of: "parent_id", in: grid) == 200)
+
+        applyMetadata(to: grid, foreignKeys: [:])
+
+        #expect(try width(of: "parent_id", in: grid) == 200)
+        #expect(grid.model.store.columnLayout.columnWidths == ["parent_id": 200])
+    }
+
+    // A layout saved before widths recorded who set them cannot tell a measured width from a dragged one.
+    @Test("A legacy width widens when its column's accessory arrives after the restore")
+    func legacyWidthWidensForALateAccessory() throws {
+        var layout = ColumnLayoutState()
+        layout.columnWidths = ["parent_id": 168, "plain": 210]
+        let grid = HostedDataGrid(
+            rows: Self.rows(["parent_id", "plain"]),
+            store: InMemoryDataGridStateStore(columnLayout: layout)
+        )
+        defer { grid.close() }
+        #expect(try width(of: "parent_id", in: grid) == 168)
+
+        applyMetadata(to: grid, foreignKeys: ["parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id")])
+
+        #expect(grid.controller.presenter.presentation(forDataIndex: 0).accessory == .foreignKey)
+        #expect(try width(of: "parent_id", in: grid) > 168)
+        #expect(try width(of: "plain", in: grid) == 210)
+    }
+
+    @Test("Columns that share a name take the one width saved for it")
+    func duplicateNamesShareTheSavedWidth() {
+        var layout = ColumnLayoutState()
+        layout.columnWidths = ["result": 160]
+        let grid = HostedDataGrid(
+            rows: Self.rows(["result", "result"], types: [.text(rawType: "TEXT"), .date(rawType: "DATE")]),
+            store: InMemoryDataGridStateStore(columnLayout: layout)
+        )
+        defer { grid.close() }
+
+        let widths = grid.main.tableColumns
+            .filter { grid.controller.main.columnID(of: $0)?.name == "result" }
+            .map { $0.width }
+        #expect(widths == [160, 160])
+    }
+
+    // MARK: - Accessories arriving late
+
+    @Test("Late foreign key metadata widens an automatic column and leaves a sized one alone")
+    func lateForeignKeyWidensAutomaticColumnOnly() throws {
+        let grid = HostedDataGrid(rows: Self.rows(["id", "parent_id"]))
+        defer { grid.close() }
+        let idColumn = try #require(grid.tableColumn(named: "id"))
+        resize(idColumn, to: 75, in: grid)
+        let before = try width(of: "parent_id", in: grid)
+
+        applyMetadata(to: grid, foreignKeys: ["parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id")])
+
+        let widened = try width(of: "parent_id", in: grid)
+        #expect(grid.controller.presenter.presentation(forDataIndex: 1).accessory == .foreignKey)
+        #expect(try width(of: "id", in: grid) == 75)
+        #expect(widened > before)
+        #expect(
+            DataGridCellAccessory.foreignKey.availableTextWidth(in: NSRect(x: 0, y: 0, width: widened, height: 24))
+                >= CGFloat(Self.longValue.count) * ThemeEngine.shared.dataGridFonts.monoCharWidth
+        )
+
+        applyMetadata(to: grid, foreignKeys: [:])
+
+        #expect(try width(of: "id", in: grid) == 75)
+        #expect(try width(of: "parent_id", in: grid) == widened)
+        #expect(grid.model.store.columnLayout.columnWidths == ["id": 75])
+    }
+
+    @Test("Late enum values widen the automatic column they appear in")
+    func lateEnumValuesWidenTheirColumn() throws {
+        let grid = HostedDataGrid(rows: Self.rows(["status"]), configuration: Self.editable())
+        defer { grid.close() }
+        let before = try width(of: "status", in: grid)
+
+        applyMetadata(to: grid, enumValues: ["status": ["open", "closed"]])
+
+        let widened = try width(of: "status", in: grid)
+        #expect(grid.controller.presenter.presentation(forDataIndex: 0).kind == .dropdown)
+        #expect(widened > before)
+        #expect(
+            DataGridCellAccessory.chevron.availableTextWidth(in: NSRect(x: 0, y: 0, width: widened, height: 24))
+                >= CGFloat(Self.longValue.count) * ThemeEngine.shared.dataGridFonts.monoCharWidth
+        )
+
+        applyMetadata(to: grid, enumValues: [:])
+
+        #expect(grid.controller.presenter.presentation(forDataIndex: 0).kind == .text)
+        #expect(try width(of: "status", in: grid) == widened)
+    }
+
+    @Test("A column that loses its accessory keeps the width the reader gave it")
+    func losingAnAccessoryKeepsTheWidth() throws {
+        let grid = HostedDataGrid(
+            rows: Self.rows(["created_at"], types: [.date(rawType: "DATE")], value: "2026-08-17"),
+            configuration: Self.editable()
+        )
+        defer { grid.close() }
+        #expect(grid.controller.presenter.presentation(forDataIndex: 0).accessory == .chevron)
+        let column = try #require(grid.tableColumn(named: "created_at"))
+        resize(column, to: 176, in: grid)
+
+        grid.model.configuration.isEditable = false
+
+        #expect(grid.controller.presenter.presentation(forDataIndex: 0).accessory == .none)
+        #expect(try width(of: "created_at", in: grid) == 176)
+        #expect(grid.model.store.columnLayout.columnWidths == ["created_at": 176])
+    }
+
+    // MARK: - Size to fit
+
+    @Test("A divider double-click measures each column with its own accessory")
+    func dividerFitCountsTheAccessory() throws {
+        let rows = Self.rows(
+            ["plain", "created_at", "parent_id"],
+            types: [.text(rawType: "TEXT"), .date(rawType: "DATE"), .text(rawType: "TEXT")],
+            foreignKeys: ["parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id")]
+        )
+        let grid = HostedDataGrid(rows: rows, configuration: Self.editable())
+        defer { grid.close() }
+
+        func fitted(_ position: Int) throws -> CGFloat {
+            let index = try #require(grid.tableIndex(ofDisplayPosition: position))
+            return grid.controller.tableView(grid.main, sizeToFitWidthOfColumn: index)
+        }
+        let plain = try fitted(0)
+        let date = try fitted(1)
+        let foreignKey = try fitted(2)
+
+        #expect(date == plain + DataGridCellAccessory.chevron.reservedTrailingWidth)
+        #expect(foreignKey == plain + DataGridCellAccessory.foreignKey.reservedTrailingWidth)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridCommandTests.swift b/apple/TableProTests/Views/DataGrid/DataGridCommandTests.swift
new file mode 100644
index 0000000000..f2f53cd346
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridCommandTests.swift
@@ -0,0 +1,1091 @@
+//
+//  DataGridCommandTests.swift
+//  TableProTests
+//
+
+import AppKit
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+// The grid's owner as the commands see it: it records every request and writes each commit into its rows
+// and change manager, the way the data tab does, then reports the change back.
+@MainActor
+final class CommandGridOwner: DataGridDataSource, DataGridActions {
+    var tableRows: TableRows
+    let changeManager: DataChangeManager
+    let changeState: AnyChangeManager
+    weak var model: DataGridModel?
+
+    var exporter: RecordingSQLExporter?
+    var copiesRowsItself = false
+    var runsSetCellsToValue = false
+    var pastesRows = false
+    // The values a load fills in; nil refuses the load.
+    var loadableValues: [RowID: [Int: PluginCellValue]]?
+    // Holds each load until finishLoads(), the way a page fetch answers later.
+    var defersLoads = false
+    private var pendingLoads: [@MainActor () -> Void] = []
+    // Titles rather than items: a menu item belongs to one menu, and every menu asks again.
+    var rowMenuTitles: [String] = []
+    var cellMenuTitles: [String] = []
+
+    private(set) var commits: [(edits: [DataGridResolvedEdit], actionName: String)] = []
+    private(set) var rowCopies: [[RowID]] = []
+    private(set) var deletions: [[RowID]] = []
+    private(set) var undoneDeletions: [[RowID]] = []
+    private(set) var duplications: [[RowID]] = []
+    private(set) var rowPastes = 0
+    private(set) var addRowRequests = 0
+    private(set) var setCellsToValueRequests: [[(rowID: RowID, column: String)]] = []
+    private(set) var loadRequests: [[RowID]] = []
+    private(set) var navigations: [(value: String, table: String, intent: ReferenceOpenIntent)] = []
+    private(set) var hiddenColumns: [String] = []
+    private(set) var showAllColumnsRequests = 0
+    private(set) var rowsShownAsJSON: [[RowID]] = []
+    private(set) var displayOrderRequests = 0
+
+    init(_ tableRows: TableRows, changeManager: DataChangeManager = DataChangeManager()) {
+        self.tableRows = tableRows
+        self.changeManager = changeManager
+        changeState = AnyChangeManager(changeManager)
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        commits.append((edits, actionName))
+        var changed: Set<CellPosition> = []
+        for edit in edits {
+            guard let index = tableRows.index(of: edit.rowID) else { continue }
+            _ = tableRows.edit(row: index, column: edit.dataIndex, value: edit.newValue, isAbsent: edit.absence.isAbsent)
+            changeState.recordCellChange(
+                rowID: edit.rowID,
+                columnIndex: edit.dataIndex,
+                columnName: edit.columnName,
+                oldValue: edit.oldValue,
+                newValue: edit.newValue,
+                originalRow: edit.originalRow,
+                absence: edit.absence,
+                isExpression: edit.isExpression
+            )
+            changed.insert(CellPosition(row: index, column: edit.dataIndex))
+        }
+        model?.apply(.cellsChanged(changed))
+        return true
+    }
+
+    func gridDeleteRows(_ rowIDs: [RowID]) {
+        deletions.append(rowIDs)
+    }
+
+    func gridCopyRows(_ rowIDs: [RowID]) -> Bool {
+        guard copiesRowsItself else { return false }
+        rowCopies.append(rowIDs)
+        return true
+    }
+
+    func gridSetCellsToValue(_ cells: [(rowID: RowID, column: DataGridColumn)]) -> Bool {
+        guard runsSetCellsToValue else { return false }
+        setCellsToValueRequests.append(cells.map { (rowID: $0.rowID, column: $0.column.name) })
+        return true
+    }
+
+    func gridUndoDelete(_ rowIDs: [RowID]) {
+        undoneDeletions.append(rowIDs)
+    }
+
+    func gridAddRow() {
+        addRowRequests += 1
+    }
+
+    func gridDuplicateRows(_ rowIDs: [RowID]) {
+        duplications.append(rowIDs)
+    }
+
+    func gridCanPasteRows() -> Bool {
+        pastesRows
+    }
+
+    func gridPasteRows() {
+        rowPastes += 1
+    }
+
+    func gridConfirmDisplayOrderChange(then apply: @escaping @MainActor () -> Void) {
+        displayOrderRequests += 1
+        apply()
+    }
+
+    func gridHideColumn(_ column: DataGridColumn) {
+        hiddenColumns.append(column.name)
+    }
+
+    func gridShowAllColumns() {
+        showAllColumnsRequests += 1
+    }
+
+    func gridNavigateForeignKey(value: String, info: ForeignKeyInfo, intent: ReferenceOpenIntent) {
+        navigations.append((value, info.referencedTable, intent))
+    }
+
+    func gridShowRowsAsJSON(_ rowIDs: [RowID]) {
+        rowsShownAsJSON.append(rowIDs)
+    }
+
+    func gridLoadUnloadedValues(rowIDs: [RowID], columns: IndexSet?, completion: @escaping @MainActor (Bool) -> Void) {
+        loadRequests.append(rowIDs)
+        let load = { @MainActor [self] in
+            guard let loadableValues else {
+                completion(false)
+                return
+            }
+            let delta = tableRows.fillUnloaded(loadableValues)
+            model?.apply(delta)
+            completion(true)
+        }
+        guard defersLoads else {
+            load()
+            return
+        }
+        pendingLoads.append(load)
+    }
+
+    func finishLoads() {
+        let loads = pendingLoads
+        pendingLoads.removeAll()
+        loads.forEach { $0() }
+    }
+
+    var gridSQLExporter: (any DataGridSQLExporting)? { exporter }
+
+    func gridRowMenuItems(for rowIDs: [RowID], clickedRow: RowID) -> [NSMenuItem] {
+        rowMenuTitles.map { NSMenuItem(title: $0, action: nil, keyEquivalent: "") }
+    }
+
+    func gridCellMenuItems(for rowID: RowID, column: DataGridColumn) -> [NSMenuItem] {
+        cellMenuTitles.map { NSMenuItem(title: $0, action: nil, keyEquivalent: "") }
+    }
+
+    // The value the last commit wrote into a cell, and whether it was staged as SQL.
+    func staged(_ row: Int, _ column: Int) -> (value: PluginCellValue, isExpression: Bool)? {
+        for commit in commits.reversed() {
+            if let edit = commit.edits.last(where: { $0.rowID == .existing(row) && $0.dataIndex == column }) {
+                return (edit.newValue, edit.isExpression)
+            }
+        }
+        return nil
+    }
+
+    var editCount: Int { commits.reduce(0) { $0 + $1.edits.count } }
+}
+
+// Hands back what it was given, so a test sees which rows and columns the grid asked statements for.
+@MainActor
+final class RecordingSQLExporter: DataGridSQLExporting {
+    var allowsInsert = true
+    var allowsUpdate = true
+    private(set) var requests: [(update: Bool, rowIDs: [RowID], columns: [String])] = []
+
+    func canCopyAsInsert(_ rows: TableRows) -> Bool { allowsInsert }
+    func canCopyAsUpdate(_ rows: TableRows) -> Bool { allowsUpdate }
+
+    func insertStatements(for rowIDs: [RowID], columns: [DataGridColumn], in rows: TableRows) -> String? {
+        requests.append((false, rowIDs, columns.map { $0.name }))
+        return "INSERT \(rowIDs.count)"
+    }
+
+    func updateStatements(for rowIDs: [RowID], columns: [DataGridColumn], in rows: TableRows) -> String? {
+        requests.append((true, rowIDs, columns.map { $0.name }))
+        return "UPDATE \(rowIDs.count)"
+    }
+
+    func inClause(values: [PluginCellValue], column: DataGridColumn) -> String? {
+        "IN " + values.compactMap { $0.asText }.joined(separator: ",")
+    }
+}
+
+// A model, its owner and a controller that has not been put in a window; host() mounts it when a test needs one.
+@MainActor
+final class CommandGrid {
+    let owner: CommandGridOwner
+    let model: DataGridModel
+    let controller: DataGridViewController
+    private(set) var window: NSWindow?
+
+    init(
+        _ rows: TableRows,
+        configuration: DataGridConfiguration = CommandGrid.editable(),
+        changeManager: DataChangeManager = DataChangeManager(),
+        selectionSummary: SelectionSummaryState? = nil
+    ) {
+        owner = CommandGridOwner(rows, changeManager: changeManager)
+        model = DataGridModel(configuration: configuration, selectionSummary: selectionSummary)
+        model.dataSource = owner
+        model.actions = owner
+        owner.model = model
+        model.reloadRows()
+        controller = DataGridViewController(model: model)
+    }
+
+    static func editable(
+        databaseType: DatabaseType? = .postgresql,
+        commands: Set<DataGridCommand> = [.deleteRows, .duplicateRows, .undoDelete, .pasteRows, .loadUnloadedValues],
+        appliesRowCopyFormat: Bool = true
+    ) -> DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        configuration.appliesRowCopyFormat = appliesRowCopyFormat
+        configuration.commands = commands
+        configuration.traits = DataGridEngineTraits(databaseType: databaseType, cellWriterSupport: .host)
+        return configuration
+    }
+
+    static func readOnly(appliesRowCopyFormat: Bool = true) -> DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.appliesRowCopyFormat = appliesRowCopyFormat
+        return configuration
+    }
+
+    var commands: DataGridCommands { controller.gridCommands }
+
+    func host(size: NSSize = NSSize(width: 900, height: 400)) {
+        guard window == nil else { return }
+        let window = NSWindow(
+            contentRect: NSRect(origin: .zero, size: size),
+            styleMask: [.titled, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        let content = NSView(frame: NSRect(origin: .zero, size: size))
+        window.contentView = content
+        controller.view.frame = content.bounds
+        controller.view.autoresizingMask = [.width, .height]
+        content.addSubview(controller.view)
+        content.layoutSubtreeIfNeeded()
+        controller.container.layoutSubtreeIfNeeded()
+        self.window = window
+    }
+
+    func close() {
+        guard let window else { return }
+        controller.dismantle()
+        window.orderOut(nil)
+        self.window = nil
+    }
+
+    func select(
+        rows: ClosedRange<Int>,
+        columns: ClosedRange<Int>,
+        active: GridCoord? = nil,
+        mode: GridSelection.Mode = .cells
+    ) {
+        let anchor = GridCoord(row: rows.lowerBound, displayColumn: columns.lowerBound)
+        model.setSelection(GridSelection(
+            rectangles: [GridRect(rows: rows, columns: columns)],
+            activeCell: active ?? GridCoord(row: rows.upperBound, displayColumn: columns.upperBound),
+            anchor: anchor,
+            mode: mode
+        ))
+    }
+
+    func selectCell(_ row: Int, _ column: Int) {
+        model.setSelection(GridSelectionReducer.single(GridCoord(row: row, displayColumn: column)))
+    }
+
+    // What a row-number click leaves: whole rows picked, the cursor kept on a column.
+    func selectRows(_ rows: ClosedRange<Int>, activeColumn: Int = 0) {
+        select(
+            rows: rows,
+            columns: 0...(model.columns.count - 1),
+            active: GridCoord(row: rows.upperBound, displayColumn: activeColumn),
+            mode: .rows
+        )
+    }
+
+    // The scope a right-click builds, carried by the item the way the menu carries it.
+    func contextItem(row: Int, displayColumn: Int?, action: Selector? = nil) -> NSMenuItem {
+        let scope = DataGridCommandScope.contextMenu(
+            selection: model.selection,
+            row: row,
+            displayColumn: displayColumn,
+            columnCount: model.columns.count
+        )
+        let item = NSMenuItem(title: "", action: action, keyEquivalent: "")
+        item.representedObject = DataGridMenuContext(scope, model: model)
+        return item
+    }
+
+    func rowMenu(row: Int, displayColumn: Int?) -> NSMenu? {
+        controller.rowMenu(forRow: row, displayColumn: displayColumn, in: .main)
+    }
+
+    func headerMenu(_ name: String) -> NSMenu? {
+        guard let column = model.columns.columns.first(where: { $0.name == name }) else { return nil }
+        return controller.headerMenu(for: column)
+    }
+
+    func isEnabled(_ action: Selector, sender: NSMenuItem? = nil) -> Bool {
+        let item = sender ?? NSMenuItem(title: "", action: action, keyEquivalent: "")
+        item.action = action
+        return controller.validateMenuItem(item)
+    }
+
+    func perform(_ item: NSMenuItem) {
+        guard let action = item.action else { return }
+        _ = NSApp.sendAction(action, to: item.target ?? controller, from: item)
+    }
+}
+
+@MainActor
+enum CommandRows {
+    static let people = TableRows.from(
+        queryRows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")], [.text("3"), .text("Carol")]],
+        columns: ["id", "name"],
+        columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
+    )
+
+    static func titles(_ menu: NSMenu?) -> [String] {
+        menu?.items.map { $0.isSeparatorItem ? "-" : $0.title } ?? []
+    }
+
+    static func item(_ title: String, in menu: NSMenu?) -> NSMenuItem? {
+        menu?.items.first { $0.title == title }
+    }
+}
+
+// MARK: - Row menu
+
+@MainActor
+struct DataGridRowMenuTests {
+    @Test("A right-click outside the selection acts on the clicked cell and leaves the selection where it was")
+    func clickOutsideTheSelectionTargetsTheClickedCell() {
+        let grid = CommandGrid(CommandRows.people)
+        grid.select(rows: 0...1, columns: 0...0)
+        let before = grid.model.selection
+
+        let outside = DataGridCommandScope.contextMenu(selection: before, row: 2, displayColumn: 1, columnCount: 2)
+        let inside = DataGridCommandScope.contextMenu(selection: before, row: 1, displayColumn: 0, columnCount: 2)
+
+        let clicked = grid.commands.cells(outside)
+        #expect(clicked.map { $0.rowID } == [.existing(2)])
+        #expect(clicked.map { $0.column.name } == ["name"])
+        #expect(grid.commands.rowIDs(inside) == [.existing(0), .existing(1)])
+        _ = grid.rowMenu(row: 2, displayColumn: 1)
+        #expect(grid.model.selection == before)
+    }
+
+    @Test("A deleted row's menu offers only Undo Delete, which hands the row back to its owner")
+    func deletedRowOffersUndoDelete() throws {
+        let manager = DataChangeManager()
+        let grid = CommandGrid(CommandRows.people, changeManager: manager)
+        manager.recordRowDeletion(rowID: .existing(1), originalRow: [.text("2"), .text("Bob")])
+
+        let menu = grid.rowMenu(row: 1, displayColumn: 1)
+
+        #expect(CommandRows.titles(menu) == [String(localized: "Undo Delete")])
+        grid.perform(try #require(menu?.items.first))
+        #expect(grid.owner.undoneDeletions == [[.existing(1)]])
+    }
+
+    @Test("Commands the grid does not offer are left out of the menu")
+    func unofferedCommandsAreHidden() {
+        let grid = CommandGrid(CommandRows.people, configuration: CommandGrid.readOnly())
+        let titles = CommandRows.titles(grid.rowMenu(row: 0, displayColumn: 1))
+
+        #expect(titles.contains(String(localized: "Copy")))
+        #expect(!titles.contains(String(localized: "Paste")))
+        #expect(!titles.contains(String(localized: "Delete")))
+        #expect(!titles.contains(String(localized: "Duplicate")))
+        #expect(!titles.contains(String(localized: "Export Results…")))
+        #expect(!titles.contains(String(localized: "Set Value")))
+    }
+
+    @Test("The row numbers get the row items only")
+    func rowNumberMenuHasRowItems() {
+        var configuration = CommandGrid.editable()
+        configuration.commands.formUnion([.exportResults, .showRowsAsJSON])
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+        let titles = CommandRows.titles(grid.rowMenu(row: 0, displayColumn: nil))
+
+        #expect(titles.contains(String(localized: "Copy")))
+        #expect(titles.contains(String(localized: "Copy as")))
+        #expect(titles.contains(String(localized: "Show Row as JSON")))
+        #expect(titles.contains(String(localized: "Delete")))
+        #expect(!titles.contains(String(localized: "Copy Cell Value")))
+        #expect(!titles.contains(String(localized: "Set Value")))
+    }
+
+    @Test("Owner items join the menu, row items for the rows and cell items for the clicked cell")
+    func ownerItemsJoinTheMenu() {
+        let grid = CommandGrid(CommandRows.people)
+        grid.owner.rowMenuTitles = ["Insert Document…"]
+        grid.owner.cellMenuTitles = ["Filter by Value"]
+
+        let cellTitles = CommandRows.titles(grid.rowMenu(row: 0, displayColumn: 1))
+        let rowTitles = CommandRows.titles(grid.rowMenu(row: 0, displayColumn: nil))
+
+        #expect(cellTitles.contains("Insert Document…"))
+        #expect(cellTitles.contains("Filter by Value"))
+        #expect(rowTitles.contains("Insert Document…"))
+        #expect(!rowTitles.contains("Filter by Value"))
+    }
+
+    @Test("Delete and Duplicate from the menu take every row the selection touches")
+    func rowCommandsTakeTheSelectedRows() throws {
+        let grid = CommandGrid(CommandRows.people)
+        grid.select(rows: 0...1, columns: 0...1)
+        let menu = grid.rowMenu(row: 1, displayColumn: 0)
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Delete"), in: menu)))
+        grid.perform(try #require(CommandRows.item(String(localized: "Duplicate"), in: menu)))
+
+        #expect(grid.owner.deletions == [[.existing(0), .existing(1)]])
+        #expect(grid.owner.duplications == [[.existing(0), .existing(1)]])
+    }
+
+    @Test("Delete and Forward Delete mark the rows a range touches; a grid that deletes nothing asks nothing")
+    func deleteKeyDeletesTheRangeRows() {
+        let grid = CommandGrid(CommandRows.people)
+        grid.select(rows: 1...2, columns: 1...1)
+
+        grid.controller.performDeleteCommand()
+
+        #expect(grid.owner.deletions == [[.existing(1), .existing(2)]])
+
+        let readOnly = CommandGrid(CommandRows.people, configuration: CommandGrid.readOnly())
+        readOnly.select(rows: 0...0, columns: 0...1)
+        readOnly.controller.performDeleteCommand()
+        #expect(readOnly.owner.deletions.isEmpty)
+        #expect(!readOnly.isEnabled(#selector(DataGridViewController.delete(_:))))
+    }
+
+    @Test("Show Row as JSON hands the owner the rows the menu acts on")
+    func showRowAsJSONHandsTheRows() throws {
+        var configuration = CommandGrid.editable()
+        configuration.commands.insert(.showRowsAsJSON)
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+
+        let menu = grid.rowMenu(row: 2, displayColumn: 1)
+        grid.perform(try #require(CommandRows.item(String(localized: "Show Row as JSON"), in: menu)))
+
+        #expect(grid.owner.rowsShownAsJSON == [[.existing(2)]])
+    }
+
+    @Test("A double-click below the last row adds one only where the grid offers it")
+    func doubleClickBelowRowsAddsARow() {
+        var configuration = CommandGrid.editable()
+        configuration.commands.insert(.addRow)
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+        grid.controller.handleDoubleClickBelowRows()
+        #expect(grid.owner.addRowRequests == 1)
+
+        let without = CommandGrid(CommandRows.people)
+        without.controller.handleDoubleClickBelowRows()
+        #expect(without.owner.addRowRequests == 0)
+    }
+
+    // MARK: - Foreign keys
+
+    private static let orders = TableRows.from(
+        queryRows: [[.text("10"), .text("7")], [.text("11"), .null]],
+        columns: ["id", "customer_id"],
+        columnTypes: [.integer(rawType: "INT"), .integer(rawType: "INT")],
+        columnForeignKeys: [
+            "customer_id": ForeignKeyInfo(name: "fk", column: "customer_id", referencedTable: "customers", referencedColumn: "id")
+        ]
+    )
+
+    @Test("A key with a value offers to choose, preview and follow its row; following hands the value to the owner")
+    func foreignKeyItems() throws {
+        var configuration = CommandGrid.editable()
+        configuration.commands.insert(.navigateForeignKey)
+        let grid = CommandGrid(Self.orders, configuration: configuration)
+
+        let menu = grid.rowMenu(row: 0, displayColumn: 1)
+        let titles = CommandRows.titles(menu)
+        #expect(titles.contains(String(format: String(localized: "Choose %@ Row…"), "customers")))
+        #expect(titles.contains(String(localized: "Preview Referenced Row")))
+
+        grid.perform(try #require(CommandRows.item(String(format: String(localized: "Open %@"), "customers"), in: menu)))
+        grid.perform(try #require(CommandRows.item(String(format: String(localized: "Open %@ in New Tab"), "customers"), in: menu)))
+
+        let navigations = grid.owner.navigations
+        #expect(navigations.map { $0.value } == ["7", "7"])
+        #expect(navigations.map { $0.intent } == [.follow, .newTab])
+    }
+
+    @Test("An empty key offers only Choose, and a read-only grid nothing to follow without the command")
+    func emptyForeignKeyOffersChooseOnly() {
+        let grid = CommandGrid(Self.orders)
+        let titles = CommandRows.titles(grid.rowMenu(row: 1, displayColumn: 1))
+
+        #expect(titles.contains(String(format: String(localized: "Choose %@ Row…"), "customers")))
+        #expect(!titles.contains(String(localized: "Preview Referenced Row")))
+
+        let readOnly = CommandGrid(Self.orders, configuration: CommandGrid.readOnly())
+        let readOnlyTitles = CommandRows.titles(readOnly.rowMenu(row: 0, displayColumn: 1))
+        #expect(!readOnlyTitles.contains(String(format: String(localized: "Choose %@ Row…"), "customers")))
+        #expect(!readOnlyTitles.contains(String(format: String(localized: "Open %@"), "customers")))
+    }
+}
+
+// MARK: - Menu bar commands
+
+@MainActor
+struct DataGridResponderCommandTests {
+    @Test("Copy Rows and Delete take every row of a range selection")
+    func rowCommandsCoverTheRange() {
+        let grid = CommandGrid(CommandRows.people)
+        grid.owner.copiesRowsItself = true
+        grid.select(rows: 0...1, columns: 1...1)
+
+        grid.controller.copySelectedRows(nil)
+        grid.controller.delete(nil)
+
+        #expect(grid.owner.rowCopies == [[.existing(0), .existing(1)]])
+        #expect(grid.owner.deletions == [[.existing(0), .existing(1)]])
+    }
+
+    @Test("Copy Rows is enabled over a range and dimmed with nothing selected")
+    func copyRowsValidation() {
+        let grid = CommandGrid(CommandRows.people)
+        #expect(!grid.isEnabled(#selector(GridRowCopyCommandResponding.copySelectedRows(_:))))
+        #expect(!grid.isEnabled(#selector(DataGridViewController.copy(_:))))
+
+        grid.select(rows: 0...1, columns: 1...1)
+
+        #expect(grid.isEnabled(#selector(GridRowCopyCommandResponding.copySelectedRows(_:))))
+        #expect(grid.isEnabled(#selector(DataGridViewController.copy(_:))))
+    }
+
+    @Test("A grid of definitions dims the row formats and keeps Copy Rows for its owner")
+    func definitionsGridDimsTheFormats() {
+        let grid = CommandGrid(CommandRows.people, configuration: CommandGrid.editable(appliesRowCopyFormat: false))
+        grid.selectRows(0...1)
+
+        #expect(grid.isEnabled(#selector(GridRowCopyCommandResponding.copySelectedRows(_:))))
+        #expect(!grid.isEnabled(#selector(GridRowCopyCommandResponding.copyRowsWithHeaders(_:))))
+        #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsCsv(_:))))
+        #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsMarkdown(_:))))
+        #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
+    }
+
+    @Test("Statements are offered only where the owner can write them")
+    func statementsNeedTheExporter() {
+        let grid = CommandGrid(CommandRows.people)
+        grid.selectRows(0...1)
+        #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
+
+        var configuration = CommandGrid.editable()
+        configuration.commands.insert(.copyAsSQL)
+        let table = CommandGrid(CommandRows.people, configuration: configuration)
+        let exporter = RecordingSQLExporter()
+        table.owner.exporter = exporter
+        table.selectRows(0...1)
+        #expect(table.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
+        #expect(table.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsUpdateStatements(_:))))
+
+        exporter.allowsUpdate = false
+        #expect(!table.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsUpdateStatements(_:))))
+        exporter.allowsInsert = false
+        #expect(!table.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
+    }
+
+    @Test("Copy Cell Value needs a cell to read")
+    func copyCellValueNeedsACell() {
+        let grid = CommandGrid(CommandRows.people)
+        #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyCellValue(_:))))
+
+        grid.selectRows(0...1, activeColumn: 1)
+        #expect(grid.isEnabled(#selector(GridCopyCommandResponding.copyCellValue(_:))))
+        #expect(!grid.isEnabled(
+            #selector(GridCopyCommandResponding.copyCellValue(_:)),
+            sender: grid.contextItem(row: 0, displayColumn: nil)
+        ))
+    }
+
+    @Test("Select All selects every row and leaves no cell cursor; an empty grid has nothing to select")
+    func selectAll() {
+        let grid = CommandGrid(CommandRows.people)
+        grid.selectCell(1, 1)
+
+        grid.controller.performSelectAll(nil)
+
+        let selection = grid.model.selection
+        #expect(selection.affectedRows == IndexSet(integersIn: 0...2))
+        #expect(selection.affectedColumns == IndexSet(integersIn: 0...1))
+        #expect(selection.picksRows)
+        #expect(selection.activeCell == nil)
+        #expect(selection.columns.isEmpty)
+        #expect(grid.isEnabled(#selector(NSTableView.selectAll(_:))))
+
+        let empty = CommandGrid(TableRows.from(queryRows: [], columns: ["id"], columnTypes: [.integer(rawType: "INT")]))
+        empty.controller.performSelectAll(nil)
+        #expect(empty.model.selection.isEmpty)
+        #expect(!empty.isEnabled(#selector(NSTableView.selectAll(_:))))
+    }
+
+    @Test("A row dragged out carries tab-separated text and an HTML table, and the reorder type only where rows reorder")
+    func rowDragPasteboard() throws {
+        let grid = CommandGrid(CommandRows.people)
+        let item = try #require(grid.controller.rowDragPasteboardItem(forRow: 1))
+
+        #expect(item.string(forType: .string) == "2\tBob")
+        #expect(item.string(forType: .html)?.contains("Bob") == true)
+        #expect(item.string(forType: DataGridViewController.rowDragType) == nil)
+    }
+
+    @Test("A focused grid answers Find itself; Find Next waits for a term")
+    func findOpensTheGridsOwnBar() {
+        let grid = CommandGrid(CommandRows.people)
+        #expect(grid.isEnabled(#selector(DataGridViewController.performFind(_:))))
+        #expect(!grid.isEnabled(#selector(DataGridViewController.findNext(_:))))
+        #expect(!grid.isEnabled(#selector(DataGridViewController.useSelectionForFind(_:))))
+
+        grid.controller.performFind(nil)
+        #expect(grid.model.find.isVisible)
+        #expect(!grid.isEnabled(#selector(DataGridViewController.findNext(_:))))
+
+        grid.selectCell(1, 1)
+        grid.controller.useSelectionForFind(nil)
+        #expect(grid.model.find.term == "Bob")
+        #expect(grid.isEnabled(#selector(DataGridViewController.findNext(_:))))
+        #expect(grid.isEnabled(#selector(DataGridViewController.findPrevious(_:))))
+    }
+
+    @Test("Rows lift from the number of a selected row only")
+    func dragStartsOnSelectedRows() {
+        let grid = CommandGrid(CommandRows.people)
+        grid.selectRows(0...1)
+
+        #expect(grid.controller.canDragRows(fromRowNumberAt: 1))
+        #expect(!grid.controller.canDragRows(fromRowNumberAt: 2))
+
+        grid.selectCell(1, 1)
+        #expect(!grid.controller.canDragRows(fromRowNumberAt: 1))
+    }
+}
+
+// MARK: - Header menu
+
+@MainActor
+struct DataGridHeaderMenuTests {
+    @Test("Select Column comes just before Copy Column Name and selects every row of that column")
+    func selectColumn() throws {
+        let grid = CommandGrid(CommandRows.people)
+        grid.host()
+        defer { grid.close() }
+        let menu = grid.headerMenu("name")
+        let titles = CommandRows.titles(menu)
+        let select = try #require(titles.firstIndex(of: String(localized: "Select Column")))
+        #expect(titles[select + 1] == String(localized: "Copy Column Name"))
+
+        grid.perform(try #require(menu?.items[select]))
+
+        #expect(grid.model.selection.columns == IndexSet(integer: 1))
+        #expect(grid.model.selection.affectedRows == IndexSet(integersIn: 0...2))
+    }
+
+    @Test("Sort items replace the sort as the user's own, and Don't Sort shows only while a sort applies")
+    func sortItems() throws {
+        let grid = CommandGrid(CommandRows.people)
+        #expect(!CommandRows.titles(grid.headerMenu("name")).contains(String(localized: "Don't Sort")))
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Sort Descending"), in: grid.headerMenu("name"))))
+
+        let sort = grid.model.store.sortState
+        #expect(sort.columns.map { $0.columnIndex } == [1])
+        #expect(sort.columns.first?.direction == .descending)
+        #expect(sort.source == .user)
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Don't Sort"), in: grid.headerMenu("name"))))
+        #expect(grid.model.store.sortState == SortState(columns: [], source: .user))
+    }
+
+    @Test("A grid that cannot sort offers no sort items")
+    func noSortItemsWithoutSort() {
+        var configuration = CommandGrid.editable()
+        configuration.supportsColumnSort = false
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+
+        #expect(!CommandRows.titles(grid.headerMenu("name")).contains(String(localized: "Sort Ascending")))
+    }
+
+    @Test("Display As checks the current format and sets the chosen one, confirming first under a value filter")
+    func displayAs() throws {
+        var configuration = CommandGrid.editable()
+        configuration.commands.formUnion([.displayAs, .valueFilter])
+        let rows = TableRows.from(
+            queryRows: [[.bytes(Data(repeating: 0xAB, count: 16))]],
+            columns: ["payload"],
+            columnTypes: [.blob(rawType: "BYTEA")]
+        )
+        let grid = CommandGrid(rows, configuration: configuration)
+        let displayAs = try #require(CommandRows.item(String(localized: "Display As"), in: grid.headerMenu("payload"))?.submenu)
+        #expect(displayAs.items.first { $0.state == .on }?.title == ValueDisplayFormat.raw.displayName)
+
+        let uuid = try #require(displayAs.items.first { $0.title == ValueDisplayFormat.uuid.displayName })
+        grid.perform(uuid)
+        #expect(grid.model.store.displayFormats.first == .uuid)
+        #expect(grid.owner.displayOrderRequests == 0)
+
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["x"], includesNull: true), columnName: "payload", forColumn: 0)
+        grid.model.setValueFilter(filter)
+        let requests = grid.owner.displayOrderRequests
+        let menu = try #require(CommandRows.item(String(localized: "Display As"), in: grid.headerMenu("payload"))?.submenu)
+        grid.perform(try #require(menu.items.first { $0.title == ValueDisplayFormat.raw.displayName }))
+        #expect(grid.owner.displayOrderRequests == requests + 1)
+        #expect(grid.model.store.displayFormats.first == .raw)
+    }
+
+    @Test("Hide Column hands the column to the owner; Show All Columns appears once a column is hidden")
+    func hideAndShowColumns() throws {
+        var configuration = CommandGrid.editable()
+        configuration.commands.insert(.hideColumns)
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+        #expect(!CommandRows.titles(grid.headerMenu("id")).contains(String(localized: "Show All Columns")))
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Hide Column"), in: grid.headerMenu("id"))))
+        #expect(grid.owner.hiddenColumns == ["id"])
+
+        grid.model.updateColumnLayout { $0.hiddenColumns = ["id"] }
+        grid.perform(try #require(CommandRows.item(String(localized: "Show All Columns"), in: grid.headerMenu("name"))))
+        #expect(grid.owner.showAllColumnsRequests == 1)
+    }
+
+    @Test("Value filter items follow the command, and Clear Value Filter clears that column")
+    func valueFilterItems() throws {
+        let plain = CommandGrid(CommandRows.people)
+        #expect(!CommandRows.titles(plain.headerMenu("name")).contains(String(localized: "Filter Values…")))
+
+        var configuration = CommandGrid.editable()
+        configuration.commands.insert(.valueFilter)
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["Bob"], includesNull: false), columnName: "name", forColumn: 1)
+        grid.model.setValueFilter(filter)
+        let titles = CommandRows.titles(grid.headerMenu("name"))
+        #expect(titles.contains(String(localized: "Filter Values…")))
+        #expect(titles.contains(String(localized: "Clear All Value Filters")))
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Clear Value Filter"), in: grid.headerMenu("name"))))
+
+        #expect(!grid.model.store.valueFilter.isActive)
+        #expect(grid.model.rowCount == 3)
+    }
+
+    @Test("Filter Values lists each shown value once with its count, NULL first")
+    func distinctValues() {
+        let rows = TableRows.from(
+            queryRows: [[.text("b")], [.text("a")], [.null], [.text("b")]],
+            columns: ["status"],
+            columnTypes: [.text(rawType: "TEXT")]
+        )
+        let grid = CommandGrid(rows)
+        let column = grid.model.columns.columns[0]
+
+        let values = grid.commands.distinctValues(for: column)
+
+        #expect(values == [
+            ColumnDistinctValue(display: "", isNull: true, count: 1),
+            ColumnDistinctValue(display: "a", isNull: false, count: 1),
+            ColumnDistinctValue(display: "b", isNull: false, count: 2),
+        ])
+    }
+
+    @Test("Fill Column is offered on a writable column that is not a key")
+    func fillColumnOffer() {
+        var configuration = CommandGrid.editable()
+        configuration.primaryKeyColumns = ["id"]
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+
+        #expect(!CommandRows.titles(grid.headerMenu("id")).contains(String(localized: "Fill Column…")))
+        #expect(CommandRows.titles(grid.headerMenu("name")).contains(String(localized: "Fill Column…")))
+
+        let readOnly = CommandGrid(CommandRows.people, configuration: CommandGrid.readOnly())
+        #expect(!CommandRows.titles(readOnly.headerMenu("name")).contains(String(localized: "Fill Column…")))
+    }
+
+    // A filter applied while the values load must not move the fill onto other records.
+    @Test("A fill that waits for values writes the rows it was started on")
+    func fillKeepsItsRowsAcrossALoad() throws {
+        let grid = CommandGrid(TableRows.from(
+            queryRows: [[.text("1"), .null], [.text("2"), .null], [.text("3"), .text("c")]],
+            columns: ["id", "body"],
+            columnTypes: [.text(rawType: nil), .text(rawType: nil)],
+            unloadedCells: [0: [1: 2_000_000], 1: [1: 2_000_000]]
+        ))
+        grid.owner.loadableValues = [.existing(0): [1: .text("a")], .existing(1): [1: .text("b")]]
+        grid.owner.defersLoads = true
+        let body = try #require(grid.model.columns.column(at: 1))
+
+        grid.commands.applyFillColumn(body, content: .value(.text("x")))
+        try #require(grid.owner.commits.isEmpty)
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["2", "3"], includesNull: false), columnName: "id", forColumn: 0)
+        grid.model.setValueFilter(filter)
+        grid.owner.finishLoads()
+
+        #expect(grid.owner.staged(0, 1)?.value == .text("x"))
+        #expect(grid.owner.staged(1, 1)?.value == .text("x"))
+        #expect(grid.owner.staged(2, 1)?.value == .text("x"))
+    }
+
+    @Test("Freeze Up to This Column and Unfreeze Columns write the frozen count")
+    func freezeColumns() throws {
+        var configuration = CommandGrid.editable()
+        configuration.commands.insert(.freezeColumns)
+        let grid = CommandGrid(CommandRows.people, configuration: configuration)
+        grid.host()
+        defer { grid.close() }
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Freeze Up to This Column"), in: grid.headerMenu("id"))))
+        #expect(grid.model.store.columnLayout.frozenColumnCount == 1)
+        #expect(!CommandRows.titles(grid.headerMenu("id")).contains(String(localized: "Freeze Up to This Column")))
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Unfreeze Columns"), in: grid.headerMenu("id"))))
+        #expect(grid.model.store.columnLayout.frozenColumnCount == 0)
+    }
+
+    @Test("Size All Columns to Fit records every column's width as the user's own")
+    func sizeAllColumnsToFit() throws {
+        let grid = CommandGrid(CommandRows.people)
+        grid.host()
+        defer { grid.close() }
+
+        grid.perform(try #require(CommandRows.item(String(localized: "Size All Columns to Fit"), in: grid.headerMenu("id"))))
+
+        let layout = grid.model.store.columnLayout
+        #expect(Set(layout.columnWidths.keys) == ["id", "name"])
+        #expect(Set(layout.columnContentWidths.map { Array($0.keys) } ?? []) == ["id", "name"])
+    }
+}
+
+// MARK: - Selection summary
+
+extension GlobalStateSuites {
+    @Suite(.recordingClipboard)
+    @MainActor
+    struct DataGridSelectionSummaryMenuTests {
+        private static let numbers = TableRows.from(
+            queryRows: [[.text("1"), .text("a")], [.text("2"), .text("b")], [.text("3"), .text("c")]],
+            columns: ["n", "s"],
+            columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
+        )
+
+        private func summarized(column: Int) async throws -> CommandGrid {
+            let grid = CommandGrid(Self.numbers, selectionSummary: SelectionSummaryState())
+            grid.host()
+            try await waitUntil { grid.controller.selectionSummaryTracker.state != nil }
+            grid.select(rows: 0...2, columns: column...column)
+            try await waitUntil { grid.controller.selectionSummaryTracker.currentSummary != nil }
+            return grid
+        }
+
+        @Test("The cell menu offers Copy Sum and Copy Average right after Copy as, as plain text")
+        func cellMenuCopiesTheSummary() async throws {
+            let grid = try await summarized(column: 0)
+            defer { grid.close() }
+            let menu = grid.rowMenu(row: 0, displayColumn: 0)
+            let titles = CommandRows.titles(menu)
+            let copyAs = try #require(titles.firstIndex(of: String(localized: "Copy as")))
+            #expect(Array(titles.dropFirst(copyAs + 1).prefix(2)) == [
+                String(localized: "Copy Sum"),
+                String(localized: "Copy Average"),
+            ])
+
+            let clipboard = try #require(RecordingClipboard.current)
+            grid.perform(try #require(menu?.items[copyAs + 1]))
+            #expect(clipboard.text == "6")
+            grid.perform(try #require(menu?.items[copyAs + 2]))
+            #expect(clipboard.text == "2")
+        }
+
+        @Test("No summary copies for a selection holding no numbers, nor for a menu opened outside the selection")
+        func noSummaryCopies() async throws {
+            let text = try await summarized(column: 1)
+            defer { text.close() }
+            #expect(!CommandRows.titles(text.rowMenu(row: 0, displayColumn: 1)).contains(String(localized: "Copy Sum")))
+
+            let numbers = try await summarized(column: 0)
+            defer { numbers.close() }
+            #expect(!CommandRows.titles(numbers.rowMenu(row: 0, displayColumn: 1)).contains(String(localized: "Copy Sum")))
+        }
+    }
+}
+
+// MARK: - Cell and range copy
+
+extension GlobalStateSuites {
+    @Suite(.recordingClipboard)
+    @MainActor
+    struct DataGridCopyCommandTests {
+        private static let uuidBytes = Data([
+            0xAF, 0x49, 0x45, 0x3B, 0x7F, 0x2F, 0xFB, 0x58,
+            0xFC, 0xD3, 0x2B, 0xD3, 0x99, 0x59, 0x9F, 0xA5,
+        ])
+
+        private func binaryGrid(_ rows: [[PluginCellValue]], types: [ColumnType], databaseType: DatabaseType? = nil) -> CommandGrid {
+            let columns = (0..<types.count).map { "c\($0)" }
+            return CommandGrid(
+                TableRows.from(queryRows: rows, columns: columns, columnTypes: types),
+                configuration: CommandGrid.editable(databaseType: databaseType)
+            )
+        }
+
+        @Test("One cell copies its value, with its display format applied, and carries no row payload")
+        func cellCopyAppliesTheDisplayFormat() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = binaryGrid([[.text("1"), .bytes(Self.uuidBytes)]], types: [.integer(rawType: "INT"), .blob(rawType: "BYTEA")])
+            grid.model.setDisplayFormat(.uuid, for: grid.model.columns.columns[1])
+            grid.selectCell(0, 1)
+
+            grid.controller.copy(nil)
+
+            #expect(clipboard.text == "af49453b-7f2f-fb58-fcd3-2bd399599fa5")
+            #expect(clipboard.hasGridRows == false)
+        }
+
+        @Test("Copy does not guess MongoDB legacy UUID byte order")
+        func copyKeepsUndecodedMongoUuidAsHex() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let javaLegacyBytes = Data([
+                0x24, 0x43, 0x25, 0x4A, 0xEB, 0x03, 0xD0, 0x8C,
+                0x1A, 0x0D, 0xDA, 0xE2, 0xFC, 0x88, 0x32, 0x93,
+            ])
+            let grid = binaryGrid([[.bytes(javaLegacyBytes)]], types: [.blob(rawType: "BLOB(3)")], databaseType: .mongodb)
+            grid.model.setDisplayFormat(.uuid, for: grid.model.columns.columns[0])
+            grid.selectCell(0, 0)
+
+            grid.controller.copy(nil)
+
+            #expect(clipboard.text == "0x2443254AEB03D08C1A0DDAE2FC883293")
+        }
+
+        @Test("Copy reads the record a display position shows under a value filter")
+        func copyUsesTheDisplayedRows() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = CommandGrid(CommandRows.people)
+            var filter = GridValueFilterState()
+            filter.set(ColumnValueFilter(selectedValues: ["Bob", "Carol"], includesNull: false), columnName: "name", forColumn: 1)
+            grid.model.setValueFilter(filter)
+            grid.selectCell(0, 1)
+
+            grid.controller.copy(nil)
+
+            #expect(clipboard.text == "Bob")
+        }
+
+        @Test("A multi-cell range keeps raw bytes rather than a display format")
+        func rangeCopyKeepsRawBytes() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let first = Data(repeating: 0xAA, count: 16)
+            let second = Data(repeating: 0xBB, count: 16)
+            let grid = binaryGrid(
+                [[.bytes(first), .bytes(second), .text("x")]],
+                types: [.blob(rawType: "BYTEA"), .blob(rawType: "BYTEA"), .text(rawType: "TEXT")]
+            )
+            grid.model.setDisplayFormat(.uuid, for: grid.model.columns.columns[0])
+            grid.select(rows: 0...0, columns: 0...1)
+
+            grid.controller.copy(nil)
+
+            #expect(clipboard.text == "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\t0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB")
+        }
+
+        @Test("A range copies as typed fields, NULL kept, in display order")
+        func rangeCopiesTypedFields() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = CommandGrid(TableRows.from(
+                queryRows: [[.text("1"), .text("Alice"), .null], [.text("2"), .text("Bob"), .text("x")]],
+                columns: ["id", "name", "note"],
+                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .text(rawType: "TEXT")]
+            ))
+            grid.select(rows: 0...1, columns: 1...2)
+
+            grid.controller.copy(nil)
+
+            #expect(clipboard.text == "Alice\tNULL\nBob\tx")
+            #expect(clipboard.gridCells?.fields == [["Alice", nil], ["Bob", "x"]])
+        }
+
+        @Test("The context menu's Copy outside a range copies the clicked cell, not the range (interaction 6)")
+        func contextCopyOutsideTheRangeTakesTheClickedCell() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = CommandGrid(CommandRows.people)
+            grid.select(rows: 0...1, columns: 0...0)
+
+            grid.controller.copy(grid.contextItem(row: 0, displayColumn: 1))
+            #expect(clipboard.text == "Alice")
+
+            grid.controller.copy(grid.contextItem(row: 1, displayColumn: 0))
+            #expect(clipboard.text == "1\n2")
+        }
+
+        @Test("Copy from the row numbers copies the row even with a cell selected", .appSettings { $0.dataGrid.rowCopyFormat = .rows })
+        func rowNumberCopyCopiesTheRow() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = CommandGrid(CommandRows.people)
+            grid.selectCell(0, 1)
+
+            grid.controller.copy(grid.contextItem(row: 0, displayColumn: nil))
+
+            #expect(clipboard.text == "1\tAlice")
+            #expect(clipboard.gridRows?.rows.count == 1)
+        }
+
+        @Test("A value the page left on the server loads before it is copied")
+        func unloadedValueLoadsFirst() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = CommandGrid(TableRows.from(
+                queryRows: [[.text("1"), .null]],
+                columns: ["id", "body"],
+                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")],
+                unloadedCells: [0: [1: 2_000_000]]
+            ))
+            grid.owner.loadableValues = [.existing(0): [1: .text("the whole body")]]
+            grid.selectCell(0, 1)
+
+            grid.controller.copy(nil)
+
+            #expect(grid.owner.loadRequests == [[.existing(0)]])
+            #expect(clipboard.text == "the whole body")
+        }
+
+        @Test("A load the owner refuses copies nothing")
+        func refusedLoadCopiesNothing() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = CommandGrid(TableRows.from(
+                queryRows: [[.text("1"), .null]],
+                columns: ["id", "body"],
+                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")],
+                unloadedCells: [0: [1: 2_000_000]]
+            ))
+            grid.selectCell(0, 1)
+
+            grid.controller.copy(nil)
+
+            #expect(grid.owner.loadRequests.count == 1)
+            #expect(clipboard.text == nil)
+        }
+
+        @Test("Copy Column Values copies every displayed value of the column, NULL spelled out")
+        func copyColumnValues() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = CommandGrid(TableRows.from(
+                queryRows: [[.text("a")], [.null], [.text("c")]],
+                columns: ["v"],
+                columnTypes: [.text(rawType: "TEXT")]
+            ))
+
+            grid.perform(try #require(CommandRows.item(String(localized: "Copy Column Values"), in: grid.headerMenu("v"))))
+
+            #expect(clipboard.text == "a\nNULL\nc")
+        }
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridConfigurationTests.swift b/apple/TableProTests/Views/DataGrid/DataGridConfigurationTests.swift
new file mode 100644
index 0000000000..b975c6ba27
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridConfigurationTests.swift
@@ -0,0 +1,172 @@
+//
+//  DataGridConfigurationTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct DataGridConfigurationTests {
+    private func dataColumns(of table: NSTableView) -> [NSTableColumn] {
+        table.tableColumns.filter { $0.identifier != DataGridPane.rowNumberIdentifier }
+    }
+
+    private func hasAttachment(_ string: NSAttributedString) -> Bool {
+        var found = false
+        string.enumerateAttribute(.attachment, in: NSRange(location: 0, length: string.length)) { value, _, stop in
+            if value != nil {
+                found = true
+                stop.pointee = true
+            }
+        }
+        return found
+    }
+
+    private static func sorted(by name: String, ascending: Bool) -> InMemoryDataGridStateStore {
+        let store = InMemoryDataGridStateStore()
+        store.sortState = SortState(
+            columns: [SortColumn(columnIndex: 1, direction: ascending ? .ascending : .descending, columnName: name)],
+            source: .user
+        )
+        return store
+    }
+
+    @Test("A default grid offers value filters and column sort, and edits nothing")
+    func defaults() {
+        let configuration = DataGridConfiguration()
+
+        #expect(configuration.supportsValueFilter)
+        #expect(configuration.supportsColumnSort)
+        #expect(configuration.showRowNumbers)
+        #expect(!configuration.isEditable)
+        #expect(configuration.commands.isEmpty)
+    }
+
+    // MARK: - Sort
+
+    @Test("Every data column sorts by its column identity, first click ascending outside row grids")
+    func dataColumnsCarryASortPrototype() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+
+        let prototypes = dataColumns(of: grid.main).map { $0.sortDescriptorPrototype }
+        #expect(prototypes.map { $0?.key } == ["id", "name", "age"].map { DataGridColumnID(name: $0, occurrence: 0).stringValue })
+        #expect(prototypes.allSatisfy { $0?.ascending == true })
+    }
+
+    @Test("A grid that cannot be ordered by a column offers no sort on its headers")
+    func noColumnSortRemovesPrototypes() {
+        var configuration = DataGridConfiguration()
+        configuration.supportsColumnSort = false
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration)
+        defer { grid.close() }
+
+        #expect(dataColumns(of: grid.main).allSatisfy { $0.sortDescriptorPrototype == nil })
+    }
+
+    @Test("Turning column sort off on an open grid takes the sort away from its headers")
+    func columnSortOffLive() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, store: Self.sorted(by: "name", ascending: false))
+        defer { grid.close() }
+        #expect(grid.main.sortDescriptors.map { $0.key } == [DataGridColumnID(name: "name", occurrence: 0).stringValue])
+
+        grid.model.configuration.supportsColumnSort = false
+
+        #expect(dataColumns(of: grid.main).allSatisfy { $0.sortDescriptorPrototype == nil })
+        #expect(grid.main.sortDescriptors.isEmpty)
+    }
+
+    @Test("Without column sort a header sort change reaches no owner")
+    func noColumnSortIgnoresHeaderSort() {
+        var configuration = DataGridConfiguration()
+        configuration.supportsColumnSort = false
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration)
+        defer { grid.close() }
+
+        grid.main.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
+
+        #expect(grid.owner.sortChanges.isEmpty)
+        #expect(!grid.model.store.sortState.isSorting)
+    }
+
+    @Test("The stored sort shows on the header, with its direction for accessibility")
+    func storedSortShowsOnTheHeader() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, store: Self.sorted(by: "name", ascending: false))
+        defer { grid.close() }
+        let descriptor = try #require(grid.main.sortDescriptors.first)
+        let name = try #require(grid.tableColumn(named: "name"))
+        let age = try #require(grid.tableColumn(named: "age"))
+
+        #expect(descriptor.key == DataGridColumnID(name: "name", occurrence: 0).stringValue)
+        #expect(!descriptor.ascending)
+        #expect(name.headerCell.accessibilitySortDirection() == .descending)
+        #expect(age.headerCell.accessibilitySortDirection() == .unknown)
+    }
+
+    // MARK: - Value filter
+
+    @Test("A filtered column's heading carries the funnel when the grid offers value filters")
+    func funnelShowsWithValueFilters() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people) { _, model in
+            model.store.valueFilter = GridFixtureRows.nameFilter(["bob"])
+        }
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+        let age = try #require(grid.tableColumn(named: "age"))
+
+        #expect(grid.model.rowCount == 1)
+        #expect(hasAttachment(name.headerCell.attributedStringValue))
+        #expect(!hasAttachment(age.headerCell.attributedStringValue))
+    }
+
+    @Test("A grid without value filters shows a plain heading")
+    func noFunnelWithoutValueFilters() throws {
+        var configuration = DataGridConfiguration()
+        configuration.supportsValueFilter = false
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration) { _, model in
+            model.store.valueFilter = GridFixtureRows.nameFilter(["bob"])
+        }
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+
+        #expect(!hasAttachment(name.headerCell.attributedStringValue))
+        #expect(name.headerCell.stringValue == "name")
+    }
+
+    @Test("Clearing the filter puts the plain heading back")
+    func clearingTheFilterDropsTheFunnel() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people) { _, model in
+            model.store.valueFilter = GridFixtureRows.nameFilter(["bob"])
+        }
+        defer { grid.close() }
+
+        grid.model.setValueFilter(GridValueFilterState())
+
+        let name = try #require(grid.tableColumn(named: "name"))
+        #expect(grid.model.rowCount == 5)
+        #expect(!hasAttachment(name.headerCell.attributedStringValue))
+    }
+
+    // MARK: - Headers
+
+    @Test("A heading's tooltip names the column and its type")
+    func headerToolTipNamesTheType() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+
+        #expect(name.headerToolTip == "name (TEXT)")
+    }
+
+    @Test("A heading tells accessibility which column it heads")
+    func headerAccessibilityLabel() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+
+        #expect(name.headerCell.accessibilityLabel() == String(format: String(localized: "Column: %@"), "name"))
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridControllerTests.swift b/apple/TableProTests/Views/DataGrid/DataGridControllerTests.swift
new file mode 100644
index 0000000000..e423818a3e
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridControllerTests.swift
@@ -0,0 +1,419 @@
+//
+//  DataGridControllerTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+@MainActor
+struct DataGridControllerTests {
+    private func cell(_ row: Int, _ column: Int) -> GridSelection {
+        GridSelectionReducer.single(GridCoord(row: row, displayColumn: column))
+    }
+
+    private func reordered(_ table: TableRows, ids: [Int]) -> TableRows {
+        var rows = table
+        rows.reorderRows(ContiguousArray(ids.compactMap { table.row(withID: .existing($0)) }))
+        return rows
+    }
+
+    private func deletingGrid() -> HostedDataGrid {
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        configuration.commands = [.deleteRows]
+        return HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration)
+    }
+
+    // What AppKit does with a heading click before it calls sortDescriptorsDidChange: it reports the press, then
+    // puts the clicked key first (flipped when it already was), or under Option appends it or flips it in place.
+    private func clickHeading(_ column: NSTableColumn, in grid: HostedDataGrid, modifiers: NSEvent.ModifierFlags = []) throws {
+        grid.setCurrentEventModifiers(modifiers)
+        let addsKey = modifiers.contains(.option)
+        try #require(NSApp.currentEvent?.modifierFlags.contains(.option) == addsKey)
+        let prototype = try #require(column.sortDescriptorPrototype)
+        grid.controller.tableView(grid.main, mouseDownInHeaderOf: column)
+        var descriptors = grid.main.sortDescriptors
+        if let existing = descriptors.firstIndex(where: { $0.key == prototype.key }) {
+            let flipped = NSSortDescriptor(key: prototype.key, ascending: !descriptors[existing].ascending)
+            if addsKey {
+                descriptors[existing] = flipped
+            } else {
+                descriptors.remove(at: existing)
+                descriptors.insert(existing == 0 ? flipped : prototype, at: 0)
+            }
+        } else if addsKey {
+            descriptors.append(prototype)
+        } else {
+            descriptors.insert(prototype, at: 0)
+        }
+        grid.main.sortDescriptors = descriptors
+    }
+
+    private func sortedNames(_ grid: HostedDataGrid) -> [String?] {
+        grid.model.store.sortState.columns.map { $0.columnName }
+    }
+
+    // NSTableView tracks a press until the mouse-up, so the mouse-up waits in the queue before the press is sent.
+    private func click(_ table: DataGridTableView, at point: NSPoint, in grid: HostedDataGrid) throws {
+        let location = table.convert(point, to: nil)
+        func event(_ type: NSEvent.EventType) throws -> NSEvent {
+            try #require(NSEvent.mouseEvent(
+                with: type,
+                location: location,
+                modifierFlags: [],
+                timestamp: ProcessInfo.processInfo.systemUptime,
+                windowNumber: grid.window.windowNumber,
+                context: nil,
+                eventNumber: 0,
+                clickCount: 1,
+                pressure: type == .leftMouseDown ? 1 : 0
+            ))
+        }
+        let up = try event(.leftMouseUp)
+        let down = try event(.leftMouseDown)
+        NSApp.postEvent(up, atStart: true)
+        table.mouseDown(with: down)
+        _ = NSApp.nextEvent(matching: .leftMouseUp, until: .distantPast, inMode: .default, dequeue: true)
+    }
+
+    // MARK: - Keyboard
+
+    @Test("Typing a letter selects the next row whose active column starts with it")
+    func typeSelectMovesTheRow() async throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.focus()
+        grid.model.setSelection(cell(0, 1))
+
+        try #require(grid.press("d", keyCode: KeyCode.d.rawValue))
+
+        try await waitUntil(timeout: .seconds(2)) { grid.model.selection.activeCell?.row == 3 }
+        #expect(grid.model.selectedRowIDs == [.existing(3)])
+        #expect(grid.model.activeCell?.column.name == "name")
+        #expect(grid.main.selectedRowIndexes == IndexSet(integer: 3))
+    }
+
+    @Test("Delete with Caps Lock on reaches the delete command")
+    func deleteWithCapsLockDeletesRows() throws {
+        let grid = deletingGrid()
+        defer { grid.close() }
+        grid.focus()
+        grid.model.selectRows([.existing(1), .existing(2)])
+
+        try #require(grid.press("\u{7F}", keyCode: KeyCode.delete.rawValue, modifiers: [.capsLock]))
+
+        #expect(grid.owner.deleteRequests == [[.existing(1), .existing(2)]])
+    }
+
+    @Test("Forward Delete, Fn and Caps Lock included, reaches the delete command")
+    func forwardDeleteDeletesRows() throws {
+        let grid = deletingGrid()
+        defer { grid.close() }
+        grid.focus()
+        grid.model.selectRows([.existing(3)])
+
+        try #require(grid.press("\u{F728}", keyCode: KeyCode.forwardDelete.rawValue, modifiers: [.function, .capsLock]))
+
+        #expect(grid.owner.deleteRequests == [[.existing(3)]])
+    }
+
+    @Test("Shift-Space widens a cell range to the whole rows it touches")
+    func shiftSpaceWidensToRows() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.focus()
+        grid.model.setSelection(GridSelection(
+            rectangles: [GridRect(rows: 1...2, columns: 1...1)],
+            activeCell: GridCoord(row: 2, displayColumn: 1),
+            anchor: GridCoord(row: 1, displayColumn: 1)
+        ))
+
+        try #require(grid.press(" ", keyCode: KeyCode.space.rawValue, modifiers: [.shift, .capsLock]))
+
+        #expect(grid.model.selection.rectangles == [GridRect(rows: 1...2, columns: 0...2)])
+        #expect(grid.model.selection.activeCell?.displayColumn == 1)
+    }
+
+    @Test("Space sets every selected checkbox the same way and leaves the selection where it was")
+    func spaceTogglesCheckboxes() throws {
+        var configuration = DataGridConfiguration()
+        configuration.checkboxColumns = [0]
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration) { owner, _ in
+            owner.checkboxStates = [.existing(1): true, .existing(2): false]
+        }
+        defer { grid.close() }
+        grid.focus()
+        grid.model.selectRows([.existing(1), .existing(2)])
+        let selected = grid.model.selection
+
+        try #require(grid.press(" ", keyCode: KeyCode.space.rawValue))
+
+        #expect(grid.owner.checkboxWrites.count == 1)
+        #expect(grid.owner.checkboxWrites.first?.isOn == true)
+        #expect(grid.owner.checkboxWrites.first?.rowIDs == [.existing(1), .existing(2)])
+        #expect(grid.owner.checkboxWrites.first?.column == "id")
+        #expect(grid.model.selection == selected)
+    }
+
+    // MARK: - Header
+
+    @Test("A plain heading click sorts by that column alone and an Option-click adds a key")
+    func headingClicksReplaceAndOptionAdds() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+        let age = try #require(grid.tableColumn(named: "age"))
+
+        try clickHeading(name, in: grid)
+        #expect(sortedNames(grid) == ["name"])
+
+        try clickHeading(age, in: grid, modifiers: .option)
+        #expect(sortedNames(grid) == ["name", "age"])
+        #expect(grid.model.store.sortState.columns.map { $0.direction } == [.ascending, .ascending])
+        #expect(grid.main.sortDescriptors.map { $0.key } == ["name", "age"].map { DataGridColumnID(name: $0, occurrence: 0).stringValue })
+
+        try clickHeading(age, in: grid)
+        #expect(sortedNames(grid) == ["age"])
+        #expect(grid.model.store.sortState.source == .user)
+        #expect(grid.main.sortDescriptors.map { $0.key } == [DataGridColumnID(name: "age", occurrence: 0).stringValue])
+        #expect(grid.owner.sortChanges.count == 3)
+    }
+
+    @Test("A plain click on the sorted heading flips it and an Option-click on a secondary key flips only that key")
+    func headingClicksFlip() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+        let age = try #require(grid.tableColumn(named: "age"))
+
+        try clickHeading(name, in: grid)
+        try clickHeading(name, in: grid)
+        #expect(grid.model.store.sortState.columns.map { $0.direction } == [.descending])
+
+        try clickHeading(age, in: grid, modifiers: .option)
+        try clickHeading(age, in: grid, modifiers: .option)
+        #expect(sortedNames(grid) == ["name", "age"])
+        #expect(grid.model.store.sortState.columns.map { $0.direction } == [.descending, .descending])
+    }
+
+    // MARK: - Columns
+
+    @Test("Moving a column in the header keeps the cursor on that column")
+    func columnReorderKeepsCursor() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.setSelection(cell(1, 2))
+        let age = try #require(grid.tableIndex(ofDisplayPosition: 2))
+        let id = try #require(grid.tableIndex(ofDisplayPosition: 0))
+
+        grid.main.moveColumn(age, toColumn: id)
+
+        #expect(grid.model.columns.orderedNames == ["age", "id", "name"])
+        #expect(grid.model.selection.activeCell == GridCoord(row: 1, displayColumn: 0))
+        #expect(grid.model.activeCell?.column.name == "age")
+        #expect(grid.model.activeCell?.rowID == .existing(1))
+        #expect(grid.model.store.columnLayout.columnOrder == ["age", "id", "name"])
+    }
+
+    // MARK: - Find
+
+    @Test("A find match moves the active cell to the match's column, so the arrow keys continue from it")
+    func findMatchSetsActiveColumn() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.setSelection(cell(0, 0))
+
+        grid.model.showFind()
+        grid.model.find.term = "dee"
+        grid.model.findQueryDidChange()
+
+        #expect(grid.model.selection.activeCell == GridCoord(row: 3, displayColumn: 1))
+        #expect(grid.main.selectedRowIndexes == IndexSet(integer: 3))
+
+        grid.main.moveRight(nil)
+
+        #expect(grid.model.selection.activeCell == GridCoord(row: 3, displayColumn: 2))
+    }
+
+    // MARK: - Frozen pane
+
+    @Test("The frozen pane lies over the main table's leading columns, at the same geometry")
+    func frozenPaneCoversLeadingColumns() throws {
+        var layout = ColumnLayoutState()
+        layout.frozenColumnCount = 2
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide(), store: InMemoryDataGridStateStore(columnLayout: layout))
+        defer { grid.close() }
+
+        #expect(grid.controller.effectiveFrozenCount == 2)
+        #expect(!grid.frozenScrollView.isHidden)
+        #expect(grid.frozen.tableColumns.count == 3)
+        #expect(grid.frozen.tableColumns.first?.identifier == DataGridPane.rowNumberIdentifier)
+        for index in 0..<grid.frozen.tableColumns.count {
+            let shown = grid.frozen.rect(ofColumn: index)
+            let home = grid.main.rect(ofColumn: index)
+            #expect(shown.minX == home.minX)
+            #expect(shown.width == home.width)
+        }
+        let frame = grid.frozenScrollView.frame
+        #expect(frame.minX == 0)
+        #expect(frame.minY == grid.mainScrollView.frame.minY)
+        #expect(frame.width == grid.container.frozenPaneWidth)
+        #expect(frame.width == grid.controller.frozen.columnsWidth)
+        #expect(frame.height == grid.container.bounds.height - grid.mainScrollView.legacyHorizontalScrollerHeight)
+    }
+
+    @Test("The two panes scroll vertically in step, and the frozen pane never scrolls sideways")
+    func panesScrollInStep() async throws {
+        var layout = ColumnLayoutState()
+        layout.frozenColumnCount = 1
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide(), store: InMemoryDataGridStateStore(columnLayout: layout))
+        defer { grid.close() }
+        let mainClip = grid.mainScrollView.contentView
+        let frozenClip = grid.frozenScrollView.contentView
+
+        grid.main.scroll(NSPoint(x: 300, y: grid.main.rect(ofRow: 30).minY))
+
+        try await waitUntil(timeout: .seconds(2)) { frozenClip.bounds.origin.y == mainClip.bounds.origin.y }
+        #expect(mainClip.bounds.origin.x > 0)
+        #expect(frozenClip.bounds.origin.x == 0)
+
+        grid.frozen.scroll(NSPoint(x: 0, y: grid.frozen.rect(ofRow: 10).minY))
+
+        try await waitUntil(timeout: .seconds(2)) { mainClip.bounds.origin.y == frozenClip.bounds.origin.y }
+        #expect(frozenClip.bounds.origin.x == 0)
+    }
+
+    @Test("Both panes emphasize their selected rows together and stop together")
+    func panesEmphasizeTogether() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.selectRows([.existing(1)])
+        let mainRow = try #require(grid.main.rowView(atRow: 1, makeIfNecessary: true))
+        let frozenRow = try #require(grid.frozen.rowView(atRow: 1, makeIfNecessary: true))
+        #expect(!grid.frozenScrollView.isHidden)
+
+        grid.focus()
+
+        #expect(grid.container.gridHasFocus)
+        #expect(mainRow.isSelected)
+        #expect(frozenRow.isSelected)
+        #expect(mainRow.isEmphasized)
+        #expect(frozenRow.isEmphasized)
+
+        grid.setKeyWindow(false)
+
+        #expect(!grid.container.gridHasFocus)
+        #expect(!mainRow.isEmphasized)
+        #expect(!frozenRow.isEmphasized)
+    }
+
+    // MARK: - Accessibility
+
+    @Test("A cell's label names the row number on screen and the column's display position")
+    func accessibilityLabelsUseScreenPositions() throws {
+        let wasActive = DataGridAccessibility.isActive
+        DataGridAccessibility.isActive = true
+        defer { DataGridAccessibility.isActive = wasActive }
+        var layout = ColumnLayoutState()
+        layout.columnOrder = ["age", "id", "name"]
+        let grid = HostedDataGrid(
+            rows: GridFixtureRows.people,
+            store: InMemoryDataGridStateStore(columnLayout: layout)
+        ) { owner, _ in
+            owner.rowNumberOffset = 100
+        }
+        defer { grid.close() }
+        grid.model.setValueFilter(GridFixtureRows.nameFilter(["bob", "dee"]))
+        grid.layout()
+
+        let index = try #require(grid.tableIndex(ofDisplayPosition: 2))
+        let cell = try #require(grid.main.view(atColumn: index, row: 1, makeIfNecessary: true) as? DataGridAccessibilityCellView)
+
+        #expect(cell.accessibilityLabel() == "Row 102, column 3: dee")
+        #expect(cell.accessibilityIdentifier() == "data-grid-cell")
+        #expect(cell.accessibilityRowIndexRange() == NSRange(location: 1, length: 1))
+        #expect(!grid.frozen.isAccessibilityElement())
+        #expect(grid.frozenScrollView.accessibilityChildren()?.isEmpty == true)
+    }
+
+    // MARK: - Selection
+
+    @Test("A reload keeps the model's selection in both tables, following its rows")
+    func reloadKeepsSelection() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.setSelection(GridSelection(
+            rectangles: [GridRect(rows: 1...2, columns: 0...2)],
+            activeCell: GridCoord(row: 1, displayColumn: 1),
+            anchor: GridCoord(row: 1, displayColumn: 1)
+        ))
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 1...2))
+
+        grid.model.reloadRows()
+
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 1...2))
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integersIn: 1...2))
+
+        grid.owner.tableRows = reordered(GridFixtureRows.people, ids: [4, 3, 2, 1, 0])
+        grid.model.reloadRows()
+
+        #expect(grid.model.selectedRowIDs == [.existing(2), .existing(1)])
+        #expect(grid.model.activeCell?.rowID == .existing(1))
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 2...3))
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integersIn: 2...3))
+    }
+
+    @Test("A click past the last column selects that row with the cursor, as a table row does")
+    func clickPastLastColumnSelectsRow() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.setSelection(GridSelectionReducer.cursor(GridCoord(row: 1, displayColumn: 2), in: grid.controller.selectionContext))
+        let table = grid.main
+        let lastColumn = table.rect(ofColumn: table.numberOfColumns - 1)
+        let point = NSPoint(x: (lastColumn.maxX + table.bounds.maxX) / 2, y: table.rect(ofRow: 3).midY)
+        try #require(table.column(at: point) == -1)
+        try #require(table.row(at: point) == 3)
+
+        try click(table, at: point, in: grid)
+
+        #expect(grid.model.selection.mode == .cursor)
+        #expect(grid.model.selectedRowIDs == [.existing(3)])
+        #expect(grid.model.selection.activeCell == GridCoord(row: 3, displayColumn: 2))
+        #expect(grid.main.selectedRowIndexes == IndexSet(integer: 3))
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integer: 3))
+    }
+
+    @Test("Pressing the number of a clicked row picks the row, so Copy takes the whole row")
+    func rowNumberPressPicksClickedRow() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.setSelection(GridSelectionReducer.cursor(GridCoord(row: 2, displayColumn: 1), in: grid.controller.selectionContext))
+        let table = grid.frozen
+        try #require(table.tableColumns.first?.identifier == DataGridPane.rowNumberIdentifier)
+        try #require(grid.controller.canDragRows(fromRowNumberAt: 2))
+        let point = NSPoint(x: table.rect(ofColumn: 0).midX, y: table.rect(ofRow: 2).midY)
+
+        try click(table, at: point, in: grid)
+
+        #expect(grid.model.selection.picksRows)
+        #expect(grid.model.selectedRowIDs == [.existing(2)])
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integer: 2))
+    }
+
+    @Test("A row the table selects itself becomes the model's selection, keeping the column")
+    func nativeRowSelectionReachesModel() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.setSelection(cell(1, 2))
+
+        grid.main.selectRowIndexes(IndexSet(integer: 4), byExtendingSelection: false)
+
+        #expect(grid.model.selection.activeCell == GridCoord(row: 4, displayColumn: 2))
+        #expect(grid.model.selectedRowIDs == [.existing(4)])
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integer: 4))
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridDisplayCacheTests.swift b/apple/TableProTests/Views/DataGrid/DataGridDisplayCacheTests.swift
new file mode 100644
index 0000000000..41e006c2fd
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridDisplayCacheTests.swift
@@ -0,0 +1,153 @@
+//
+//  DataGridDisplayCacheTests.swift
+//  TableProTests
+//
+
+import AppKit
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+@MainActor
+private final class DisplayGrid {
+    let owner: GridTestOwner
+    let model: DataGridModel
+    let presenter: DataGridCellPresenter
+
+    init(_ rows: TableRows) {
+        owner = GridTestOwner(rows)
+        model = DataGridModel()
+        model.dataSource = owner
+        model.actions = owner
+        owner.model = model
+        model.reloadRows()
+        presenter = DataGridCellPresenter(model: model)
+    }
+
+    func text(row displayRow: Int, column position: Int = 0) -> String? {
+        DataGridDisplayCacheTests.text(of: model, presenter: presenter, row: displayRow, column: position)
+    }
+}
+
+@MainActor
+struct DataGridDisplayCacheTests {
+    private static let binary = Data([
+        0xAF, 0x49, 0x45, 0x3B, 0x7F, 0x2F, 0xFB, 0x58,
+        0xFC, 0xD3, 0x2B, 0xD3, 0x99, 0x59, 0x9F, 0xA5,
+    ])
+    private static let rawBinaryText = "0xAF49453B7F2FFB58FCD32BD399599FA5"
+    private static let uuidText = "af49453b-7f2f-fb58-fcd3-2bd399599fa5"
+
+    private static var binaryRows: TableRows {
+        TableRows(
+            rows: [Row(id: .existing(0), values: [.bytes(binary)])],
+            columns: ["id"],
+            columnTypes: [.blob(rawType: "BLOB")]
+        )
+    }
+
+    static func text(of model: DataGridModel, presenter: DataGridCellPresenter, row displayRow: Int, column position: Int) -> String? {
+        guard let row = model.row(at: displayRow), let column = model.columns.column(at: position) else { return nil }
+        return presenter.displayText(
+            of: row,
+            dataIndex: column.dataIndex,
+            type: column.type,
+            formats: model.store.displayFormats,
+            databaseType: model.configuration.traits.databaseType,
+            columnCount: model.rows.columns.count
+        )
+    }
+
+    @Test("A row's cached text is served until the change to it reaches the model")
+    func cacheServesTheRowUntilTheChangeArrives() {
+        let grid = DisplayGrid(TableRows(
+            rows: [Row(id: .existing(0), values: [.text("A")])],
+            columns: ["name"],
+            columnTypes: [.text(rawType: nil)]
+        ))
+        #expect(grid.text(row: 0) == "A")
+
+        grid.owner.tableRows.rows[0].values[0] = .text("B")
+        #expect(grid.text(row: 0) == "A")
+
+        grid.model.apply(.cellChanged(row: 0, column: 0))
+
+        #expect(grid.text(row: 0) == "B")
+    }
+
+    @Test("A reload drops every cached text")
+    func reloadDropsTheCache() {
+        let grid = DisplayGrid(TableRows(
+            rows: [Row(id: .existing(0), values: [.text("A")]), Row(id: .existing(1), values: [.text("C")])],
+            columns: ["name"],
+            columnTypes: [.text(rawType: nil)]
+        ))
+        #expect(grid.text(row: 0) == "A")
+        #expect(grid.text(row: 1) == "C")
+
+        grid.owner.tableRows.rows[0].values[0] = .text("B")
+        grid.owner.tableRows.rows[1].values[0] = .text("D")
+        grid.model.reloadRows()
+
+        #expect(grid.text(row: 0) == "B")
+        #expect(grid.text(row: 1) == "D")
+    }
+
+    @Test("A display format change recomputes cached binary values")
+    func displayFormatChangesRecomputeBinaryValues() throws {
+        let grid = DisplayGrid(Self.binaryRows)
+        let column = try #require(grid.model.columns.column(at: 0))
+        #expect(grid.text(row: 0) == Self.rawBinaryText)
+
+        grid.model.setDisplayFormat(.uuid, for: column)
+        #expect(grid.text(row: 0) == Self.uuidText)
+
+        grid.model.setDisplayFormat(.raw, for: column)
+        #expect(grid.text(row: 0) == Self.rawBinaryText)
+    }
+
+    @Test("A display format is kept in the grid's store, where its owner reads it")
+    func displayFormatIsWrittenToTheStore() throws {
+        let grid = DisplayGrid(Self.binaryRows)
+        let column = try #require(grid.model.columns.column(at: 0))
+
+        grid.model.setDisplayFormat(.uuid, for: column)
+
+        #expect(grid.model.store.displayFormats == [.uuid])
+        #expect(grid.model.displayFormat(for: column) == .uuid)
+    }
+
+    @Test("Reformatting for a settings change keeps a manual display format")
+    func reformattingKeepsAManualFormat() throws {
+        let hosted = HostedDataGrid(rows: Self.binaryRows)
+        defer { hosted.close() }
+        let column = try #require(hosted.model.columns.column(at: 0))
+        hosted.model.setDisplayFormat(.uuid, for: column)
+
+        hosted.controller.reformatText()
+
+        #expect(hosted.model.store.displayFormats == [.uuid])
+        let text = Self.text(of: hosted.model, presenter: hosted.controller.presenter, row: 0, column: 0)
+        #expect(text == Self.uuidText)
+    }
+
+    @Test("The background prewarm formats the rows around the viewport and no further")
+    func prewarmCachesAroundTheViewport() async throws {
+        let rowCount = DataGridPrewarmWindow.margin * 3
+        let rows = TableRows.from(
+            queryRows: (0..<rowCount).map { [PluginCellValue.text("row \($0)")] },
+            columns: ["name"],
+            columnTypes: [.text(rawType: "TEXT")]
+        )
+        let hosted = HostedDataGrid(rows: rows)
+        defer { hosted.close() }
+        let cache = hosted.model.display.cache
+        let edge = RowID.existing(DataGridPrewarmWindow.margin)
+
+        try await waitUntil { cache.box(forID: edge) != nil }
+
+        #expect(cache.box(forID: .existing(rowCount - 1)) == nil)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridEditingTests.swift b/apple/TableProTests/Views/DataGrid/DataGridEditingTests.swift
new file mode 100644
index 0000000000..3ba71aaa0e
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridEditingTests.swift
@@ -0,0 +1,954 @@
+//
+//  DataGridEditingTests.swift
+//  TableProTests
+//
+
+import AppKit
+import SwiftUI
+@testable import TablePro
+import TableProPluginKit
+import TableProTheme
+import Testing
+
+@MainActor
+final class EditingGridOwner: DataGridDataSource, DataGridActions {
+    var tableRows: TableRows
+    let changeState = AnyChangeManager(DataChangeManager())
+    weak var model: DataGridModel?
+    private(set) var commits: [(edits: [DataGridResolvedEdit], actionName: String)] = []
+    private(set) var loadRequests: [[RowID]] = []
+    var loadsValue: ((inout TableRows) -> Void)?
+
+    init(_ tableRows: TableRows) {
+        self.tableRows = tableRows
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        commits.append((edits, actionName))
+        var positions = Set<CellPosition>()
+        for edit in edits {
+            guard let index = tableRows.index(of: edit.rowID) else { continue }
+            _ = tableRows.edit(row: index, column: edit.dataIndex, value: edit.newValue, isAbsent: edit.absence.isAbsent)
+            positions.insert(CellPosition(row: index, column: edit.dataIndex))
+        }
+        model?.apply(.cellsChanged(positions))
+        return true
+    }
+
+    func gridLoadUnloadedValues(rowIDs: [RowID], columns: IndexSet?, completion: @escaping @MainActor (Bool) -> Void) {
+        loadRequests.append(rowIDs)
+        guard let loadsValue else {
+            completion(false)
+            return
+        }
+        loadsValue(&tableRows)
+        model?.reloadRows()
+        completion(true)
+    }
+
+    var committedValues: [PluginCellValue] {
+        commits.flatMap { $0.edits.map(\.newValue) }
+    }
+}
+
+// A real controller in a window, with the edit cell mounted the way AppKit mounts it.
+@MainActor
+struct EditingGrid {
+    let window: NSWindow
+    let controller: DataGridViewController
+    let model: DataGridModel
+    let owner: EditingGridOwner
+
+    static let people = TableRows.from(
+        queryRows: [
+            [.text("0"), .text("ann")],
+            [.text("1"), .text("bob")],
+            [.text("2"), .text("cid")],
+        ],
+        columns: ["id", "name"],
+        columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+    )
+
+    static var editable: DataGridConfiguration {
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        configuration.showRowNumbers = true
+        return configuration
+    }
+
+    init(
+        rows: TableRows = EditingGrid.people,
+        configuration: DataGridConfiguration = EditingGrid.editable,
+        store: any DataGridStateStore = InMemoryDataGridStateStore(),
+        themeScope: ThemeScope = .live
+    ) {
+        let owner = EditingGridOwner(rows)
+        let model = DataGridModel(store: store, configuration: configuration, themeScope: themeScope)
+        model.dataSource = owner
+        model.actions = owner
+        owner.model = model
+        model.reloadRows()
+        let controller = DataGridViewController(model: model)
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 800, height: 400),
+            styleMask: [.titled, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        controller.view.frame = NSRect(x: 0, y: 0, width: 800, height: 400)
+        window.contentViewController = controller
+        window.setContentSize(NSSize(width: 800, height: 400))
+        controller.view.layoutSubtreeIfNeeded()
+        self.owner = owner
+        self.model = model
+        self.controller = controller
+        self.window = window
+    }
+
+    var cellView: DataGridEditingCellView { controller.editingState.editingCellView }
+
+    var fieldEditor: NSTextView? {
+        cellView.field.currentEditor() as? NSTextView
+    }
+
+    func type(_ text: String) {
+        fieldEditor?.string = text
+    }
+
+    @discardableResult
+    func send(_ selector: Selector) -> Bool {
+        guard let fieldEditor else { return false }
+        return controller.fieldEditor(fieldEditor, doCommandBy: selector)
+    }
+
+    func mountedEditCell(in pane: DataGridPane, row: Int, displayColumn: Int) -> DataGridEditingCellView? {
+        guard let index = pane.tableIndex(forDisplayPosition: displayColumn, columns: model.columns),
+              row < pane.tableView.numberOfRows else { return nil }
+        return pane.tableView.view(atColumn: index, row: row, makeIfNecessary: false) as? DataGridEditingCellView
+    }
+
+    func select(_ row: Int, _ column: Int) {
+        model.setSelection(GridSelectionReducer.single(GridCoord(row: row, displayColumn: column)))
+    }
+
+    func tearDown() {
+        controller.discardCellEditing()
+        controller.dismantle()
+        window.orderOut(nil)
+    }
+}
+
+@MainActor
+struct DataGridEditingTests {
+    // MARK: - Field lifecycle
+
+    @Test("Beginning an edit mounts the field in that one cell and hands it the field editor")
+    func beginMountsTheField() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+
+        #expect(grid.controller.beginEditingCell(row: 1, displayColumn: 1))
+
+        #expect(grid.controller.editedCell == GridCoord(row: 1, displayColumn: 1))
+        #expect(grid.model.isEditing)
+        #expect(grid.mountedEditCell(in: grid.controller.main, row: 1, displayColumn: 1) === grid.cellView)
+        #expect(grid.mountedEditCell(in: grid.controller.main, row: 0, displayColumn: 1) == nil)
+        #expect(grid.fieldEditor?.string == "bob")
+    }
+
+    @Test("Return commits once, by the record the edit opened on, and unmounts the field")
+    func returnCommitsByRowID() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 1, displayColumn: 1)
+        grid.type("zed")
+
+        #expect(grid.send(#selector(NSResponder.insertNewline(_:))))
+
+        let edit = try #require(grid.owner.commits.first?.edits.first)
+        #expect(grid.owner.commits.count == 1)
+        #expect(grid.owner.commits.first?.actionName == "Edit Cell")
+        #expect(edit.rowID == .existing(1))
+        #expect(edit.dataIndex == 1)
+        #expect(edit.newValue == .text("zed"))
+        #expect(grid.controller.editedCell == nil)
+        #expect(!grid.model.isEditing)
+        #expect(grid.mountedEditCell(in: grid.controller.main, row: 1, displayColumn: 1) == nil)
+    }
+
+    @Test("Return on text the editor opened with commits nothing, even over a NULL that reads as empty")
+    func unchangedTextCommitsNothing() {
+        let rows = TableRows.from(
+            queryRows: [[.text("0"), .null]],
+            columns: ["id", "note"],
+            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+        )
+        let grid = EditingGrid(rows: rows)
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+
+        grid.send(#selector(NSResponder.insertNewline(_:)))
+
+        #expect(grid.owner.commits.isEmpty)
+    }
+
+    @Test("Escape drops what was typed and ends the edit")
+    func escapeDiscards() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        grid.type("zed")
+
+        #expect(grid.send(#selector(NSResponder.cancelOperation(_:))))
+
+        #expect(grid.owner.commits.isEmpty)
+        #expect(!grid.model.isEditing)
+        #expect(grid.controller.editedCell == nil)
+    }
+
+    @Test("The owner's commitEditing keeps the text and discardEditing drops it")
+    func ownerCommitAndDiscard() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        grid.type("one")
+
+        #expect(grid.model.commitEditing())
+        #expect(grid.owner.committedValues == [.text("one")])
+
+        grid.controller.beginEditingCell(row: 1, displayColumn: 1)
+        grid.type("two")
+        grid.model.discardEditing()
+
+        #expect(grid.owner.committedValues == [.text("one")])
+        #expect(!grid.model.isEditing)
+    }
+
+    @Test("An owner waiting for the edit hears once that it ended")
+    func editingEndedIsReportedOnce() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        var ended = 0
+        grid.model.onEditingEnded = { ended += 1 }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        grid.type("zed")
+
+        grid.send(#selector(NSResponder.insertNewline(_:)))
+
+        #expect(ended == 1)
+    }
+
+    @Test("A locked column refuses the edit")
+    func lockedColumnRefuses() {
+        var configuration = EditingGrid.editable
+        configuration.lockedColumns = ["name"]
+        let grid = EditingGrid(configuration: configuration)
+        defer { grid.tearDown() }
+
+        #expect(!grid.controller.beginEditingCell(row: 0, displayColumn: 1))
+        #expect(!grid.model.isEditing)
+    }
+
+    // MARK: - Moving between cells
+
+    @Test("Tab commits and edits the next cell, wrapping onto the next row")
+    func tabMovesAndWraps() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.select(0, 1)
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        grid.type("zed")
+
+        grid.send(#selector(NSResponder.insertTab(_:)))
+
+        #expect(grid.owner.committedValues == [.text("zed")])
+        #expect(grid.model.selection.activeCell == GridCoord(row: 1, displayColumn: 0))
+        #expect(grid.controller.editedCell == GridCoord(row: 1, displayColumn: 0))
+        #expect(grid.fieldEditor?.string == "1")
+    }
+
+    @Test("Shift-Tab walks back onto the previous row's last column")
+    func backtabWrapsBack() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 1, displayColumn: 0)
+
+        grid.send(#selector(NSResponder.insertBacktab(_:)))
+
+        #expect(grid.controller.editedCell == GridCoord(row: 0, displayColumn: 1))
+    }
+
+    @Test("Tab at the last cell commits and stays there")
+    func tabStopsAtTheLastCell() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 2, displayColumn: 1)
+        grid.type("zed")
+
+        grid.send(#selector(NSResponder.insertTab(_:)))
+
+        #expect(grid.owner.committedValues == [.text("zed")])
+        #expect(grid.controller.editedCell == nil)
+        #expect(grid.model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+    }
+
+    @Test("Down commits and edits the same column a row below; it stops at the last row")
+    func downHoldsTheColumn() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 1, displayColumn: 1)
+
+        grid.send(#selector(NSResponder.moveDown(_:)))
+        #expect(grid.controller.editedCell == GridCoord(row: 2, displayColumn: 1))
+
+        grid.send(#selector(NSResponder.moveDown(_:)))
+        #expect(grid.controller.editedCell == nil)
+        #expect(grid.model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+    }
+
+    @Test("Up on the first row commits and does not wrap")
+    func upStopsAtTheFirstRow() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+
+        grid.send(#selector(NSResponder.moveUp(_:)))
+
+        #expect(grid.controller.editedCell == nil)
+    }
+
+    // Reaching for a cell's accessibility element marks the grid active, which mounts a view per visible cell (#2381).
+    @Test("Moving the editor leaves the accessibility layout alone")
+    func movingLeavesAccessibilityAlone() {
+        let wasActive = DataGridAccessibility.isActive
+        DataGridAccessibility.isActive = false
+        defer { DataGridAccessibility.isActive = wasActive }
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 0)
+
+        grid.send(#selector(NSResponder.insertTab(_:)))
+
+        #expect(!DataGridAccessibility.isActive)
+    }
+
+    // MARK: - Identity across changes (H2)
+
+    @Test("A reorder under an open editor moves it with its record, and the commit lands there")
+    func editFollowsItsRecordAcrossAReorder() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 1, displayColumn: 1)
+        grid.type("zed")
+
+        let reversed = ContiguousArray(grid.owner.tableRows.rows.reversed())
+        grid.owner.tableRows.reorderRows(reversed)
+        grid.model.reloadRows()
+
+        #expect(grid.controller.editedCell == GridCoord(row: 1, displayColumn: 1))
+        #expect(grid.fieldEditor?.string == "zed")
+        let current = grid.owner.tableRows
+        grid.owner.tableRows.reorderRows(ContiguousArray([2, 0, 1].compactMap { current.row(withID: .existing($0)) }))
+        grid.model.reloadRows()
+        #expect(grid.controller.editedCell == GridCoord(row: 2, displayColumn: 1))
+
+        grid.send(#selector(NSResponder.insertNewline(_:)))
+        let edit = try #require(grid.owner.commits.first?.edits.first)
+        #expect(edit.rowID == .existing(1))
+        #expect(grid.owner.tableRows.row(withID: .existing(1))?.values[1] == .text("zed"))
+    }
+
+    @Test("A new result that reuses the RowID for another record drops the edit instead of writing into it")
+    func replacedRecordDropsTheEdit() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 1, displayColumn: 1)
+        grid.type("zed")
+
+        grid.owner.tableRows = TableRows.from(
+            queryRows: [[.text("7"), .text("gus")], [.text("8"), .text("hal")]],
+            columns: ["id", "name"],
+            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+        )
+        grid.model.reloadRows()
+
+        #expect(!grid.model.isEditing)
+        #expect(grid.owner.commits.isEmpty)
+    }
+
+    @Test("A value filter that hides the edited row keeps what was typed")
+    func filterHidingTheRowCommits() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 1, displayColumn: 1)
+        grid.type("zed")
+
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["ann"], includesNull: false), columnName: "name", forColumn: 1)
+        grid.model.setValueFilter(filter)
+
+        let edit = try #require(grid.owner.commits.first?.edits.first)
+        #expect(edit.rowID == .existing(1))
+        #expect(!grid.model.isEditing)
+    }
+
+    // MARK: - Panes
+
+    @Test("A frozen cell edits in the frozen pane, over its home in the main table")
+    func frozenCellEditsInTheFrozenPane() {
+        var layout = ColumnLayoutState()
+        layout.frozenColumnCount = 1
+        let grid = EditingGrid(store: InMemoryDataGridStateStore(columnLayout: layout))
+        defer { grid.tearDown() }
+        grid.controller.containerDidLayout()
+        guard grid.controller.effectiveFrozenCount == 1 else {
+            Issue.record("the frozen pane did not take the column")
+            return
+        }
+
+        #expect(grid.controller.beginEditingCell(row: 0, displayColumn: 0))
+
+        #expect(grid.controller.editingState.session?.pane == .frozen)
+        #expect(grid.mountedEditCell(in: grid.controller.frozen, row: 0, displayColumn: 0) === grid.cellView)
+        #expect(grid.mountedEditCell(in: grid.controller.main, row: 0, displayColumn: 0) == nil)
+        #expect(grid.fieldEditor != nil)
+    }
+
+    // MARK: - The popover editor
+
+    @Test("Option-Return hands the text to the popover editor with the line break where the caret was")
+    func optionReturnMovesToThePopover() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        grid.type("ab")
+        grid.fieldEditor?.setSelectedRange(NSRange(location: 1, length: 0))
+
+        grid.send(#selector(NSResponder.insertNewlineIgnoringFieldEditor(_:)))
+
+        let popover = try #require(grid.controller.editingState.textPopover)
+        #expect(popover.isEditable)
+        #expect(popover.textView.string == "a\nb")
+        #expect(grid.controller.editingState.session?.editor == .textPopover)
+        #expect(grid.controller.editedCell == nil)
+
+        #expect(grid.model.commitEditing())
+        #expect(grid.owner.committedValues == [.text("a\nb")])
+    }
+
+    // Single-line mode drops a pasted line break, so only text that has one leaves the field.
+    @Test("Pasting text with a line break hands the edit to the popover editor with the text in place")
+    func multiLinePasteMovesToThePopover() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        grid.type("ab")
+        let editor = try #require(grid.fieldEditor)
+        editor.setSelectedRange(NSRange(location: 1, length: 0))
+        let pasteboard = NSPasteboard(name: NSPasteboard.Name("com.TablePro.tests.grid.paste"))
+        pasteboard.clearContents()
+        pasteboard.setString("z", forType: .string)
+
+        #expect(editor.readSelection(from: pasteboard, type: .string))
+        #expect(grid.controller.editedCell != nil)
+        #expect(grid.controller.editingState.textPopover == nil)
+
+        pasteboard.clearContents()
+        pasteboard.setString("x\ny", forType: .string)
+        #expect(editor.readSelection(from: pasteboard, type: .string))
+
+        let popover = try #require(grid.controller.editingState.textPopover)
+        #expect(popover.textView.string == "azx\nyb")
+        #expect(grid.controller.editingState.session?.editor == .textPopover)
+        #expect(grid.controller.editedCell == nil)
+
+        #expect(grid.model.commitEditing())
+        #expect(grid.owner.committedValues == [.text("azx\nyb")])
+    }
+
+    @Test("A value with a line break opens the popover editor instead of the field")
+    func multiLineValueOpensThePopover() throws {
+        let rows = TableRows.from(
+            queryRows: [[.text("0"), .text("line1\nline2")]],
+            columns: ["id", "note"],
+            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+        )
+        let grid = EditingGrid(rows: rows)
+        defer { grid.tearDown() }
+
+        grid.controller.openEditor(at: GridCoord(row: 0, displayColumn: 1))
+
+        let popover = try #require(grid.controller.editingState.textPopover)
+        #expect(popover.isEditable)
+        #expect(grid.controller.editedCell == nil)
+        #expect(grid.model.isEditing)
+    }
+
+    @Test("A read-only cell opens the viewer, which edits nothing")
+    func readOnlyCellOpensTheViewer() throws {
+        var configuration = EditingGrid.editable
+        configuration.isEditable = false
+        let grid = EditingGrid(configuration: configuration)
+        defer { grid.tearDown() }
+
+        grid.controller.openEditor(at: GridCoord(row: 0, displayColumn: 1))
+
+        let viewer = try #require(grid.controller.editingState.textPopover)
+        #expect(!viewer.isEditable)
+        #expect(!viewer.textView.isEditable)
+        #expect(viewer.textView.string == "ann")
+        #expect(!grid.model.isEditing)
+    }
+
+    // MARK: - Unloaded values (#3758)
+
+    @Test("Editing a value the page left on the server loads it first, then edits the loaded value")
+    func unloadedValueLoadsFirst() {
+        let rows = TableRows.from(
+            queryRows: [[.text("0"), .null]],
+            columns: ["id", "body"],
+            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")],
+            unloadedCells: [0: [1: 4_096]]
+        )
+        let grid = EditingGrid(rows: rows)
+        defer { grid.tearDown() }
+        grid.owner.loadsValue = { rows in
+            rows = TableRows.from(
+                queryRows: [[.text("0"), .text("loaded")]],
+                columns: ["id", "body"],
+                columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+            )
+        }
+
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+
+        #expect(grid.owner.loadRequests == [[.existing(0)]])
+        #expect(grid.controller.editedCell == GridCoord(row: 0, displayColumn: 1))
+        #expect(grid.fieldEditor?.string == "loaded")
+    }
+
+    @Test("A value that fails to load opens no editor")
+    func unloadedValueThatFailsOpensNothing() {
+        let rows = TableRows.from(
+            queryRows: [[.text("0"), .null]],
+            columns: ["id", "body"],
+            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")],
+            unloadedCells: [0: [1: 4_096]]
+        )
+        let grid = EditingGrid(rows: rows)
+        defer { grid.tearDown() }
+
+        #expect(!grid.controller.beginEditingCell(row: 0, displayColumn: 1))
+        #expect(grid.owner.loadRequests.count == 1)
+        #expect(!grid.model.isEditing)
+    }
+
+    // MARK: - Typed popovers
+
+    @Test("commitEditing and discardEditing close a typed editor and the detached JSON window")
+    func commitClosesTypedEditors() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        let state = grid.controller.editingState
+        let cell = try #require(grid.controller.editCell(at: GridCoord(row: 0, displayColumn: 1)))
+
+        let popover = EditingCloseCountingPopover()
+        state.typedPopover = popover
+        state.typedPopoverRow = grid.controller.heldRow(cell)
+        state.typedPopoverEdits = true
+        let window = JSONViewerWindowController()
+        state.poppedOutEditor = window
+        state.poppedOutRow = grid.controller.heldRow(cell)
+        #expect(grid.model.isEditing)
+
+        #expect(grid.model.commitEditing())
+        #expect(popover.closeCount == 1)
+        #expect(state.typedPopover == nil)
+        #expect(state.poppedOutEditor == nil)
+        #expect(!grid.model.isEditing)
+
+        let second = EditingCloseCountingPopover()
+        state.typedPopover = second
+        grid.model.discardEditing()
+        #expect(second.closeCount == 1)
+        #expect(state.typedPopover == nil)
+    }
+
+    // An .applicationDefined editor stays until something closes it; forgetting it would strand it on screen.
+    @Test("Opening another typed editor closes the first instead of forgetting it")
+    func secondTypedEditorClosesTheFirst() {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        let first = EditingCloseCountingPopover()
+        first.behavior = .applicationDefined
+        grid.controller.editingState.typedPopover = first
+
+        grid.controller.closeTypedPopover()
+
+        #expect(first.closeCount == 1)
+        #expect(grid.controller.editingState.typedPopover == nil)
+    }
+
+    // AppKit posts a closed popover's didClose once it finishes animating out, after the next one is shown.
+    @Test("The replaced typed editor closing late leaves the open one tracked")
+    func lateCloseOfTheReplacedEditorKeepsTheOpenOne() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        let state = grid.controller.editingState
+        let first = try #require(grid.controller.editCell(at: GridCoord(row: 0, displayColumn: 1)))
+        let second = try #require(grid.controller.editCell(at: GridCoord(row: 1, displayColumn: 1)))
+        let replaced = try #require(grid.controller.presentTypedPopover(for: first, edits: true) { _ in EmptyView() })
+        let open = try #require(grid.controller.presentTypedPopover(for: second, edits: true) { _ in EmptyView() })
+
+        state.typedPopoverObserver.popoverDidClose(Notification(name: NSPopover.didCloseNotification, object: replaced))
+
+        #expect(state.typedPopover === open)
+        #expect(state.typedPopoverRow?.target.rowID == .existing(1))
+        #expect(grid.model.isEditing)
+
+        state.typedPopoverObserver.popoverDidClose(Notification(name: NSPopover.didCloseNotification, object: open))
+
+        #expect(state.typedPopover == nil)
+        #expect(!grid.model.isEditing)
+    }
+
+    @Test("A reload that keeps the record keeps its typed editor; one that replaces it closes the editor")
+    func reloadKeepsOrClosesTypedEditor() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        let state = grid.controller.editingState
+        let cell = try #require(grid.controller.editCell(at: GridCoord(row: 1, displayColumn: 1)))
+        let popover = EditingCloseCountingPopover()
+        state.typedPopover = popover
+        state.typedPopoverRow = grid.controller.heldRow(cell)
+
+        let reversed = ContiguousArray(grid.owner.tableRows.rows.reversed())
+        grid.owner.tableRows.reorderRows(reversed)
+        grid.model.reloadRows()
+        #expect(state.typedPopover === popover)
+        #expect(popover.closeCount == 0)
+
+        grid.owner.tableRows = TableRows.from(
+            queryRows: [[.text("7"), .text("gus")], [.text("8"), .text("hal")]],
+            columns: ["id", "name"],
+            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+        )
+        grid.model.reloadRows()
+        #expect(state.typedPopover == nil)
+        #expect(popover.closeCount == 1)
+    }
+
+    @Test("The detached JSON window stays while its record does and closes once it is gone")
+    func poppedOutWindowFollowsItsRecord() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        let state = grid.controller.editingState
+        let cell = try #require(grid.controller.editCell(at: GridCoord(row: 2, displayColumn: 1)))
+        let window = JSONViewerWindowController()
+        state.poppedOutEditor = window
+        state.poppedOutRow = grid.controller.heldRow(cell)
+
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["ann"], includesNull: false), columnName: "name", forColumn: 1)
+        grid.model.setValueFilter(filter)
+        #expect(state.poppedOutEditor === window)
+
+        _ = grid.owner.tableRows.remove(at: IndexSet(integer: 2))
+        grid.model.apply(.rowsRemoved(IndexSet(integer: 2)))
+        #expect(state.poppedOutEditor == nil)
+    }
+
+    // MARK: - SET picker (interaction 1)
+
+    @Test("Picking a SET value commits from the item itself, keeping the declared order")
+    func setPickCommitsFromTheItem() throws {
+        var committed: [String] = []
+        let menu = EnumMenuPicker.makeSetMenu(allowedValues: ["a", "b", "c"], currentCsv: "c") { committed.append($0) }
+
+        menu.performActionForItem(at: 0)
+
+        #expect(committed == ["a,c"])
+    }
+
+    @Test("Unticking the only SET value commits the empty set, and a value outside the declaration stays last")
+    func setUntickAndDrift() {
+        var committed: [String] = []
+        let menu = EnumMenuPicker.makeSetMenu(allowedValues: ["a", "b"], currentCsv: "a, zz") { committed.append($0) }
+
+        menu.performActionForItem(at: 1)
+        menu.performActionForItem(at: 0)
+
+        #expect(committed == ["a,b,zz", "zz"])
+    }
+
+    // MARK: - Accessibility
+
+    // A text field's element is its cell, which reads nothing set on the control (measured on macOS 27).
+    @Test("The edit field's element is named for its column")
+    func fieldIsNamedForItsColumn() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        let element = try #require(grid.cellView.field.cell)
+
+        #expect(element.isAccessibilityElement())
+        #expect(element.accessibilityRole() == .textField)
+        #expect(element.accessibilityLabel() == "name")
+        #expect(element.accessibilityIdentifier() == "data-grid-edit-field")
+    }
+}
+
+// The popover editor reads the four movement selectors a field editor would turn into an NSTextMovement (#2569).
+@MainActor
+struct DataGridTextEditorPopoverTests {
+    private struct Outcome {
+        let handled: Bool
+        let ending: DataGridTextEditorPopover.Ending?
+        let text: String?
+    }
+
+    private func makePopover(_ value: String, selection: NSRange, isEditable: Bool = true) -> DataGridTextEditorPopover {
+        let popover = DataGridTextEditorPopover(text: value, isEditable: isEditable, cellWidth: 120, scope: .live)
+        popover.textView.setSelectedRange(selection)
+        return popover
+    }
+
+    private func send(_ selector: Selector, to popover: DataGridTextEditorPopover) -> Outcome {
+        var ending: DataGridTextEditorPopover.Ending?
+        var text: String?
+        popover.onEnd = { reported, reportedText in
+            ending = reported
+            text = reportedText
+        }
+        let handled = popover.textView(popover.textView, doCommandBy: selector)
+        return Outcome(handled: handled, ending: ending, text: text)
+    }
+
+    @Test("Return commits what was typed and Escape cancels it")
+    func returnCommitsEscapeCancels() {
+        let committed = makePopover("a\nb", selection: NSRange(location: 0, length: 0))
+        committed.textView.string = "a\nbc"
+        let returned = send(#selector(NSResponder.insertNewline(_:)), to: committed)
+        #expect(returned.handled)
+        #expect(returned.ending == .commit(nil))
+        #expect(returned.text == "a\nbc")
+
+        let cancelled = send(#selector(NSResponder.cancelOperation(_:)), to: makePopover("a\nb", selection: NSRange(location: 0, length: 0)))
+        #expect(cancelled.handled)
+        #expect(cancelled.ending == .cancel)
+    }
+
+    // Option-Return is insertNewlineIgnoringFieldEditor:, which a plain text view answers with a line break.
+    @Test("Option-Return is left to the text view, which inserts the line break")
+    func optionReturnInsertsALineBreak() {
+        let result = send(#selector(NSResponder.insertNewlineIgnoringFieldEditor(_:)), to: makePopover("ab", selection: NSRange(location: 1, length: 0)))
+
+        #expect(!result.handled)
+        #expect(result.ending == nil)
+    }
+
+    @Test("Down leaves a single-line value for the row below, Up for the row above")
+    func arrowsLeaveASingleLine() {
+        let down = send(#selector(NSResponder.moveDown(_:)), to: makePopover("alpha", selection: NSRange(location: 0, length: 5)))
+        let up = send(#selector(NSResponder.moveUp(_:)), to: makePopover("alpha", selection: NSRange(location: 2, length: 0)))
+
+        #expect(down.handled)
+        #expect(down.ending == .commit(.down))
+        #expect(up.handled)
+        #expect(up.ending == .commit(.up))
+    }
+
+    @Test("Down inside a multi-line value stays in the text, and leaves from its last line")
+    func downFollowsTheValuesLines() {
+        let inside = send(#selector(NSResponder.moveDown(_:)), to: makePopover("a\nb\nc", selection: NSRange(location: 0, length: 0)))
+        let last = send(#selector(NSResponder.moveDown(_:)), to: makePopover("a\nb\nc", selection: NSRange(location: 5, length: 0)))
+
+        #expect(!inside.handled)
+        #expect(inside.ending == nil)
+        #expect(last.handled)
+        #expect(last.ending == .commit(.down))
+    }
+
+    @Test("A selection-extending arrow is left to the text view")
+    func extendingArrowIsLeftAlone() {
+        let result = send(#selector(NSResponder.moveDownAndModifySelection(_:)), to: makePopover("alpha", selection: NSRange(location: 0, length: 0)))
+
+        #expect(!result.handled)
+        #expect(result.ending == nil)
+    }
+
+    @Test("Tab and Shift-Tab commit and report their own movements")
+    func tabAndBacktabMove() {
+        let forward = send(#selector(NSResponder.insertTab(_:)), to: makePopover("alpha", selection: NSRange(location: 0, length: 0)))
+        let backward = send(#selector(NSResponder.insertBacktab(_:)), to: makePopover("alpha", selection: NSRange(location: 0, length: 0)))
+
+        #expect(forward.ending == .commit(.tab))
+        #expect(backward.ending == .commit(.backtab))
+    }
+
+    // Until the input method commits, the text view holds provisional text a movement would save.
+    @Test("During an IME composition an arrow moves through it and Tab is swallowed")
+    func compositionOwnsTheKeys() {
+        func composing() -> DataGridTextEditorPopover {
+            let popover = makePopover("", selection: NSRange(location: 0, length: 0))
+            popover.textView.setMarkedText(
+                "\u{304B}",
+                selectedRange: NSRange(location: 1, length: 0),
+                replacementRange: NSRange(location: 0, length: 0)
+            )
+            return popover
+        }
+        let arrow = send(#selector(NSResponder.moveDown(_:)), to: composing())
+        let tab = send(#selector(NSResponder.insertTab(_:)), to: composing())
+
+        #expect(!arrow.handled)
+        #expect(arrow.ending == nil)
+        #expect(tab.handled)
+        #expect(tab.ending == nil)
+    }
+
+    @Test("The viewer closes on Return, Escape and Tab and never commits; its arrows move through the text")
+    func viewerKeys() {
+        for selector in [#selector(NSResponder.insertNewline(_:)), #selector(NSResponder.cancelOperation(_:)), #selector(NSResponder.insertTab(_:))] {
+            let result = send(selector, to: makePopover("3", selection: NSRange(location: 0, length: 0), isEditable: false))
+            #expect(result.ending == .cancel)
+        }
+        let arrow = send(#selector(NSResponder.moveDown(_:)), to: makePopover("3", selection: NSRange(location: 0, length: 0), isEditable: false))
+        #expect(!arrow.handled)
+    }
+
+    @Test("The viewer is a text area holding the value")
+    func viewerAccessibility() {
+        let viewer = makePopover("3", selection: NSRange(location: 0, length: 0), isEditable: false)
+
+        #expect(viewer.textView.accessibilityRole() == .textArea)
+        #expect(viewer.textView.accessibilityValue() as? String == "3")
+    }
+
+    @Test("A popover reports its ending once")
+    func endsOnce() {
+        let popover = makePopover("x", selection: NSRange(location: 0, length: 0))
+        var endings: [DataGridTextEditorPopover.Ending] = []
+        popover.onEnd = { ending, _ in endings.append(ending) }
+
+        popover.end(.commit(nil))
+        popover.end(.cancel)
+        popover.popoverDidClose(Notification(name: NSPopover.didCloseNotification))
+
+        #expect(endings == [.commit(nil)])
+    }
+
+    // MARK: - Layout
+
+    // Wrapping lays a paragraph out whole before the popover appears (#2381), so only a value under the limit wraps.
+    @Test("A value under the limit wraps to the popover's width; one past it scrolls sideways")
+    func wrapsUnderTheLimit() throws {
+        let short = NSTextView(usingTextLayoutManager: true)
+        DataGridTextEditorPopover.applyLayout(to: short, for: "some text", width: 300)
+        let shortContainer = try #require(short.textContainer)
+        #expect(shortContainer.widthTracksTextView)
+        #expect(!short.isHorizontallyResizable)
+
+        let long = String(repeating: "some cell value ", count: DataGridTextEditorPopover.wrapLimit / 16 + 1)
+        let wide = NSTextView(usingTextLayoutManager: true)
+        DataGridTextEditorPopover.applyLayout(to: wide, for: long, width: 300)
+        let wideContainer = try #require(wide.textContainer)
+        #expect(!wideContainer.widthTracksTextView)
+        #expect(wide.isHorizontallyResizable)
+        #expect(wide.maxSize.width == CGFloat.greatestFiniteMagnitude)
+    }
+
+    // A text view grows only as far as maxSize, so a value past the limit would be clipped at the popover's edge.
+    @Test("A value past the limit makes the editor scrollable rather than clipping it")
+    func longValueScrolls() throws {
+        let long = String(repeating: "some cell value ", count: DataGridTextEditorPopover.wrapLimit / 16 + 1)
+        let popover = DataGridTextEditorPopover(text: long, isEditable: true, cellWidth: 120, scope: .live)
+        let layoutManager = try #require(popover.textView.textLayoutManager, "the editor has to be on TextKit 2")
+        layoutManager.ensureLayout(for: layoutManager.documentRange)
+        popover.textView.layout()
+
+        #expect(popover.textView.frame.width > 1_000)
+    }
+
+    @Test("The edit field holds one line that scrolls rather than wraps")
+    func fieldIsOneLine() throws {
+        let field = DataGridEditingTextField(frame: NSRect(x: 0, y: 0, width: 100, height: 20))
+        let cell = try #require(field.cell)
+
+        #expect(field.usesSingleLineMode)
+        #expect(!cell.wraps)
+        #expect(cell.isScrollable)
+        #expect(field.isEditable)
+    }
+
+    // MARK: - Appearance
+
+    @Test("Under the default theme the field and its field editor keep the system colors")
+    func defaultThemeIsNative() {
+        let grid = EditingGrid(themeScope: .fixed(BuiltInThemes.light))
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+
+        #expect(ThemeTestFixture.hex(grid.cellView.field.textColor) == ThemeTestFixture.hex(.textColor))
+        #expect(ThemeTestFixture.hex(grid.cellView.field.backgroundColor) == ThemeTestFixture.hex(.textBackgroundColor))
+        #expect(grid.fieldEditor === grid.cellView.field.ownFieldEditor)
+    }
+
+    @Test("Under a theme the field, its field editor and the popover take the editor colors, and give them back")
+    func themeReachesTheEditors() throws {
+        var theme = try ThemeTestFixture.theme(.light, [
+            .editorBackground: "#282A36",
+            .editorText: "#F8F8F2",
+            .editorCursor: "#FF79C6",
+            .editorSelection: "#44475A",
+        ])
+        theme.id = "test.grid-editor"
+        let scope = ThemeScope.fixed(theme)
+        let grid = EditingGrid(themeScope: scope)
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        let editor = try #require(grid.fieldEditor)
+
+        #expect(ThemeTestFixture.hex(grid.cellView.field.textColor) == "#F8F8F2")
+        #expect(ThemeTestFixture.hex(grid.cellView.field.backgroundColor) == "#282A36")
+        #expect(ThemeTestFixture.hex(editor.insertionPointColor) == "#FF79C6")
+        #expect(ThemeTestFixture.hex(editor.selectedTextAttributes[.backgroundColor] as? NSColor) == "#44475A")
+
+        // Its own field editor, so the caret color never stays on the window's shared one.
+        #expect(editor === grid.cellView.field.ownFieldEditor)
+        #expect(editor !== grid.window.fieldEditor(false, for: nil))
+
+        let popover = DataGridTextEditorPopover(text: "value", isEditable: true, cellWidth: 120, scope: scope)
+        #expect(ThemeTestFixture.hex(popover.textView.backgroundColor) == "#282A36")
+        #expect(ThemeTestFixture.hex(popover.textView.textColor) == "#F8F8F2")
+    }
+
+    // MARK: - Accessibility
+
+    // The old overlay sat outside the table, where NSTableView could not publish it; the field lives in its cell.
+    // A field outside a table hangs off the window; inside one, NSTableView parents it to its own cell element.
+    @Test("The open edit field is part of the table's accessibility tree")
+    func fieldIsInsideTheTable() throws {
+        let grid = EditingGrid()
+        defer { grid.tearDown() }
+        grid.controller.beginEditingCell(row: 0, displayColumn: 1)
+        let element = try #require(grid.cellView.field.cell)
+
+        let parent = try #require(element.accessibilityParent())
+        #expect(!(parent is NSWindow))
+        #expect(!(parent is NSView))
+    }
+}
+
+final class EditingCloseCountingPopover: NSPopover {
+    private(set) var closeCount = 0
+
+    override func close() {
+        closeCount += 1
+        super.close()
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridEmptyResultColumnsTests.swift b/apple/TableProTests/Views/DataGrid/DataGridEmptyResultColumnsTests.swift
new file mode 100644
index 0000000000..157a0294c8
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridEmptyResultColumnsTests.swift
@@ -0,0 +1,75 @@
+//
+//  DataGridEmptyResultColumnsTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+// A failed run leaves an error result with no columns and no rows under the banner, over the grid
+// that showed the previous result.
+@MainActor
+struct DataGridEmptyResultColumnsTests {
+    private static func result(_ columns: [String], rowCount: Int = 1) -> TableRows {
+        TableRows.from(
+            queryRows: (0..<rowCount).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } },
+            columns: columns,
+            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count)
+        )
+    }
+
+    private func headings(of grid: HostedDataGrid) -> [String] {
+        grid.main.tableColumns
+            .filter { $0.identifier != DataGridPane.rowNumberIdentifier }
+            .map { $0.headerCell.stringValue }
+    }
+
+    private func show(_ rows: TableRows, in grid: HostedDataGrid) {
+        grid.owner.tableRows = rows
+        grid.model.reloadRows()
+        grid.layout()
+    }
+
+    @Test("An error result takes down the headings of the result before it")
+    func errorResultDropsThePreviousHeadings() throws {
+        let grid = HostedDataGrid(rows: Self.result(["first_col", "second_col"]))
+        defer { grid.close() }
+        show(Self.result(["third_col"]), in: grid)
+        try #require(headings(of: grid) == ["third_col"])
+
+        show(TableRows(), in: grid)
+
+        #expect(headings(of: grid).isEmpty)
+        #expect(grid.main.numberOfRows == 0)
+        #expect(grid.model.columns.isEmpty)
+    }
+
+    @Test("Updating to an error result leaves what a fresh mount over it shows")
+    func updateMatchesAFreshMount() throws {
+        let updated = HostedDataGrid(rows: Self.result(["third_col"]))
+        defer { updated.close() }
+        let fresh = HostedDataGrid(rows: TableRows())
+        defer { fresh.close() }
+        try #require(fresh.main.tableColumns.map { $0.identifier } == [DataGridPane.rowNumberIdentifier])
+
+        show(TableRows(), in: updated)
+
+        #expect(updated.main.tableColumns.map { $0.identifier } == fresh.main.tableColumns.map { $0.identifier })
+        #expect(updated.frozen.tableColumns.map { $0.identifier } == fresh.frozen.tableColumns.map { $0.identifier })
+    }
+
+    @Test("The headings come back when a result with columns follows an error result")
+    func headingsReturnAfterAnErrorResult() {
+        let grid = HostedDataGrid(rows: Self.result(["third_col"]))
+        defer { grid.close() }
+        show(TableRows(), in: grid)
+
+        show(Self.result(["x"], rowCount: 2), in: grid)
+
+        #expect(headings(of: grid) == ["x"])
+        #expect(grid.main.numberOfRows == 2)
+        #expect(grid.frozen.numberOfRows == 2)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridHighlightTests.swift b/apple/TableProTests/Views/DataGrid/DataGridHighlightTests.swift
new file mode 100644
index 0000000000..dada447fc6
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridHighlightTests.swift
@@ -0,0 +1,177 @@
+//
+//  DataGridHighlightTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+private final class HighlightGrid {
+    let owner: GridTestOwner
+    let model: DataGridModel
+    let presenter: DataGridCellPresenter
+
+    init(statuses: [String]) {
+        let rows = TableRows.from(
+            queryRows: statuses.enumerated().map { index, status in [PluginCellValue.text("\(index)"), .text(status)] },
+            columns: ["id", "status"],
+            columnTypes: [.integer(rawType: "INT"), .text(rawType: "VARCHAR")]
+        )
+        owner = GridTestOwner(rows)
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        model = DataGridModel(configuration: configuration)
+        model.dataSource = owner
+        model.actions = owner
+        owner.model = model
+        owner.appliesCommits = true
+        model.reloadRows()
+        presenter = DataGridCellPresenter(model: model)
+    }
+
+    // The presenter reads the owner's rules at draw time; this is the step a row draw takes first.
+    func apply(_ rules: [HighlightRule]) {
+        owner.highlightRules = rules
+        presenter.prepareRowState(rows: model.rows)
+    }
+
+    func rowColor(_ displayRow: Int) -> HighlightColor? {
+        guard let row = model.row(at: displayRow) else { return nil }
+        presenter.prepareRowState(rows: model.rows)
+        return presenter.visualState(of: row).highlight.rowColor
+    }
+}
+
+@MainActor
+struct DataGridHighlightTests {
+    private let paid = HighlightRule(columnName: "status", value: "paid", color: .green)
+
+    @Test("Only the rows a rule matches carry its highlight")
+    func matchingRowsCarryTheHighlight() {
+        let grid = HighlightGrid(statuses: ["paid", "pending", "paid"])
+        grid.apply([paid])
+
+        #expect(grid.rowColor(0) == .green)
+        #expect(grid.rowColor(1) == nil)
+        #expect(grid.rowColor(2) == .green)
+    }
+
+    @Test("Changing the rules recolours rows already evaluated, and the same rules keep their key")
+    func changingRulesRecolours() {
+        let grid = HighlightGrid(statuses: ["paid"])
+        grid.apply([paid])
+        #expect(grid.rowColor(0) == .green)
+        let firstKey = grid.model.display.highlightRuleSetKey
+
+        var recolored = paid
+        recolored.color = .red
+        grid.apply([recolored])
+        #expect(grid.rowColor(0) == .red)
+        let secondKey = grid.model.display.highlightRuleSetKey
+        #expect(secondKey != firstKey)
+
+        grid.apply([recolored])
+        #expect(grid.model.display.highlightRuleSetKey == secondKey)
+    }
+
+    @Test("An edit that flips a rule is reflected once the edit commits")
+    func editFlipsTheHighlight() {
+        let grid = HighlightGrid(statuses: ["pending"])
+        grid.apply([paid])
+        #expect(grid.rowColor(0) == nil)
+
+        let committed = grid.model.commit(
+            [DataGridCellEdit(rowID: .existing(0), columnID: DataGridColumnID(name: "status", occurrence: 0), value: .enteredText("paid"))],
+            actionName: "Edit Cell"
+        )
+
+        #expect(committed)
+        #expect(grid.owner.tableRows.rows[0].values[1] == .text("paid"))
+        #expect(grid.rowColor(0) == .green)
+    }
+
+    @Test("Rows replaced under the same positional ids are evaluated afresh on reload")
+    func positionalIdsAreNotServedStaleHighlights() {
+        let grid = HighlightGrid(statuses: ["paid"])
+        grid.apply([paid])
+        #expect(grid.rowColor(0) == .green)
+
+        grid.owner.tableRows.rows[0].values[1] = .text("pending")
+        grid.model.reloadRows()
+
+        #expect(grid.rowColor(0) == nil)
+    }
+
+    @Test("A grid whose owner supplies its own row state is never highlighted")
+    func ownerStateSuppressesHighlights() {
+        let grid = HighlightGrid(statuses: ["paid"])
+        grid.owner.visualStates[.existing(0)] = .empty
+        grid.apply([paid])
+
+        #expect(grid.rowColor(0) == nil)
+    }
+
+    @Test("The accessibility description names the rule that coloured the cell")
+    func accessibilityDescription() throws {
+        let grid = HighlightGrid(statuses: ["paid"])
+        grid.apply([paid])
+        let row = try #require(grid.model.row(at: 0))
+
+        #expect(grid.presenter.highlightDescription(of: row, dataIndex: 0) == "status = \u{201C}paid\u{201D}")
+    }
+
+    @Test("A highlighted row tints its whole row in the rule's color")
+    func highlightedRowTint() throws {
+        let grid = HighlightGrid(statuses: ["paid", "pending"])
+        grid.apply([paid])
+        let highlighted = try #require(grid.model.row(at: 0))
+        let plain = try #require(grid.model.row(at: 1))
+
+        #expect(grid.presenter.visualState(of: highlighted).tint(in: .live) == HighlightColor.green.washColor)
+        #expect(grid.presenter.visualState(of: plain).tint(in: .live) == nil)
+    }
+
+    // MARK: - Repaint
+
+    @Test("A value change repaints its whole row where a row rule can wash it, else only the changed column")
+    func rowRuleRepaintsWholeRow() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people) { owner, _ in
+            owner.highlightRules = [HighlightRule(columnName: "name", value: "bob", color: .green)]
+        }
+        defer { grid.close() }
+        _ = try #require(grid.main.rowView(atRow: 1, makeIfNecessary: true))
+        _ = try #require(grid.frozen.rowView(atRow: 1, makeIfNecessary: true))
+
+        #expect(grid.controller.refreshRowState(IndexSet(integer: 1), columns: IndexSet(integer: 1)) == IndexSet(integer: 1))
+
+        grid.owner.highlightRules = [HighlightRule(columnName: "name", value: "bob", color: .green, target: .cell)]
+
+        #expect(grid.controller.refreshRowState(IndexSet(integer: 1), columns: IndexSet(integer: 1)).isEmpty)
+    }
+
+    @Test("A value change on a row whose pending mark moved repaints the whole row")
+    func movedMarkRepaintsWholeRow() throws {
+        let manager = DataChangeManager()
+        manager.configureForTable(
+            tableName: "people",
+            columns: ["id", "name", "age"],
+            primaryKeyColumns: ["id"],
+            databaseType: .mysql,
+            generatedColumns: []
+        )
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, changeManager: manager)
+        defer { grid.close() }
+        _ = try #require(grid.main.rowView(atRow: 2, makeIfNecessary: true))
+        manager.recordRowDeletion(rowID: .existing(2), originalRow: [.text("2"), .text("cid"), .text("25")])
+        grid.model.repaintRows([RowID.existing(2)])
+        try #require(grid.controller.rowTint(forRow: 2) != nil)
+
+        manager.undoRowDeletion(rowID: .existing(2))
+
+        #expect(grid.controller.refreshRowState(IndexSet(integer: 2), columns: IndexSet(integer: 1)) == IndexSet(integer: 2))
+        #expect(grid.controller.rowTint(forRow: 2) == nil)
+    }
+}
diff --git a/apple/TableProTests/Views/Results/DataGridInvisibleCharacterTests.swift b/apple/TableProTests/Views/DataGrid/DataGridInvisibleCharacterTests.swift
similarity index 85%
rename from apple/TableProTests/Views/Results/DataGridInvisibleCharacterTests.swift
rename to apple/TableProTests/Views/DataGrid/DataGridInvisibleCharacterTests.swift
index ad60d29845..a8ff9a99b8 100644
--- a/apple/TableProTests/Views/Results/DataGridInvisibleCharacterTests.swift
+++ b/apple/TableProTests/Views/DataGrid/DataGridInvisibleCharacterTests.swift
@@ -4,11 +4,10 @@
 //
 
 import AppKit
+@testable import TablePro
 import TableProPluginKit
 import Testing
 
-@testable import TablePro
-
 @MainActor
 struct DataGridInvisibleCharacterTests {
     private let palette = DataGridCellPalette(
@@ -39,9 +38,7 @@ struct DataGridInvisibleCharacterTests {
             content: DataGridCellContent(displayText: text, rawValue: text, placeholder: placeholder),
             state: DataGridCellState(
                 visualState: .empty,
-                isFocused: false,
                 isEditable: true,
-                isLargeDataset: false,
                 isCurrentFindMatch: isCurrentFindMatch,
                 row: 0,
                 columnIndex: 0
@@ -49,7 +46,6 @@ struct DataGridInvisibleCharacterTests {
             palette: palette,
             nullDisplayString: "NULL",
             onEmphasizedSelection: onEmphasizedSelection,
-            hasOverlay: false,
             revealsInvisibleCharacters: reveals
         )
     }
@@ -102,13 +98,28 @@ struct DataGridInvisibleCharacterTests {
             columns: ["v"],
             columnTypes: [.text(rawType: nil)]
         )
-        let factory = DataGridCellFactory()
-        let marked = factory.calculateFitToContentWidth(
-            for: "v", columnIndex: 0, tableRows: rows, availableWidth: 1_600, revealsInvisibleCharacters: true
-        )
-        let unmarked = factory.calculateFitToContentWidth(
-            for: "v", columnIndex: 0, tableRows: rows, availableWidth: 1_600, revealsInvisibleCharacters: false
+        let input = DataGridColumnWidthCalculator.Input(
+            column: DataGridColumn(
+                id: DataGridColumnID(name: "v", occurrence: 0),
+                dataIndex: 0,
+                type: .text(rawType: nil),
+                comment: nil
+            ),
+            accessory: .none,
+            displayFormat: nil
         )
+        func calculator(revealing reveals: Bool) -> DataGridColumnWidthCalculator {
+            DataGridColumnWidthCalculator(
+                rows: rows,
+                databaseType: nil,
+                nullDisplayString: "NULL",
+                revealsInvisibleCharacters: reveals,
+                fonts: ThemeEngine.shared.dataGridFonts
+            )
+        }
+
+        let marked = calculator(revealing: true).fittedWidth(input, availableWidth: 1_600)
+        let unmarked = calculator(revealing: false).fittedWidth(input, availableWidth: 1_600)
 
         #expect(marked > unmarked + 20)
     }
@@ -134,7 +145,9 @@ struct DataGridInvisibleCharacterTests {
     @Test("A lone CR draws as a box while marked and as the old space while not")
     func carriageReturnIsDrawn() throws {
         #expect(try ink(of: resolve("abc\r")).orange > 0)
-        #expect(try ink(of: resolve("abc\r", reveals: false)) == ink(of: resolve("abc ", reveals: false)))
+        let unmarkedCR = try ink(of: resolve("abc\r", reveals: false))
+        let space = try ink(of: resolve("abc ", reveals: false))
+        #expect(unmarkedCR == space)
     }
 
     @Test("Marks past the ellipsis of a truncated value are not drawn")
@@ -172,6 +185,7 @@ struct DataGridInvisibleCharacterTests {
         return Ink(orange: orange, reach: reach)
     }
 
+    // A plain view, not a table: the renderer draws one cell into whatever surface it is given.
     private final class CellHost: NSView {
         var cellAppearance: DataGridCellAppearance?
 
diff --git a/apple/TableProTests/Views/DataGrid/DataGridMountTests.swift b/apple/TableProTests/Views/DataGrid/DataGridMountTests.swift
new file mode 100644
index 0000000000..11e695cc28
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridMountTests.swift
@@ -0,0 +1,251 @@
+//
+//  DataGridMountTests.swift
+//  TableProTests
+//
+
+import AppKit
+import SwiftUI
+@testable import TablePro
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+// A second controller over a model that already has an owner, the way a tab switch remounts its grid.
+@MainActor
+private final class Remount {
+    let controller: DataGridViewController
+    let window: GridTestWindow
+
+    init(_ model: DataGridModel, size: NSSize = NSSize(width: 600, height: 300)) {
+        controller = DataGridViewController(model: model)
+        window = GridTestWindow(
+            contentRect: NSRect(origin: .zero, size: size),
+            styleMask: [.titled],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        let content = NSView(frame: NSRect(origin: .zero, size: size))
+        window.contentView = content
+        controller.view.frame = content.bounds
+        content.addSubview(controller.view)
+        layout()
+    }
+
+    func layout() {
+        window.contentView?.layoutSubtreeIfNeeded()
+        controller.container.layoutSubtreeIfNeeded()
+        for pane in controller.panes {
+            pane.scrollView.layoutSubtreeIfNeeded()
+            pane.tableView.layoutSubtreeIfNeeded()
+        }
+    }
+
+    func close() {
+        controller.dismantle()
+        window.orderOut(nil)
+    }
+}
+
+@MainActor
+struct DataGridMountTests {
+    private static func rows(_ values: [String]) -> TableRows {
+        TableRows.from(
+            queryRows: values.map { [PluginCellValue.text($0)] },
+            columns: ["name"],
+            columnTypes: [.text(rawType: nil)]
+        )
+    }
+
+    private static func numbered(_ count: Int) -> TableRows {
+        rows((0..<count).map { "row \($0)" })
+    }
+
+    private func text(atRow row: Int, of model: DataGridModel, through controller: DataGridViewController) throws -> String {
+        let rowModel = try #require(model.row(at: row))
+        let column = try #require(model.columns.column(at: 0))
+        return controller.presenter.displayText(
+            of: rowModel,
+            dataIndex: column.dataIndex,
+            type: column.type,
+            formats: model.store.displayFormats,
+            databaseType: model.configuration.traits.databaseType,
+            columnCount: model.rows.columns.count
+        )
+    }
+
+    private func scroll(_ table: NSTableView, toRow row: Int, inset: CGFloat) {
+        table.scroll(NSPoint(x: 0, y: table.rect(ofRow: row).minY - inset))
+    }
+
+    // MARK: - Formatted text across a remount
+
+    @Test("A remount reuses the formatted text the previous mount produced")
+    func remountReusesFormattedText() throws {
+        let grid = HostedDataGrid(rows: Self.rows(["A"]))
+        #expect(try text(atRow: 0, of: grid.model, through: grid.controller) == "A")
+        grid.close()
+        _ = grid.owner.tableRows.edit(row: 0, column: 0, value: .text("B"))
+
+        let remount = Remount(grid.model)
+        defer { remount.close() }
+
+        #expect(try text(atRow: 0, of: grid.model, through: remount.controller) == "A")
+        grid.model.reloadRows()
+        #expect(try text(atRow: 0, of: grid.model, through: remount.controller) == "B")
+    }
+
+    @Test("A remount with a display format applied still reuses the formatted text")
+    func remountWithDisplayFormatReusesText() throws {
+        let grid = HostedDataGrid(rows: Self.rows(["A"])) { _, model in
+            model.store.displayFormats = [.raw]
+        }
+        #expect(try text(atRow: 0, of: grid.model, through: grid.controller) == "A")
+        grid.close()
+        _ = grid.owner.tableRows.edit(row: 0, column: 0, value: .text("B"))
+
+        let remount = Remount(grid.model)
+        defer { remount.close() }
+
+        #expect(try text(atRow: 0, of: grid.model, through: remount.controller) == "A")
+    }
+
+    @Test("Another model over the same rows formats them afresh")
+    func separateModelsShareNoText() throws {
+        let first = HostedDataGrid(rows: Self.rows(["A"]))
+        defer { first.close() }
+        #expect(try text(atRow: 0, of: first.model, through: first.controller) == "A")
+
+        let second = HostedDataGrid(rows: Self.rows(["B"]))
+        defer { second.close() }
+
+        #expect(try text(atRow: 0, of: second.model, through: second.controller) == "B")
+    }
+
+    // MARK: - Viewport across a remount
+
+    @Test("The rows the reader was looking at come back on a remount, and only once")
+    func viewportSurvivesARemount() async throws {
+        let grid = HostedDataGrid(rows: Self.numbered(1_000))
+        scroll(grid.main, toRow: 500, inset: grid.controller.headerInset)
+        try #require(grid.controller.viewportSample()?.row == 500)
+        grid.close()
+
+        let anchor = try #require(grid.model.store.viewportAnchor)
+        #expect(anchor.firstVisibleRow == .existing(500))
+
+        let remount = Remount(grid.model)
+        defer { remount.close() }
+        try await waitUntil {
+            remount.layout()
+            return remount.controller.viewportSample()?.row == 500
+        }
+        #expect(grid.model.store.viewportAnchor == nil)
+    }
+
+    // MARK: - Teardown
+
+    @Test("Unmounting detaches the grid, so later changes leave its tables alone")
+    func unmountDetachesTheModel() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        #expect(grid.model.isMounted)
+
+        grid.close()
+        grid.owner.tableRows = Self.numbered(2)
+        grid.model.reloadRows()
+
+        #expect(!grid.model.isMounted)
+        #expect(grid.main.numberOfRows == 5)
+    }
+
+    @Test("Unmounting takes the scroll observers off, so the panes stop moving in step")
+    func unmountStopsScrollSync() async throws {
+        let grid = HostedDataGrid(rows: Self.numbered(300))
+        let mainClip = grid.mainScrollView.contentView
+        let frozenClip = grid.frozenScrollView.contentView
+        mainClip.setBoundsOrigin(NSPoint(x: 0, y: 400))
+        try await waitUntil { frozenClip.bounds.origin.y == 400 }
+
+        grid.close()
+        mainClip.setBoundsOrigin(NSPoint(x: 0, y: 900))
+
+        #expect(mainClip.bounds.origin.y != frozenClip.bounds.origin.y)
+    }
+
+    @Test("A newer mount of the same model survives the older mount going")
+    func newerMountSurvivesOlderTeardown() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        let newer = Remount(grid.model)
+        #expect(grid.model.mountedView === newer.controller)
+
+        grid.close()
+
+        #expect(grid.model.mountedView === newer.controller)
+        #expect(grid.model.store.viewportAnchor == nil)
+
+        newer.close()
+        #expect(!grid.model.isMounted)
+    }
+
+    @Test("Unmounting twice is harmless")
+    func unmountIsIdempotent() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+
+        grid.close()
+        grid.controller.dismantle()
+
+        #expect(!grid.model.isMounted)
+    }
+
+    @Test("A grid handed another model moves to it instead of rebuilding")
+    func adoptMovesToTheNewModel() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let otherOwner = GridTestOwner(Self.numbered(2))
+        let other = DataGridModel()
+        other.dataSource = otherOwner
+        other.actions = otherOwner
+        other.reloadRows()
+
+        grid.controller.adopt(other)
+
+        #expect(!grid.model.isMounted)
+        #expect(other.mountedView === grid.controller)
+        #expect(grid.main.numberOfRows == 2)
+        #expect(grid.frozen.numberOfRows == 2)
+        #expect(grid.tableColumn(named: "id") == nil)
+        #expect(grid.tableColumn(named: "name") != nil)
+    }
+
+    @Test("Taking the grid view out of SwiftUI unmounts it from its model")
+    func swiftUIRemovalUnmounts() async throws {
+        let owner = GridTestOwner(GridFixtureRows.people)
+        let model = DataGridModel()
+        model.dataSource = owner
+        model.actions = owner
+        model.reloadRows()
+        let host = NSHostingView(rootView: AnyView(DataGridView(model: model)))
+        host.frame = NSRect(x: 0, y: 0, width: 600, height: 300)
+        let window = GridTestWindow(
+            contentRect: host.frame,
+            styleMask: [.titled],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        window.contentView = host
+        defer { window.orderOut(nil) }
+
+        try await waitUntil {
+            host.layoutSubtreeIfNeeded()
+            return model.isMounted
+        }
+
+        host.rootView = AnyView(Color.clear)
+
+        try await waitUntil {
+            host.layoutSubtreeIfNeeded()
+            return !model.isMounted
+        }
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridPaneTests.swift b/apple/TableProTests/Views/DataGrid/DataGridPaneTests.swift
new file mode 100644
index 0000000000..24478b6047
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridPaneTests.swift
@@ -0,0 +1,272 @@
+//
+//  DataGridPaneTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct DataGridPaneTests {
+    private func dataColumnNames(_ grid: HostedDataGrid, in kind: DataGridPane.Kind = .main) -> [String] {
+        let pane = grid.controller.container.pane(kind)
+        return pane.tableView.tableColumns.compactMap { pane.columnID(of: $0)?.name }
+    }
+
+    private func hasAttachment(_ title: NSAttributedString) -> Bool {
+        var found = false
+        title.enumerateAttribute(.attachment, in: NSRange(location: 0, length: title.length)) { value, _, stop in
+            guard value != nil else { return }
+            found = true
+            stop.pointee = true
+        }
+        return found
+    }
+
+    private func frozenGrid(count: Int) -> HostedDataGrid {
+        var layout = ColumnLayoutState()
+        layout.frozenColumnCount = count
+        return HostedDataGrid(rows: GridFixtureRows.wide(), store: InMemoryDataGridStateStore(columnLayout: layout))
+    }
+
+    // MARK: - Columns
+
+    @Test("A new page of the same columns keeps the same table columns, so nothing flickers (#951)")
+    func sameColumnsReuseTableColumns() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let before = grid.main.tableColumns.map { ObjectIdentifier($0) }
+
+        grid.owner.tableRows = TableRows.from(
+            queryRows: [["7", "fay", "20"], ["8", "gus", "61"]],
+            columns: ["id", "name", "age"],
+            columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .integer(rawType: "INT")]
+        )
+        grid.model.reloadRows()
+
+        #expect(grid.main.tableColumns.map { ObjectIdentifier($0) } == before)
+        #expect(grid.main.numberOfRows == 2)
+    }
+
+    @Test("The row-number column leads the main table and can be neither moved nor displaced")
+    func rowNumberColumnStaysFirst() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+
+        #expect(grid.main.tableColumns.first?.identifier == DataGridPane.rowNumberIdentifier)
+        #expect(dataColumnNames(grid) == ["id", "name", "age"])
+        #expect(!grid.controller.tableView(grid.main, shouldReorderColumn: 0, toColumn: 2))
+        #expect(!grid.controller.tableView(grid.main, shouldReorderColumn: 2, toColumn: 0))
+        #expect(grid.controller.tableView(grid.main, shouldReorderColumn: 1, toColumn: 3))
+    }
+
+    @Test("A grid without row numbers shows no row-number column and hides the empty frozen pane")
+    func noRowNumbersHidesFrozenPane() {
+        var configuration = DataGridConfiguration()
+        configuration.showRowNumbers = false
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration)
+        defer { grid.close() }
+
+        #expect(grid.main.tableColumns.first?.identifier != DataGridPane.rowNumberIdentifier)
+        #expect(grid.frozen.tableColumns.isEmpty)
+        #expect(grid.frozenScrollView.isHidden)
+        #expect(grid.container.frozenPaneWidth == 0)
+    }
+
+    @Test("A hidden column is not presented, and showing it puts it back in its place")
+    func hiddenColumnIsNotPresented() {
+        var layout = ColumnLayoutState()
+        layout.hiddenColumns = ["name"]
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, store: InMemoryDataGridStateStore(columnLayout: layout))
+        defer { grid.close() }
+
+        #expect(dataColumnNames(grid) == ["id", "age"])
+
+        grid.model.updateColumnLayout { $0.hiddenColumns = [] }
+
+        #expect(dataColumnNames(grid) == ["id", "name", "age"])
+    }
+
+    @Test("A column named in the minimum widths gets that floor and the others keep the default")
+    func minimumWidthIsAFloor() throws {
+        var configuration = DataGridConfiguration()
+        configuration.columnMinimumWidths = ["id": 200]
+        let grid = HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration)
+        defer { grid.close() }
+        let id = try #require(grid.tableColumn(named: "id"))
+        let name = try #require(grid.tableColumn(named: "name"))
+
+        #expect(id.minWidth == 200)
+        #expect(id.width >= 200)
+        #expect(name.minWidth == DataGridMetrics.dataColumnMinWidth)
+        #expect(name.maxWidth == DataGridMetrics.dataColumnMaxWidth)
+    }
+
+    @Test("Each data column sorts by its column ID, and a grid that cannot sort gets no sort prototype")
+    func sortPrototypes() {
+        let repeated = TableRows.from(
+            queryRows: [["1", "2"]],
+            columns: ["id", "id"],
+            columnTypes: [.integer(rawType: "INT"), .integer(rawType: "INT")]
+        )
+        let sorting = HostedDataGrid(rows: repeated)
+        defer { sorting.close() }
+        let keys = sorting.main.tableColumns.compactMap { $0.sortDescriptorPrototype?.key }
+        #expect(keys == [
+            DataGridColumnID(name: "id", occurrence: 0).stringValue,
+            DataGridColumnID(name: "id", occurrence: 1).stringValue,
+        ])
+
+        var configuration = DataGridConfiguration()
+        configuration.supportsColumnSort = false
+        let unsorted = HostedDataGrid(rows: GridFixtureRows.people, configuration: configuration)
+        defer { unsorted.close() }
+        #expect(unsorted.main.tableColumns.allSatisfy { $0.sortDescriptorPrototype == nil })
+    }
+
+    @Test("The main table runs past its last column by the trailing space")
+    func trailingSpaceIsPartOfTheTable() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide())
+        defer { grid.close() }
+        let last = try #require(grid.main.tableColumns.indices.last)
+
+        #expect(grid.main.frame.width >= grid.main.rect(ofColumn: last).maxX + DataGridMetrics.trailingSpace)
+    }
+
+    // MARK: - Header
+
+    @Test("A heading's tooltip names its type and the sort order once several keys sort")
+    func headingToolTip() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+        let age = try #require(grid.tableColumn(named: "age"))
+        #expect(name.headerToolTip == "name (TEXT)")
+
+        grid.model.setSort(SortState(
+            columns: [
+                SortColumn(columnIndex: 1, direction: .ascending, columnName: "name"),
+                SortColumn(columnIndex: 2, direction: .descending, columnName: "age"),
+            ],
+            source: .user
+        ))
+
+        #expect(name.headerToolTip?.hasPrefix("name (TEXT)\n") == true)
+        #expect(age.headerToolTip?.hasPrefix("age (INT)\n") == true)
+        #expect(name.headerCell.accessibilitySortDirection() == .ascending)
+        #expect(age.headerCell.accessibilitySortDirection() == .descending)
+        #expect(grid.tableColumn(named: "id")?.headerCell.accessibilitySortDirection() == .unknown)
+    }
+
+    @Test("A value-filtered column carries the filter symbol in its title")
+    func filteredHeadingShowsSymbol() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+        let age = try #require(grid.tableColumn(named: "age"))
+        #expect(!hasAttachment(name.headerCell.attributedStringValue))
+
+        grid.model.setValueFilter(GridFixtureRows.nameFilter(["bob"]))
+
+        #expect(hasAttachment(name.headerCell.attributedStringValue))
+        #expect(name.headerCell.attributedStringValue.string.hasPrefix("name"))
+        #expect(!hasAttachment(age.headerCell.attributedStringValue))
+    }
+
+    @Test("Command-clicking a heading selects its whole column and highlights the heading")
+    func commandClickSelectsColumn() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let name = try #require(grid.tableColumn(named: "name"))
+
+        grid.setCurrentEventModifiers(.command)
+        grid.controller.tableView(grid.main, didClick: name)
+
+        #expect(grid.model.selection.columns == IndexSet(integer: 1))
+        #expect(grid.model.selection.rectangles == [GridRect(rows: 0...4, columns: 1...1)])
+        #expect(grid.main.highlightedTableColumn === name)
+        #expect(grid.model.store.sortState.columns.isEmpty)
+    }
+
+    // MARK: - Frozen pane
+
+    @Test("Frozen columns that would cover more than two thirds of the grid scroll with the rest")
+    func frozenColumnsAreCapped() {
+        let grid = frozenGrid(count: 6)
+        defer { grid.close() }
+
+        #expect(grid.model.columns.frozenCount == 6)
+        #expect(grid.controller.effectiveFrozenCount < 6)
+        #expect(grid.container.frozenPaneWidth <= grid.container.bounds.width * DataGridMetrics.maximumFrozenShare)
+        #expect(grid.controller.canFreezeColumns(throughDisplayPosition: 0))
+        #expect(!grid.controller.canFreezeColumns(throughDisplayPosition: 6))
+    }
+
+    @Test("Freezing and unfreezing rebuild the frozen pane from the column set")
+    func freezeAndUnfreeze() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide())
+        defer { grid.close() }
+        #expect(dataColumnNames(grid, in: .frozen).isEmpty)
+
+        grid.model.updateColumnLayout { $0.frozenColumnCount = 2 }
+        grid.layout()
+
+        #expect(dataColumnNames(grid, in: .frozen) == ["c0", "c1"])
+        #expect(dataColumnNames(grid).prefix(3) == ["c0", "c1", "c2"])
+
+        grid.model.updateColumnLayout { $0.frozenColumnCount = 0 }
+        grid.layout()
+
+        #expect(dataColumnNames(grid, in: .frozen).isEmpty)
+        #expect(grid.frozen.tableColumns.count == 1)
+    }
+
+    @Test("Revealing a column scrolled under the frozen pane brings it out beside the pane")
+    func revealClearsFrozenPane() throws {
+        let grid = frozenGrid(count: 1)
+        defer { grid.close() }
+        let clip = grid.mainScrollView.contentView
+        grid.main.scroll(NSPoint(x: grid.main.frame.width, y: 0))
+        #expect(clip.bounds.minX > 0)
+
+        grid.controller.revealColumn(2)
+
+        let index = try #require(grid.tableIndex(ofDisplayPosition: 2))
+        let column = grid.main.rect(ofColumn: index)
+        let tolerance = 1 / grid.window.backingScaleFactor
+        #expect(column.minX >= clip.bounds.minX + grid.container.frozenPaneWidth - tolerance)
+        #expect(column.maxX <= clip.bounds.maxX + tolerance)
+    }
+
+    // MARK: - Rows
+
+    @Test("A row view reports the row it shows after rows above it are removed or inserted")
+    func rowViewFollowsItsRow() throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        let rowView = try #require(grid.main.rowView(atRow: 3, makeIfNecessary: true) as? DataGridRowView)
+        #expect(rowView.rowIndex == 3)
+
+        grid.model.apply(grid.owner.tableRows.remove(rowIDs: [.existing(0)]))
+        #expect(grid.main.numberOfRows == 4)
+        #expect(grid.frozen.numberOfRows == 4)
+        #expect(rowView.rowIndex == 2)
+
+        grid.model.apply(grid.owner.tableRows.insertInsertedRow(at: 0, values: ["9", "new", "1"]))
+        #expect(grid.main.numberOfRows == 5)
+        #expect(grid.frozen.numberOfRows == 5)
+        #expect(rowView.rowIndex == 3)
+    }
+
+    @Test("A row height change reaches both panes")
+    func rowHeightReachesBothPanes() {
+        let grid = frozenGrid(count: 1)
+        defer { grid.close() }
+
+        #expect(grid.main.rowHeight == grid.frozen.rowHeight)
+        #expect(grid.main.rowHeight >= CGFloat(AppSettingsManager.shared.dataGrid.rowHeight.rawValue))
+        #expect(grid.main.rect(ofRow: 40).minY == grid.frozen.rect(ofRow: 40).minY)
+    }
+}
diff --git a/apple/TableProTests/Views/Results/DataGridPendingChangeMarkTests.swift b/apple/TableProTests/Views/DataGrid/DataGridPendingChangeMarkTests.swift
similarity index 73%
rename from apple/TableProTests/Views/Results/DataGridPendingChangeMarkTests.swift
rename to apple/TableProTests/Views/DataGrid/DataGridPendingChangeMarkTests.swift
index be11411aea..bf43ff369e 100644
--- a/apple/TableProTests/Views/Results/DataGridPendingChangeMarkTests.swift
+++ b/apple/TableProTests/Views/DataGrid/DataGridPendingChangeMarkTests.swift
@@ -2,16 +2,11 @@
 //  DataGridPendingChangeMarkTests.swift
 //  TableProTests
 //
-//  A pending change used to show as a tint and nothing else, so selecting the rows about to be
-//  saved hid every mark at once and a client reading the grid was told nothing at all. These cover
-//  the line the cell draws instead, which selection cannot paint over.
-//
 
 import AppKit
 import CoreText
-import Testing
-
 @testable import TablePro
+import Testing
 
 @MainActor
 struct DataGridPendingChangeMarkTests {
@@ -45,17 +40,14 @@ struct DataGridPendingChangeMarkTests {
             content: DataGridCellContent(displayText: text, rawValue: text, placeholder: nil),
             state: DataGridCellState(
                 visualState: visualState,
-                isFocused: false,
                 isEditable: true,
-                isLargeDataset: false,
                 isCurrentFindMatch: isCurrentFindMatch,
                 row: 0,
                 columnIndex: columnIndex
             ),
             palette: palette,
             nullDisplayString: "NULL",
-            onEmphasizedSelection: onEmphasizedSelection,
-            hasOverlay: false
+            onEmphasizedSelection: onEmphasizedSelection
         )
     }
 
@@ -74,8 +66,6 @@ struct DataGridPendingChangeMarkTests {
         #expect(resolve(visualState: Self.modified, columnIndex: 0).textMark == nil)
     }
 
-    /// The row is going away whatever was typed into it first, so one line wins rather than two
-    /// crossing each other.
     @Test("A deleted row that was edited first keeps the strike alone")
     func deleteOutranksTheEdit() {
         let state = RowVisualState(isDeleted: true, isInserted: false, modifiedColumns: [1])
@@ -83,8 +73,6 @@ struct DataGridPendingChangeMarkTests {
         #expect(resolve(visualState: state, columnIndex: 1).textMark == .struckThrough)
     }
 
-    /// The whole point: the tint stands down under a selection and the find highlight, and the mark
-    /// does not.
     @Test("The mark survives a selection and a find match, where the tint does not")
     func markSurvivesWhatHidesTheTint() {
         let selected = resolve(visualState: Self.modified, columnIndex: 1, onEmphasizedSelection: true)
@@ -113,12 +101,7 @@ struct DataGridPendingChangeMarkTests {
 
     // MARK: - What is actually drawn
 
-    /// `CTLineDraw` draws both lines itself from the font's metrics, so these rasterise a cell and
-    /// read the pixels rather than trusting the attribute to have any effect.
-    ///
-    /// Drawn over mid grey, not white: a selected cell's text is
-    /// `alternateSelectedControlTextColor`, which is white, and a white-on-white cell rasterises
-    /// blank whatever it drew. Ink is any pixel that differs from the ground.
+    // Read back over mid grey: a selected cell's text is white and would vanish on white.
     private func inkedColumns(of appearance: DataGridCellAppearance, in rect: NSRect) throws -> [[Int]] {
         let host = CellHost(frame: rect)
         host.cellAppearance = appearance
@@ -138,12 +121,7 @@ struct DataGridPendingChangeMarkTests {
         }
     }
 
-    /// Flipped, because the grid's own cell surface is and the renderer positions its baseline from
-    /// the top edge. Rasterising into an unflipped context draws the cell upside down, which is how
-    /// a first pass at these tests came to read the underline as sitting above the strike.
-    ///
-    /// Mid grey, not white: a selected cell's text is `alternateSelectedControlTextColor`, which is
-    /// white, and a white-on-white cell rasterises blank whatever it drew.
+    // Flipped like the grid's cell surface, whose baseline is placed from the top edge.
     private final class CellHost: NSView {
         var cellAppearance: DataGridCellAppearance?
 
@@ -161,10 +139,7 @@ struct DataGridPendingChangeMarkTests {
 
     private static let cell = NSRect(x: 0, y: 0, width: 160, height: 24)
 
-    /// Where the mark landed: the row whose ink the mark adds over the same cell drawn unmarked, how
-    /// much it added, and how far right its own ink reaches. A glyph row gains nothing, so the
-    /// largest gain is the rule itself. The gain undercounts the rule's length wherever it crosses a
-    /// glyph the plain cell already inked, which is why reach is measured separately.
+    // The pixel row where the mark adds the most ink over the unmarked cell, that ink, and how far it reaches.
     private func markedRow(
         _ marked: DataGridCellAppearance,
         against plain: DataGridCellAppearance,
@@ -177,12 +152,7 @@ struct DataGridPendingChangeMarkTests {
         return (row, gains[row], markedRows[row].max() ?? 0)
     }
 
-    /// The rule's length is `reach`, and its existence is `gain`. They are separate assertions
-    /// because a selected row admits far less new ink for the same rule: measured over mid grey at a
-    /// text width of 80, the rule reaches 84 whether the row is selected or not, but it adds 57 new
-    /// columns on a plain row against 31 on a selected one, because the selected row's glyphs are
-    /// already white and the rule crossing them inks nothing new. Holding both to half the text
-    /// width read the selected rule as missing when it was drawn in full.
+    // Gain and reach are asserted apart: a selected row's glyphs are already white, so its rule adds less new ink.
     @Test("A struck-through cell draws a rule its plain twin does not, selected or not")
     func strikeIsDrawn() throws {
         let text = "0123456789"
@@ -200,7 +170,6 @@ struct DataGridPendingChangeMarkTests {
         #expect(selected.reach >= textWidth)
     }
 
-    /// The two lines have to land in different places, or they are the same cue twice.
     @Test("The underline sits below the strike")
     func underlineSitsBelowTheStrike() throws {
         let text = "0123456789"
@@ -211,8 +180,6 @@ struct DataGridPendingChangeMarkTests {
         #expect(underlined.row > struck.row)
     }
 
-    /// A cell too narrow for its value truncates, and the mark has to stop where the text does
-    /// rather than run on across the rest of the cell.
     @Test("The mark reaches as far as the text and no further, truncated or not")
     func markStopsWithTheText() throws {
         let short = "0123"
@@ -239,10 +206,7 @@ struct DataGridPendingChangeMarkTests {
         #expect(CGFloat(truncatedMark.reach) <= narrow.width)
         #expect(truncatedMark.reach > shortMark.reach)
 
-        /// Reach alone cannot see this: the glyphs of a truncated value already run to the cell's
-        /// edge, so a line that lost its mark reaches just as far. Only the gain separates them,
-        /// measured at 158 with the rule against 67 without it, beside the short cell's 50. So the
-        /// rule carried onto the truncated line is asserted where a regression would actually show.
+        // Reach alone cannot tell: a truncated value's glyphs already reach the cell's edge.
         #expect(truncatedMark.gain > shortMark.gain * 2)
     }
 }
diff --git a/apple/TableProTests/Views/DataGrid/DataGridRowMutationTests.swift b/apple/TableProTests/Views/DataGrid/DataGridRowMutationTests.swift
new file mode 100644
index 0000000000..2a73fe0b5e
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridRowMutationTests.swift
@@ -0,0 +1,195 @@
+//
+//  DataGridRowMutationTests.swift
+//  TableProTests
+//
+
+import AppKit
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct DataGridRowMutationTests {
+    private static func rows(_ count: Int) -> TableRows {
+        TableRows.from(
+            queryRows: (0..<count).map { [.text("\($0)"), .text("name-\($0)")] },
+            columns: ["id", "name"],
+            columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
+        )
+    }
+
+    private static func block(rows: ClosedRange<Int>) -> GridSelection {
+        .single(
+            GridRect(rows: rows, columns: 0...1),
+            anchor: GridCoord(row: rows.lowerBound, displayColumn: 0),
+            active: GridCoord(row: rows.upperBound, displayColumn: 1)
+        )
+    }
+
+    private func expectTablesCount(_ grid: HostedDataGrid, _ count: Int) {
+        #expect(grid.model.rowCount == count)
+        #expect(grid.main.numberOfRows == count)
+        #expect(grid.frozen.numberOfRows == count)
+    }
+
+    // MARK: - Row count
+
+    @Test("Both tables count the rows the owner holds once they load")
+    func tablesCountLoadedRows() {
+        let grid = HostedDataGrid(rows: Self.rows(3))
+        defer { grid.close() }
+
+        expectTablesCount(grid, 3)
+        #expect(grid.controller.numberOfRows(in: grid.main) == grid.owner.tableRows.count)
+    }
+
+    @Test("Appended rows reach both tables")
+    func appendedRowsReachBothTables() {
+        let grid = HostedDataGrid(rows: Self.rows(0))
+        defer { grid.close() }
+
+        grid.model.apply(grid.owner.tableRows.appendInsertedRow(values: [.text("a"), .text("a")]))
+        grid.model.apply(grid.owner.tableRows.appendInsertedRow(values: [.text("b"), .text("b")]))
+
+        expectTablesCount(grid, 2)
+    }
+
+    @Test("Removed rows leave both tables")
+    func removedRowsLeaveBothTables() {
+        let grid = HostedDataGrid(rows: Self.rows(3))
+        defer { grid.close() }
+
+        grid.model.apply(grid.owner.tableRows.remove(rowIDs: [.existing(1)]))
+
+        expectTablesCount(grid, 2)
+        #expect(grid.model.rowID(at: 1) == .existing(2))
+    }
+
+    @Test("A full replace reaches both tables")
+    func fullReplaceReachesBothTables() {
+        let grid = HostedDataGrid(rows: Self.rows(1))
+        defer { grid.close() }
+
+        let replacement: [[PluginCellValue]] = ["x", "y", "z", "w"].map { [.text($0), .text($0)] }
+        grid.model.apply(grid.owner.tableRows.replace(rows: replacement))
+
+        expectTablesCount(grid, 4)
+    }
+
+    @Test("Both tables count only the rows a value filter keeps")
+    func tablesCountFilteredRows() {
+        let grid = HostedDataGrid(rows: Self.rows(3))
+        defer { grid.close() }
+
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["name-0", "name-2"], includesNull: false), columnName: "name", forColumn: 1)
+        grid.model.setValueFilter(filter)
+
+        expectTablesCount(grid, 2)
+        #expect(grid.model.rowID(at: 0) == .existing(0))
+        #expect(grid.model.rowID(at: 1) == .existing(2))
+    }
+
+    // MARK: - Selection follows its records
+
+    @Test("Discarding an inserted row above the selection keeps it on the same records")
+    func discardingInsertedRowShiftsSelection() {
+        let grid = HostedDataGrid(rows: Self.rows(5))
+        defer { grid.close() }
+        let insertedID = RowID.inserted(UUID())
+        grid.model.apply(grid.owner.tableRows.insertInsertedRow(at: 1, id: insertedID, values: [.text("9"), .text("new")]))
+        grid.model.setSelection(Self.block(rows: 3...4))
+        #expect(grid.model.selectedRowIDs == [.existing(2), .existing(3)])
+
+        grid.model.apply(grid.owner.tableRows.remove(rowIDs: [insertedID]))
+
+        #expect(grid.model.selection.rectangles == [GridRect(rows: 2...3, columns: 0...1)])
+        #expect(grid.model.selectedRowIDs == [.existing(2), .existing(3)])
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 2...3))
+        expectTablesCount(grid, 5)
+    }
+
+    @Test("A row added above the selection moves it down with its records")
+    func insertingRowAboveShiftsSelection() {
+        let grid = HostedDataGrid(rows: Self.rows(5))
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 1...2))
+
+        grid.model.apply(grid.owner.tableRows.insertInsertedRow(at: 0, values: [.text("9"), .text("new")]))
+
+        #expect(grid.model.selection.rectangles == [GridRect(rows: 2...3, columns: 0...1)])
+        #expect(grid.model.selectedRowIDs == [.existing(1), .existing(2)])
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 2...3))
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integersIn: 2...3))
+        expectTablesCount(grid, 6)
+    }
+
+    // The old grid dropped the selection here; the model now keeps it by identity.
+    @Test("Under a value filter a row change keeps the selection on its records")
+    func valueFilterKeepsSelection() {
+        let grid = HostedDataGrid(rows: Self.rows(5))
+        defer { grid.close() }
+        var filter = GridValueFilterState()
+        filter.set(
+            ColumnValueFilter(selectedValues: ["name-1", "name-2", "name-3"], includesNull: false),
+            columnName: "name",
+            forColumn: 1
+        )
+        grid.model.setValueFilter(filter)
+        grid.model.setSelection(Self.block(rows: 0...1))
+        #expect(grid.model.selectedRowIDs == [.existing(1), .existing(2)])
+
+        grid.model.apply(grid.owner.tableRows.remove(rowIDs: [.existing(4)]))
+
+        #expect(grid.model.selectedRowIDs == [.existing(1), .existing(2)])
+        #expect(grid.model.selection.rectangles == [GridRect(rows: 0...1, columns: 0...1)])
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 0...1))
+        expectTablesCount(grid, 3)
+    }
+
+    @Test("A row added above the cursor moves the cursor with its record")
+    func insertingRowAboveShiftsCursor() {
+        let grid = HostedDataGrid(rows: Self.rows(5))
+        defer { grid.close() }
+        grid.model.setSelection(GridSelectionReducer.single(GridCoord(row: 2, displayColumn: 1)))
+
+        grid.model.apply(grid.owner.tableRows.insertInsertedRow(at: 0, values: [.text("9"), .text("new")]))
+
+        #expect(grid.model.selection.activeCell == GridCoord(row: 3, displayColumn: 1))
+        #expect(grid.model.activeCell?.rowID == .existing(2))
+        #expect(grid.main.selectedRowIndexes == IndexSet(integer: 3))
+    }
+
+    @Test("A row added below the cursor leaves it where it is")
+    func insertingRowBelowKeepsCursor() {
+        let grid = HostedDataGrid(rows: Self.rows(5))
+        defer { grid.close() }
+        grid.model.setSelection(GridSelectionReducer.single(GridCoord(row: 2, displayColumn: 1)))
+
+        grid.model.apply(grid.owner.tableRows.insertInsertedRow(at: 4, values: [.text("9"), .text("new")]))
+
+        #expect(grid.model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+        #expect(grid.model.activeCell?.rowID == .existing(2))
+        #expect(grid.main.selectedRowIndexes == IndexSet(integer: 2))
+    }
+
+    @Test("Removing a row above the cursor moves it up, and removing its own row clears it")
+    func removingRowsShiftsOrClearsCursor() {
+        let grid = HostedDataGrid(rows: Self.rows(5))
+        defer { grid.close() }
+        grid.model.setSelection(GridSelectionReducer.single(GridCoord(row: 3, displayColumn: 1)))
+
+        grid.model.apply(grid.owner.tableRows.remove(rowIDs: [.existing(0)]))
+
+        #expect(grid.model.selection.activeCell == GridCoord(row: 2, displayColumn: 1))
+        #expect(grid.model.activeCell?.rowID == .existing(3))
+        #expect(grid.main.selectedRowIndexes == IndexSet(integer: 2))
+
+        grid.model.apply(grid.owner.tableRows.remove(rowIDs: [.existing(3)]))
+
+        #expect(grid.model.selection == .empty)
+        #expect(grid.model.activeCell == nil)
+        #expect(grid.main.selectedRowIndexes.isEmpty)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridRowNumberColumnTests.swift b/apple/TableProTests/Views/DataGrid/DataGridRowNumberColumnTests.swift
new file mode 100644
index 0000000000..474edbffb8
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridRowNumberColumnTests.swift
@@ -0,0 +1,112 @@
+//
+//  DataGridRowNumberColumnTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct DataGridRowNumberColumnTests {
+    private static func rows(_ count: Int) -> TableRows {
+        TableRows.from(
+            queryRows: (0..<count).map { [PluginCellValue.text("value \($0)")] },
+            columns: ["name"],
+            columnTypes: [.text(rawType: "TEXT")]
+        )
+    }
+
+    private func rowNumberColumns(of grid: HostedDataGrid) -> [NSTableColumn] {
+        [grid.main, grid.frozen].compactMap { table in
+            table.tableColumns.first { $0.identifier == DataGridPane.rowNumberIdentifier }
+        }
+    }
+
+    private func rowNumberWidth(rowCount: Int, offset: Int) throws -> CGFloat {
+        let grid = HostedDataGrid(rows: Self.rows(rowCount)) { owner, _ in owner.rowNumberOffset = offset }
+        defer { grid.close() }
+        return try #require(rowNumberColumns(of: grid).first).width
+    }
+
+    @Test("Both panes carry the row numbers first, at one width")
+    func bothPanesShowRowNumbers() throws {
+        let grid = HostedDataGrid(rows: Self.rows(3))
+        defer { grid.close() }
+
+        let columns = rowNumberColumns(of: grid)
+        try #require(columns.count == 2)
+        #expect(grid.main.tableColumns.first === columns[0])
+        #expect(grid.frozen.tableColumns.first === columns[1])
+        #expect(columns[0].width == columns[1].width)
+        #expect(!grid.frozenScrollView.isHidden)
+    }
+
+    @Test("A single-digit row count sizes to the floor, pinned at that width")
+    func singleDigitHonoursTheFloor() throws {
+        let grid = HostedDataGrid(rows: Self.rows(1))
+        defer { grid.close() }
+
+        for column in rowNumberColumns(of: grid) {
+            #expect(column.width == DataGridMetrics.rowNumberColumnMinWidth)
+            #expect(column.minWidth == column.width)
+            #expect(column.maxWidth == column.width)
+            #expect(column.resizingMask.isEmpty)
+        }
+    }
+
+    @Test("A five-digit row number grows the column past the floor")
+    func fiveDigitsGrowPastTheFloor() throws {
+        #expect(try rowNumberWidth(rowCount: 1, offset: 14_000) > DataGridMetrics.rowNumberColumnMinWidth)
+    }
+
+    @Test("The width grows with the digits of the last row number on the page")
+    func widthGrowsWithDigits() throws {
+        let two = try rowNumberWidth(rowCount: 1, offset: 98)
+        let four = try rowNumberWidth(rowCount: 1, offset: 9_998)
+        let seven = try rowNumberWidth(rowCount: 1, offset: 1_234_566)
+
+        #expect(four >= two)
+        #expect(seven > four)
+    }
+
+    @Test("A page with more rows widens the column on reload and stays pinned")
+    func reloadWidensAndStaysPinned() throws {
+        let grid = HostedDataGrid(rows: Self.rows(2))
+        defer { grid.close() }
+        let narrow = try #require(rowNumberColumns(of: grid).first).width
+
+        grid.owner.rowNumberOffset = 1_000_000
+        grid.model.reloadRows()
+
+        let columns = rowNumberColumns(of: grid)
+        try #require(columns.count == 2)
+        #expect(columns[0].width > narrow)
+        #expect(columns[0].width == columns[1].width)
+        #expect(columns[0].minWidth == columns[0].width)
+        #expect(columns[0].maxWidth == columns[0].width)
+    }
+
+    @Test("Turning row numbers off removes the column from both panes")
+    func rowNumbersOff() {
+        var configuration = DataGridConfiguration()
+        configuration.showRowNumbers = false
+        let grid = HostedDataGrid(rows: Self.rows(3), configuration: configuration)
+        defer { grid.close() }
+
+        #expect(rowNumberColumns(of: grid).isEmpty)
+        #expect(grid.frozenScrollView.isHidden)
+    }
+
+    @Test("The row-number column is not a data column")
+    func rowNumberIsNotData() throws {
+        let grid = HostedDataGrid(rows: Self.rows(3))
+        defer { grid.close() }
+        let column = try #require(rowNumberColumns(of: grid).first)
+
+        #expect(grid.controller.main.columnID(of: column) == nil)
+        #expect(grid.controller.main.isRowNumber(column))
+        #expect(column.sortDescriptorPrototype == nil)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridSelectionMirrorTests.swift b/apple/TableProTests/Views/DataGrid/DataGridSelectionMirrorTests.swift
new file mode 100644
index 0000000000..bcd4bffe0e
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridSelectionMirrorTests.swift
@@ -0,0 +1,148 @@
+//
+//  DataGridSelectionMirrorTests.swift
+//  TableProTests
+//
+
+import AppKit
+import Foundation
+@testable import TablePro
+import TableProTestSupport
+import Testing
+
+@MainActor
+struct DataGridSelectionMirrorTests {
+    private static func block(rows: ClosedRange<Int>, columns: ClosedRange<Int>) -> GridSelection {
+        .single(
+            GridRect(rows: rows, columns: columns),
+            anchor: GridCoord(row: rows.lowerBound, displayColumn: columns.lowerBound),
+            active: GridCoord(row: rows.upperBound, displayColumn: columns.upperBound)
+        )
+    }
+
+    // MARK: - Tables to the model
+
+    @Test("A row the table selects natively becomes the model's selection")
+    func nativeRowSelectionReachesModel() async throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+
+        grid.main.selectRowIndexes(IndexSet(integer: 2), byExtendingSelection: false)
+
+        try await waitUntil { grid.model.selectedRowIDs == [.existing(2)] }
+        #expect(grid.model.selection.rectangles == [GridRect(rows: 2...2, columns: 0...2)])
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integer: 2))
+    }
+
+    @Test("A row selected natively with no cursor seeds the cursor on a data column")
+    func nativeSelectionSeedsDataColumn() async throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        #expect(grid.model.selection.isEmpty)
+
+        grid.main.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
+
+        try await waitUntil { grid.model.selection.activeCell != nil }
+        #expect(grid.model.selection.activeCell == GridCoord(row: 0, displayColumn: 0))
+        #expect(grid.model.activeCell?.column.name == "id")
+    }
+
+    @Test("Deselecting every row natively clears the model's selection")
+    func nativeDeselectClearsModel() async throws {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.selectRows([.existing(4)])
+        #expect(grid.main.selectedRowIndexes == IndexSet(integer: 4))
+
+        grid.main.deselectAll(nil)
+
+        try await waitUntil { grid.model.selection.isEmpty }
+        #expect(grid.frozen.selectedRowIndexes.isEmpty)
+    }
+
+    @Test("A native selection change that moves nothing writes nothing")
+    func unchangedNativeSelectionWritesNothing() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.people)
+        defer { grid.close() }
+        grid.model.selectRows([.existing(3)])
+        let revision = grid.model.selectionRevision
+
+        grid.controller.tableViewSelectionDidChange(
+            Notification(name: NSTableView.selectionDidChangeNotification, object: grid.main)
+        )
+
+        #expect(grid.model.selectionRevision == revision)
+        #expect(grid.model.selectedRowIDs == [.existing(3)])
+    }
+
+    // MARK: - The model to the tables
+
+    @Test("A cell range selects every row it covers in both tables")
+    func cellRangeSelectsEveryCoveredRow() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide(rows: 20, columns: 3))
+        defer { grid.close() }
+
+        grid.model.setSelection(Self.block(rows: 1...6, columns: 0...0))
+
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 1...6))
+        #expect(grid.frozen.selectedRowIndexes == IndexSet(integersIn: 1...6))
+        #expect(grid.model.selectedRowIDs == (1...6).map { RowID.existing($0) })
+    }
+
+    @Test("Two cells on distant rows select both rows")
+    func discontiguousCellsSelectBothRows() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide(rows: 20, columns: 3))
+        defer { grid.close() }
+
+        grid.model.setSelection(GridSelection(
+            rectangles: [GridRect(cell: GridCoord(row: 3, displayColumn: 0)), GridRect(cell: GridCoord(row: 17, displayColumn: 2))],
+            activeCell: GridCoord(row: 17, displayColumn: 2),
+            anchor: GridCoord(row: 3, displayColumn: 0)
+        ))
+
+        #expect(grid.main.selectedRowIndexes == IndexSet([3, 17]))
+        #expect(grid.model.selectedRowIDs == [.existing(3), .existing(17)])
+    }
+
+    @Test("Mirroring the model into the tables never feeds back into the model")
+    func mirroringDoesNotFeedBack() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide(rows: 20, columns: 3))
+        defer { grid.close() }
+        let range = Self.block(rows: 4...9, columns: 1...2)
+
+        grid.model.setSelection(range)
+
+        #expect(grid.model.selection == range)
+        #expect(grid.main.selectedRowIndexes == IndexSet(integersIn: 4...9))
+    }
+
+    @Test("Clearing a cell range clears the rows in both tables")
+    func clearingRangeClearsTables() {
+        let grid = HostedDataGrid(rows: GridFixtureRows.wide(rows: 20, columns: 3))
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 4...9, columns: 0...0))
+
+        grid.model.clearSelection()
+
+        #expect(grid.main.selectedRowIndexes.isEmpty)
+        #expect(grid.frozen.selectedRowIndexes.isEmpty)
+    }
+
+    // MARK: - Announcement
+
+    @Test("The selection announcement counts overlapping cells once")
+    func announcementCountsUniqueCells() {
+        let selection = GridSelection(
+            rectangles: [GridRect(rows: 0...4, columns: 0...0), GridRect(rows: 2...6, columns: 0...0)],
+            activeCell: GridCoord(row: 6, displayColumn: 0),
+            anchor: GridCoord(row: 2, displayColumn: 0)
+        )
+        let expected = String(
+            format: String(localized: "%d cells selected, rows %d to %d, columns %d to %d"),
+            7, 1, 7, 1, 1
+        )
+
+        #expect(selection.uniqueCellCount == 7)
+        #expect(DataGridViewController.accessibilityAnnouncement(for: selection) == expected)
+        #expect(DataGridViewController.accessibilityAnnouncement(for: .empty) == String(localized: "Cell selection cleared"))
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridTestFixture.swift b/apple/TableProTests/Views/DataGrid/DataGridTestFixture.swift
new file mode 100644
index 0000000000..d66bb0e073
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridTestFixture.swift
@@ -0,0 +1,282 @@
+//
+//  DataGridTestFixture.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+
+// A data source and owner that records every request the grid makes of it.
+@MainActor
+final class GridTestOwner: DataGridDataSource, DataGridActions {
+    var tableRows: TableRows
+    let changeManager: DataChangeManager
+    let changeState: AnyChangeManager
+    weak var model: DataGridModel?
+
+    var rowNumberOffset = 0
+    var highlightRules: [HighlightRule] = []
+    var visualStates: [RowID: RowVisualState] = [:]
+    var checkboxStates: [RowID: Bool] = [:]
+    var approvesDisplayOrderChange = true
+    var acceptsCommits = true
+    // Records each committed value, writes it into the rows and reports it back, the way a real owner does.
+    var appliesCommits = false
+
+    private(set) var commits: [(edits: [DataGridResolvedEdit], actionName: String)] = []
+    private(set) var deleteRequests: [[RowID]] = []
+    private(set) var sortChanges: [SortState] = []
+    private(set) var displayOrderRequests = 0
+    private(set) var searchedTerms: [String] = []
+    private(set) var checkboxWrites: [(isOn: Bool, rowIDs: [RowID], column: String)] = []
+    private(set) var addRowRequests = 0
+    private(set) var movedRows: [(rowID: RowID, destination: Int)] = []
+
+    init(_ tableRows: TableRows, changeManager: DataChangeManager = DataChangeManager()) {
+        self.tableRows = tableRows
+        self.changeManager = changeManager
+        changeState = AnyChangeManager(changeManager)
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+    var gridRowNumberOffset: Int { rowNumberOffset }
+    var gridHighlightRules: [HighlightRule] { highlightRules }
+
+    func gridVisualState(for rowID: RowID) -> RowVisualState? {
+        visualStates[rowID]
+    }
+
+    func gridCheckboxState(for rowID: RowID, column: DataGridColumn) -> Bool? {
+        checkboxStates[rowID]
+    }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        commits.append((edits, actionName))
+        guard acceptsCommits else { return false }
+        guard appliesCommits else { return true }
+        var changed: Set<CellPosition> = []
+        for edit in edits {
+            guard let index = tableRows.index(of: edit.rowID) else { continue }
+            changeManager.recordCellChange(
+                rowID: edit.rowID,
+                columnIndex: edit.dataIndex,
+                columnName: edit.columnName,
+                oldValue: edit.oldValue,
+                newValue: edit.newValue,
+                originalRow: edit.originalRow,
+                absence: edit.absence,
+                isExpression: edit.isExpression
+            )
+            _ = tableRows.edit(row: index, column: edit.dataIndex, value: edit.newValue)
+            changed.insert(CellPosition(row: index, column: edit.dataIndex))
+        }
+        model?.apply(.cellsChanged(changed))
+        return true
+    }
+
+    func gridDeleteRows(_ rowIDs: [RowID]) {
+        deleteRequests.append(rowIDs)
+    }
+
+    func gridSortDidChange(_ sort: SortState) {
+        sortChanges.append(sort)
+    }
+
+    func gridConfirmDisplayOrderChange(then apply: @escaping @MainActor () -> Void) {
+        displayOrderRequests += 1
+        if approvesDisplayOrderChange {
+            apply()
+        }
+    }
+
+    func gridSearchAllRows(term: String) {
+        searchedTerms.append(term)
+    }
+
+    func gridSetCheckbox(_ isOn: Bool, rowIDs: [RowID], column: DataGridColumn) {
+        checkboxWrites.append((isOn, rowIDs, column.name))
+        for rowID in rowIDs {
+            checkboxStates[rowID] = isOn
+        }
+    }
+
+    func gridAddRow() {
+        addRowRequests += 1
+    }
+
+    func gridMoveRow(from source: RowID, toDisplayIndex destination: Int) {
+        movedRows.append((source, destination))
+    }
+}
+
+// The headless host never gives a window the keyboard, so key state is stated here instead.
+@MainActor
+final class GridTestWindow: NSWindow {
+    var holdsKeyboard = true
+
+    override var isKeyWindow: Bool { holdsKeyboard }
+    override var canBecomeKey: Bool { true }
+}
+
+// A DataGridViewController mounted in a window, over a model whose owner is a GridTestOwner.
+@MainActor
+final class HostedDataGrid {
+    let owner: GridTestOwner
+    let model: DataGridModel
+    let controller: DataGridViewController
+    let window: GridTestWindow
+
+    init(
+        rows: TableRows,
+        configuration: DataGridConfiguration = DataGridConfiguration(),
+        store: any DataGridStateStore = InMemoryDataGridStateStore(),
+        changeManager: DataChangeManager = DataChangeManager(),
+        size: NSSize = NSSize(width: 800, height: 400),
+        prepare: (GridTestOwner, DataGridModel) -> Void = { _, _ in }
+    ) {
+        owner = GridTestOwner(rows, changeManager: changeManager)
+        model = DataGridModel(store: store, configuration: configuration)
+        model.dataSource = owner
+        model.actions = owner
+        owner.model = model
+        prepare(owner, model)
+        model.reloadRows()
+
+        controller = DataGridViewController(model: model)
+        window = GridTestWindow(
+            contentRect: NSRect(origin: .zero, size: size),
+            styleMask: [.titled, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        let content = NSView(frame: NSRect(origin: .zero, size: size))
+        window.contentView = content
+        controller.view.frame = content.bounds
+        controller.view.autoresizingMask = [.width, .height]
+        content.addSubview(controller.view)
+        layout()
+    }
+
+    var container: DataGridContainerView { controller.container }
+    var main: DataGridTableView { controller.main.tableView }
+    var frozen: DataGridTableView { controller.frozen.tableView }
+    var mainScrollView: DataGridScrollView { controller.main.scrollView }
+    var frozenScrollView: DataGridScrollView { controller.frozen.scrollView }
+
+    // Lays the container out and has both tables prepare the rows on screen.
+    func layout() {
+        window.contentView?.layoutSubtreeIfNeeded()
+        container.layoutSubtreeIfNeeded()
+        for pane in controller.panes {
+            pane.scrollView.layoutSubtreeIfNeeded()
+            pane.tableView.layoutSubtreeIfNeeded()
+        }
+    }
+
+    @discardableResult
+    func focus() -> Bool {
+        let accepted = window.makeFirstResponder(main)
+        container.refreshFocus()
+        return accepted
+    }
+
+    func setKeyWindow(_ isKey: Bool) {
+        window.holdsKeyboard = isKey
+        container.refreshFocus()
+    }
+
+    // The table column that shows a display position in a pane, row numbers included.
+    func tableIndex(ofDisplayPosition position: Int, in kind: DataGridPane.Kind = .main) -> Int? {
+        controller.container.pane(kind).tableIndex(forDisplayPosition: position, columns: model.columns)
+    }
+
+    func tableColumn(named name: String, in kind: DataGridPane.Kind = .main) -> NSTableColumn? {
+        let pane = controller.container.pane(kind)
+        return pane.tableView.tableColumns.first { pane.columnID(of: $0)?.name == name }
+    }
+
+    func keyEvent(
+        _ characters: String,
+        keyCode: UInt16,
+        modifiers: NSEvent.ModifierFlags = []
+    ) -> NSEvent? {
+        NSEvent.keyEvent(
+            with: .keyDown,
+            location: .zero,
+            modifierFlags: modifiers,
+            timestamp: ProcessInfo.processInfo.systemUptime,
+            windowNumber: window.windowNumber,
+            context: nil,
+            characters: characters,
+            charactersIgnoringModifiers: characters,
+            isARepeat: false,
+            keyCode: keyCode
+        )
+    }
+
+    // Delivers a key press to the main table the way the window would.
+    @discardableResult
+    func press(_ characters: String, keyCode: UInt16, modifiers: NSEvent.ModifierFlags = []) -> Bool {
+        guard let event = keyEvent(characters, keyCode: keyCode, modifiers: modifiers) else { return false }
+        main.keyDown(with: event)
+        return true
+    }
+
+    // NSApp.currentEvent is the last event dequeued, so this leaves one carrying the modifiers in place.
+    func setCurrentEventModifiers(_ modifiers: NSEvent.ModifierFlags) {
+        guard let event = NSEvent.otherEvent(
+            with: .applicationDefined,
+            location: .zero,
+            modifierFlags: modifiers,
+            timestamp: ProcessInfo.processInfo.systemUptime,
+            windowNumber: window.windowNumber,
+            context: nil,
+            subtype: 0,
+            data1: 0,
+            data2: 0
+        ) else { return }
+        NSApp.postEvent(event, atStart: true)
+        _ = NSApp.nextEvent(matching: .applicationDefined, until: .distantPast, inMode: .default, dequeue: true)
+    }
+
+    func close() {
+        controller.dismantle()
+        window.orderOut(nil)
+    }
+}
+
+enum GridFixtureRows {
+    static let people: TableRows = TableRows.from(
+        queryRows: [
+            ["0", "ann", "30"],
+            ["1", "bob", "41"],
+            ["2", "cid", "25"],
+            ["3", "dee", "33"],
+            ["4", "eve", "52"],
+        ],
+        columns: ["id", "name", "age"],
+        columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .integer(rawType: "INT")]
+    )
+
+    // Enough rows and columns to scroll both ways in an 800 by 400 window.
+    static func wide(rows rowCount: Int = 80, columns columnCount: Int = 12) -> TableRows {
+        let columns = (0..<columnCount).map { "c\($0)" }
+        let values: [[PluginCellValue]] = (0..<rowCount).map { row in
+            (0..<columnCount).map { column in .text("r\(row) value in column \(column)") }
+        }
+        return TableRows.from(
+            queryRows: values,
+            columns: columns,
+            columnTypes: Array(repeating: .text(rawType: "TEXT"), count: columnCount)
+        )
+    }
+
+    static func nameFilter(_ names: Set<String>) -> GridValueFilterState {
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: names, includesNull: false), columnName: "name", forColumn: 1)
+        return filter
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridValueFilterTests.swift b/apple/TableProTests/Views/DataGrid/DataGridValueFilterTests.swift
new file mode 100644
index 0000000000..4a313e942b
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridValueFilterTests.swift
@@ -0,0 +1,363 @@
+//
+//  DataGridValueFilterTests.swift
+//  TableProTests
+//
+
+import AppKit
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+// Holds the work instead of running it, standing in for a reader who has not answered the alert yet.
+@MainActor
+private final class DeferringOwner: DataGridDataSource, DataGridActions {
+    var tableRows: TableRows
+    let changeState: AnyChangeManager
+    private(set) var askedCount = 0
+    private var pending: (@MainActor () -> Void)?
+
+    init(_ tableRows: TableRows) {
+        self.tableRows = tableRows
+        changeState = AnyChangeManager(DataChangeManager())
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool { false }
+
+    func gridConfirmDisplayOrderChange(then apply: @escaping @MainActor () -> Void) {
+        askedCount += 1
+        pending = apply
+    }
+
+    func confirm() {
+        let work = pending
+        pending = nil
+        work?()
+    }
+
+    func discard() {
+        pending = nil
+    }
+}
+
+@MainActor
+struct DataGridValueFilterTests {
+    private static let statuses = TableRows(
+        rows: [
+            Row(id: .existing(0), values: [.text("active"), .text("a")]),
+            Row(id: .existing(1), values: [.text("inactive"), .text("b")]),
+            Row(id: .existing(2), values: [.text("active"), .text("c")]),
+            Row(id: .existing(3), values: [.null, .text("d")]),
+        ],
+        columns: ["status", "name"],
+        columnTypes: [.text(rawType: nil), .text(rawType: nil)]
+    )
+
+    private static func filter(
+        _ values: Set<String>,
+        includesNull: Bool = false,
+        column: Int,
+        named name: String,
+        onto base: GridValueFilterState = GridValueFilterState()
+    ) -> GridValueFilterState {
+        var state = base
+        state.set(ColumnValueFilter(selectedValues: values, includesNull: includesNull), columnName: name, forColumn: column)
+        return state
+    }
+
+    private static let onlyActive = filter(["active"], column: 0, named: "status")
+
+    private func makeModel(
+        dataSource: any DataGridDataSource,
+        actions: (any DataGridActions)?
+    ) -> DataGridModel {
+        let model = DataGridModel()
+        model.dataSource = dataSource
+        model.actions = actions
+        model.reloadRows()
+        return model
+    }
+
+    private func makeModel(_ owner: GridTestOwner) -> DataGridModel {
+        makeModel(dataSource: owner, actions: owner)
+    }
+
+    // MARK: - Narrowing
+
+    @Test("A value filter narrows the rows shown and keeps them in storage order")
+    func filterNarrowsRows() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+
+        model.setValueFilter(Self.onlyActive)
+
+        #expect(model.order.filteredIDs == [.existing(0), .existing(2)])
+        #expect(model.rowCount == 2)
+        #expect(model.rowID(at: 0) == .existing(0))
+        #expect(model.rowID(at: 1) == .existing(2))
+        #expect(model.order.storageIndex(at: 1, in: model.rows) == 2)
+    }
+
+    @Test("Both tables count the filtered rows")
+    func tablesCountFilteredRows() {
+        let grid = HostedDataGrid(rows: Self.statuses)
+        defer { grid.close() }
+
+        grid.model.setValueFilter(Self.onlyActive)
+
+        #expect(grid.controller.numberOfRows(in: grid.main) == 2)
+        #expect(grid.main.numberOfRows == 2)
+        #expect(grid.frozen.numberOfRows == 2)
+    }
+
+    @Test("Filters on two columns intersect")
+    func filtersIntersect() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+
+        model.setValueFilter(Self.filter(["c"], column: 1, named: "name", onto: Self.onlyActive))
+
+        #expect(model.order.filteredIDs == [.existing(2)])
+        #expect(model.rowCount == 1)
+    }
+
+    @Test("Choosing NULL alone keeps only the NULL rows")
+    func nullSelectionMatchesNullRows() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+
+        model.setValueFilter(Self.filter([], includesNull: true, column: 0, named: "status"))
+
+        #expect(model.order.filteredIDs == [.existing(3)])
+    }
+
+    @Test("Clearing one filter leaves the other narrowing the rows")
+    func clearingOneFilterRecomputes() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+        model.setValueFilter(Self.filter(["c"], column: 1, named: "name", onto: Self.onlyActive))
+
+        var remaining = model.store.valueFilter
+        remaining.clear(column: 1)
+        model.setValueFilter(remaining)
+
+        #expect(model.order.filteredIDs == [.existing(0), .existing(2)])
+    }
+
+    @Test("Clearing every filter shows every loaded row again")
+    func clearingAllRestoresRows() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+        model.setValueFilter(Self.onlyActive)
+
+        model.setValueFilter(GridValueFilterState())
+
+        #expect(!model.order.isFiltered)
+        #expect(model.rowCount == 4)
+    }
+
+    @Test("A row added while a filter is on stays visible")
+    func insertedRowsStayVisible() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+        model.setValueFilter(Self.onlyActive)
+
+        model.apply(owner.tableRows.appendInsertedRow(values: [.text("inactive"), .text("z")]))
+
+        #expect(model.rowCount == 3)
+        #expect(model.order.filteredIDs?.last?.isInserted == true)
+    }
+
+    // MARK: - New columns
+
+    @Test("A result without the filtered column drops its filter")
+    func reloadPrunesStaleFilters() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+        model.setValueFilter(Self.onlyActive)
+
+        owner.tableRows.columns = ["other", "name"]
+        model.reloadRows()
+
+        #expect(!model.store.valueFilter.isActive)
+        #expect(!model.order.isFiltered)
+        #expect(model.rowCount == 4)
+    }
+
+    @Test("A filter follows its column by name when the columns move, and a renamed column drops it")
+    func filterFollowsColumnByName() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(owner)
+        model.setValueFilter(Self.onlyActive)
+
+        let swapped = Self.statuses.rows.map { Row(id: $0.id, values: [$0.values[1], $0.values[0]]) }
+        owner.tableRows = TableRows(
+            rows: ContiguousArray(swapped),
+            columns: ["name", "status"],
+            columnTypes: [.text(rawType: nil), .text(rawType: nil)]
+        )
+        model.reloadRows()
+
+        #expect(model.store.valueFilter.isActive(column: 1))
+        #expect(!model.store.valueFilter.isActive(column: 0))
+        #expect(model.order.filteredIDs == [.existing(0), .existing(2)])
+
+        owner.tableRows.columns = ["name", "state"]
+        model.reloadRows()
+
+        #expect(!model.store.valueFilter.isActive)
+        #expect(model.rowCount == 4)
+    }
+
+    @Test("The inspector reads the model's formats only for the columns they were set on")
+    func inspectorFormatsRequireMatchingColumns() throws {
+        let owner = GridTestOwner(TableRows(
+            rows: [Row(id: .existing(0), values: [.bytes(Data(repeating: 0xAA, count: 16))])],
+            columns: ["id"],
+            columnTypes: [.blob(rawType: "BYTEA")]
+        ))
+        let model = makeModel(owner)
+        let column = try #require(model.columns.column(at: 0))
+
+        model.setDisplayFormat(.uuid, for: column)
+
+        #expect(InspectorValueDisplayFormatResolver.activeFormats(from: model, matching: ["id"]) == [.uuid])
+        #expect(InspectorValueDisplayFormatResolver.activeFormats(from: model, matching: ["payload"]) == nil)
+        #expect(InspectorValueDisplayFormatResolver.activeFormats(from: nil, matching: ["id"]) == nil)
+    }
+
+    // MARK: - Confirming a change of order
+
+    @Test("A grid with no owner applies its filter directly")
+    func ownerlessGridAppliesImmediately() {
+        let owner = GridTestOwner(Self.statuses)
+        let model = makeModel(dataSource: owner, actions: nil)
+
+        model.setValueFilter(Self.onlyActive)
+
+        #expect(model.store.valueFilter.isActive)
+        #expect(model.rowCount == 2)
+    }
+
+    @Test("A grid with an owner asks before it narrows anything")
+    func ownedGridAsksFirst() {
+        let owner = DeferringOwner(Self.statuses)
+        let model = makeModel(dataSource: owner, actions: owner)
+
+        model.setValueFilter(Self.onlyActive)
+
+        #expect(owner.askedCount == 1)
+        #expect(!model.store.valueFilter.isActive)
+        #expect(!model.order.isFiltered)
+    }
+
+    @Test("Approving the change applies the filter")
+    func approvingApplies() {
+        let owner = DeferringOwner(Self.statuses)
+        let model = makeModel(dataSource: owner, actions: owner)
+        model.setValueFilter(Self.onlyActive)
+
+        owner.confirm()
+
+        #expect(model.store.valueFilter.isActive)
+        #expect(model.rowCount == 2)
+    }
+
+    @Test("Declining the change leaves the rows as they were")
+    func decliningLeavesRowsAlone() {
+        let owner = DeferringOwner(Self.statuses)
+        let model = makeModel(dataSource: owner, actions: owner)
+
+        model.setValueFilter(Self.onlyActive)
+        owner.discard()
+
+        #expect(!model.store.valueFilter.isActive)
+        #expect(model.rowCount == 4)
+    }
+
+    @Test("Clearing every filter asks as well")
+    func clearingAsksFirst() {
+        let owner = DeferringOwner(Self.statuses)
+        let model = makeModel(dataSource: owner, actions: owner)
+        model.setValueFilter(Self.onlyActive)
+        owner.confirm()
+
+        model.setValueFilter(GridValueFilterState())
+        #expect(owner.askedCount == 2)
+        #expect(model.store.valueFilter.isActive)
+
+        owner.confirm()
+        #expect(!model.store.valueFilter.isActive)
+    }
+
+    @Test("Applying the filter the grid already has asks nothing")
+    func reapplyingTheSameFilterAsksNothing() {
+        let owner = DeferringOwner(Self.statuses)
+        let model = makeModel(dataSource: owner, actions: owner)
+        model.setValueFilter(Self.onlyActive)
+        owner.confirm()
+
+        model.setValueFilter(Self.onlyActive)
+
+        #expect(owner.askedCount == 1)
+    }
+
+    @Test("Clearing when nothing is filtered asks nothing")
+    func clearingWithNoFilterAsksNothing() {
+        let owner = DeferringOwner(Self.statuses)
+        let model = makeModel(dataSource: owner, actions: owner)
+
+        model.setValueFilter(GridValueFilterState())
+
+        #expect(owner.askedCount == 0)
+    }
+
+    // MARK: - The popover
+
+    // The confirmation is a sheet answered later, so the popover and its picks stay until the change lands.
+    @Test("The popover closes only once its change is applied; declining the change leaves it open")
+    func popoverClosesOnceTheFilterApplies() throws {
+        let grid = HostedDataGrid(rows: Self.statuses)
+        defer { grid.close() }
+        let popover = EditingCloseCountingPopover()
+        grid.controller.menuState.valueFilterPopover = popover
+        let status = try #require(grid.model.columns.columns.first { $0.name == "status" })
+        let onlyActive = ColumnValueFilter(selectedValues: ["active"], includesNull: false)
+
+        grid.owner.approvesDisplayOrderChange = false
+        #expect(grid.controller.applyValueFilter(onlyActive, to: status))
+        #expect(grid.owner.displayOrderRequests == 1)
+        #expect(popover.closeCount == 0)
+        #expect(grid.controller.menuState.valueFilterPopover === popover)
+
+        grid.owner.approvesDisplayOrderChange = true
+        #expect(grid.controller.applyValueFilter(onlyActive, to: status))
+        #expect(grid.model.rowCount == 2)
+        #expect(popover.closeCount == 1)
+        #expect(grid.controller.menuState.valueFilterPopover == nil)
+
+        #expect(!grid.controller.applyValueFilter(onlyActive, to: status), "the same filter is no change")
+        #expect(grid.owner.displayOrderRequests == 2)
+    }
+
+    @Test("Replacing the rows closes an open value filter, whose values were the old rows'")
+    func replacingTheRowsClosesTheValueFilter() {
+        let grid = HostedDataGrid(rows: Self.statuses)
+        defer { grid.close() }
+        let popover = EditingCloseCountingPopover()
+        grid.controller.menuState.valueFilterPopover = popover
+
+        grid.owner.tableRows = TableRows(
+            rows: [Row(id: .existing(0), values: [.text("archived"), .text("z")])],
+            columns: ["status", "name"],
+            columnTypes: [.text(rawType: nil), .text(rawType: nil)]
+        )
+        grid.model.reloadRows()
+
+        #expect(popover.closeCount == 1)
+        #expect(grid.controller.menuState.valueFilterPopover == nil)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridViewportTests.swift b/apple/TableProTests/Views/DataGrid/DataGridViewportTests.swift
new file mode 100644
index 0000000000..b5ada9e63f
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridViewportTests.swift
@@ -0,0 +1,141 @@
+//
+//  DataGridViewportTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+@MainActor
+struct DataGridViewportTests {
+    private func makeGrid() -> HostedDataGrid {
+        HostedDataGrid(rows: GridFixtureRows.wide(rows: 300), size: NSSize(width: 500, height: 300))
+    }
+
+    private func scroll(_ grid: HostedDataGrid, toRow row: Int, offset: CGFloat = 0, horizontal: CGFloat = 0) {
+        let table = grid.main
+        table.scroll(NSPoint(x: horizontal, y: table.rect(ofRow: row).minY + offset - grid.controller.headerInset))
+    }
+
+    private func placement(row: Int?, offset: CGFloat = 0, selecting: [RowID] = [], reveals: Bool = false) -> GridViewportPlacement {
+        GridViewportPlacement(
+            firstVisibleRow: row.map { RowID.existing($0) },
+            firstVisibleOffset: offset,
+            selectedRows: selecting,
+            revealsSelection: reveals
+        )
+    }
+
+    @Test("The grid carries the header inset AppKit puts on the clip view")
+    func gridHasAHeaderInset() {
+        let grid = makeGrid()
+        defer { grid.close() }
+
+        #expect(grid.main.headerView != nil)
+        #expect(grid.controller.headerInset > 0)
+    }
+
+    @Test("The sample names the first row the header does not cover and how far it is scrolled past")
+    func sampleReadsTheFirstVisibleRow() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+        scroll(grid, toRow: 50, offset: 5)
+
+        let sample = try #require(grid.controller.viewportSample())
+
+        #expect(sample.row == 50)
+        #expect(sample.offset == 5)
+        #expect(grid.model.viewportSample()?.row == 50)
+    }
+
+    @Test("The first row placement puts row 0 below the header and keeps the horizontal position")
+    func firstRowSitsBelowTheHeader() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+        scroll(grid, toRow: 80, horizontal: 120)
+        let clip = grid.mainScrollView.contentView
+        let horizontal = clip.bounds.origin.x
+        try #require(horizontal > 0)
+
+        grid.model.store.viewportAnchor = .firstRow
+        grid.controller.applyStagedViewport()
+
+        #expect(clip.bounds.origin.y == -grid.controller.headerInset)
+        #expect(grid.controller.viewportSample()?.row == 0)
+        #expect(clip.bounds.origin.x == horizontal)
+        #expect(grid.model.store.viewportAnchor == nil)
+    }
+
+    @Test("An anchored placement puts its row back where the reader had it")
+    func anchoredPlacementRestoresTheRowAndOffset() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+
+        grid.model.store.viewportAnchor = placement(row: 120, offset: 4)
+        grid.controller.applyStagedViewport()
+
+        let sample = try #require(grid.controller.viewportSample())
+        #expect(sample.row == 120)
+        #expect(sample.offset == 4)
+    }
+
+    @Test("A placement staged before a reload is applied by that reload, once")
+    func stagedPlacementLandsOnReload() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+
+        grid.model.store.viewportAnchor = placement(row: 120)
+        grid.model.reloadRows()
+
+        #expect(grid.controller.viewportSample()?.row == 120)
+        #expect(grid.model.store.viewportAnchor == nil)
+    }
+
+    @Test("A taller header inset is honoured the same way")
+    func tallerInsetIsHonoured() throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+        grid.mainScrollView.automaticallyAdjustsContentInsets = false
+        grid.mainScrollView.contentInsets = NSEdgeInsets(top: 14, left: 0, bottom: 0, right: 0)
+        grid.layout()
+        let inset = grid.controller.headerInset
+        try #require(inset > 0)
+
+        grid.model.store.viewportAnchor = placement(row: 60)
+        grid.controller.applyStagedViewport()
+        #expect(grid.controller.viewportSample()?.row == 60)
+
+        grid.model.store.viewportAnchor = .firstRow
+        grid.controller.applyStagedViewport()
+        #expect(grid.mainScrollView.contentView.bounds.origin.y == -inset)
+    }
+
+    @Test("A placement that reveals its selection selects the row and scrolls it into view")
+    func revealedRowIsSelectedAndVisible() async throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+
+        grid.model.store.viewportAnchor = placement(row: nil, selecting: [.existing(250)], reveals: true)
+        grid.controller.applyStagedViewport()
+
+        try await waitUntil { grid.main.selectedRowIndexes == IndexSet(integer: 250) }
+        #expect(grid.model.selectedRowIDs == [.existing(250)])
+        #expect(NSLocationInRange(250, grid.main.rows(in: grid.main.visibleRect)))
+    }
+
+    @Test("Revealing a row scrolls the frozen pane with it")
+    func revealScrollsBothPanes() async throws {
+        let grid = makeGrid()
+        defer { grid.close() }
+
+        grid.model.reveal(rowID: .existing(200))
+
+        let mainClip = grid.mainScrollView.contentView
+        let frozenClip = grid.frozenScrollView.contentView
+        #expect(NSLocationInRange(200, grid.main.rows(in: grid.main.visibleRect)))
+        try await waitUntil { frozenClip.bounds.origin.y == mainClip.bounds.origin.y }
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataGridZoomCommandTests.swift b/apple/TableProTests/Views/DataGrid/DataGridZoomCommandTests.swift
new file mode 100644
index 0000000000..2f77a602f2
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataGridZoomCommandTests.swift
@@ -0,0 +1,149 @@
+//
+//  DataGridZoomCommandTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+@MainActor
+private func zoomResponder(from responder: NSResponder?) -> NSResponder? {
+    var responder = responder
+    while let current = responder, !current.responds(to: #selector(ZoomCommandResponding.zoomIn(_:))) {
+        responder = current.nextResponder
+    }
+    return responder
+}
+
+@MainActor
+private func menuItem(_ action: Selector) -> NSMenuItem {
+    NSMenuItem(title: "", action: action, keyEquivalent: "")
+}
+
+@MainActor
+private func zoomRows(_ count: Int) -> TableRows {
+    TableRows.from(
+        queryRows: (0..<count).map { [PluginCellValue.text("value \($0)")] },
+        columns: ["name"],
+        columnTypes: [.text(rawType: "TEXT")]
+    )
+}
+
+extension GlobalStateSuites {
+    @Suite(.appSettings {
+        $0.typography = TypographySettings(editorFontSize: 13, dataGridFontSize: 13)
+        $0.dataGrid.rowHeight = .normal
+    })
+    @MainActor
+    struct DataGridZoomCommandTests {
+        @Test("From a focused grid the command reaches the grid's table before the window")
+        func focusedGridClaimsTheCommand() {
+            let grid = HostedDataGrid(rows: zoomRows(2))
+            defer { grid.close() }
+
+            #expect(grid.focus())
+
+            #expect(zoomResponder(from: grid.window.firstResponder) === grid.main)
+        }
+
+        @Test("Zoom In and Zoom Out change the Data Grid font and leave the editor font")
+        func zoomChangesTheGridFontOnly() {
+            let table = DataGridTableView(frame: .zero)
+
+            table.zoomIn(nil)
+            #expect(AppSettingsManager.shared.typography.dataGridFontSize == 14)
+            #expect(AppSettingsManager.shared.typography.editorFontSize == 13)
+
+            table.zoomOut(nil)
+            table.zoomOut(nil)
+            #expect(AppSettingsManager.shared.typography.dataGridFontSize == 12)
+            #expect(AppSettingsManager.shared.typography.editorFontSize == 13)
+        }
+
+        @Test(
+            "Zoom In dims at the largest size instead of falling through to the editor",
+            .appSettings { $0.typography.dataGridFontSize = TypographySettings.sizeRange.upperBound }
+        )
+        func zoomInDimsAtTheLargestSize() {
+            let table = DataGridTableView(frame: .zero)
+
+            #expect(!table.validateUserInterfaceItem(menuItem(#selector(ZoomCommandResponding.zoomIn(_:)))))
+            #expect(table.validateUserInterfaceItem(menuItem(#selector(ZoomCommandResponding.zoomOut(_:)))))
+
+            table.zoomIn(nil)
+            #expect(AppSettingsManager.shared.typography.dataGridFontSize == TypographySettings.sizeRange.upperBound)
+            #expect(AppSettingsManager.shared.typography.editorFontSize == 13)
+        }
+
+        @Test(
+            "Zoom Out dims at the smallest size",
+            .appSettings { $0.typography.dataGridFontSize = TypographySettings.sizeRange.lowerBound }
+        )
+        func zoomOutDimsAtTheSmallestSize() {
+            let table = DataGridTableView(frame: .zero)
+
+            #expect(table.validateUserInterfaceItem(menuItem(#selector(ZoomCommandResponding.zoomIn(_:)))))
+            #expect(!table.validateUserInterfaceItem(menuItem(#selector(ZoomCommandResponding.zoomOut(_:)))))
+        }
+
+        @Test(
+            "A font taller than the chosen row height grows the rows of both panes of an open grid",
+            .appSettings {
+                $0.typography.dataGridFontSize = TypographySettings.sizeRange.upperBound - 1
+                $0.dataGrid.rowHeight = .compact
+            }
+        )
+        func rowsGrowWithTheFont() async throws {
+            let grid = HostedDataGrid(rows: zoomRows(2))
+            defer { grid.close() }
+            let before = grid.main.rowHeight
+            #expect(before > CGFloat(DataGridRowHeight.compact.rawValue))
+
+            grid.main.zoomIn(nil)
+
+            let font = ThemeEngine.shared.dataGridFonts.regular
+            let expected = DataGridMetrics.rowHeight(.compact, font: font)
+            try await waitUntil { grid.main.rowHeight == expected && grid.main.rowHeight > before }
+            #expect(grid.main.rowHeight >= font.ascender - font.descender + font.leading)
+            #expect(grid.frozen.rowHeight == grid.main.rowHeight)
+        }
+
+        @Test(
+            "Rows that grow with a zoom keep the first visible row in place",
+            .appSettings { $0.typography.dataGridFontSize = 20 }
+        )
+        func zoomKeepsTheFirstVisibleRow() async throws {
+            let grid = HostedDataGrid(rows: zoomRows(10_000))
+            defer { grid.close() }
+            let table = grid.main
+            table.scroll(NSPoint(x: 0, y: table.rect(ofRow: 5_000).minY - grid.controller.headerInset))
+            let before = try #require(grid.controller.viewportSample())
+            try #require(before.row > 4_000)
+            let rowHeight = table.rowHeight
+
+            table.zoomIn(nil)
+
+            try await waitUntil { table.rowHeight != rowHeight }
+            #expect(grid.controller.viewportSample()?.row == before.row)
+        }
+
+        @Test("The row height setting stands while the font fits in it")
+        func settingStandsForAFittingFont() {
+            let font = NSFont.monospacedSystemFont(ofSize: 13, weight: .regular)
+            #expect(DataGridMetrics.rowHeight(.normal, font: font) == CGFloat(DataGridRowHeight.normal.rawValue))
+            #expect(DataGridMetrics.rowHeight(.compact, font: font) == CGFloat(DataGridRowHeight.compact.rawValue))
+        }
+
+        @Test("A font taller than the row raises the row to hold the whole line")
+        func tallFontRaisesTheRow() {
+            let font = NSFont.monospacedSystemFont(ofSize: 24, weight: .regular)
+            let height = DataGridMetrics.rowHeight(.normal, font: font)
+            #expect(height > CGFloat(DataGridRowHeight.normal.rawValue))
+            #expect(height >= font.ascender - font.descender + font.leading)
+            #expect(height == height.rounded())
+        }
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataTabColumnJumpTests.swift b/apple/TableProTests/Views/DataGrid/DataTabColumnJumpTests.swift
new file mode 100644
index 0000000000..16bbcb0d5c
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataTabColumnJumpTests.swift
@@ -0,0 +1,264 @@
+//
+//  DataTabColumnJumpTests.swift
+//  TableProTests
+//
+
+import AppKit
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+// Stands in for a mounted grid, so the data tab's jump sees its grid on screen.
+@MainActor
+private final class MountedGridStub: DataGridMountedView {
+    private(set) var revealed: [(row: Int, displayColumn: Int?)] = []
+    private(set) var focusRequests = 0
+    var firstVisibleRow: Int?
+
+    func apply(_ change: DataGridChange) {}
+    func selectionDidChange() {}
+    func configurationDidChange() {}
+
+    func reveal(row: Int, displayColumn: Int?) {
+        revealed.append((row, displayColumn))
+    }
+
+    func revealColumn(_ displayColumn: Int) {}
+    func sortDidChange() {}
+    func summaryRulesDidChange() {}
+    func viewportSample() -> (row: Int, offset: CGFloat)? { firstVisibleRow.map { (row: $0, offset: 0) } }
+    func beginEditing(row: Int, displayColumn: Int) -> Bool { false }
+    var isEditing: Bool { false }
+    func commitEditing() -> Bool { true }
+    func discardEditing() {}
+
+    func focus() -> Bool {
+        focusRequests += 1
+        return true
+    }
+
+    func anchor(forColumn displayColumn: Int) -> (view: NSView, rect: NSRect)? { nil }
+}
+
+@MainActor
+struct DataTabColumnJumpTests {
+    private let fixture = CoordinatorFixture()
+    private let mounted = MountedGridStub()
+
+    private func mountGrid(
+        columns: [String] = ["id", "name", "email"],
+        rowCount: Int = 2
+    ) -> (tab: QueryTab, model: DataGridModel) {
+        let tab = QueryTab(title: "Query 1", query: "SELECT 1", tabType: .query)
+        let rows = TableRows.from(
+            queryRows: (0..<rowCount).map { row in columns.map { PluginCellValue.text("\($0) \(row)") } },
+            columns: columns,
+            columnTypes: Array(repeating: .text(rawType: "TEXT"), count: columns.count)
+        )
+        fixture.addTab(tab, rows: rows)
+        let model = fixture.coordinator.gridModel(forTab: tab.id)
+        model.attach(mounted)
+        return (tab, model)
+    }
+
+    private func entry(_ name: String, dataIndex: Int) -> GridColumnEntry {
+        GridColumnEntry(name: name, dataIndex: dataIndex, typeName: nil, position: dataIndex, isHidden: false)
+    }
+
+    private func jump(to entry: GridColumnEntry, tab: QueryTab, model: DataGridModel) {
+        fixture.coordinator.jumpToColumn(entry, from: ColumnJumpOrigin(tabId: tab.id, model: model))
+    }
+
+    private func park(
+        _ name: String,
+        dataIndex: Int? = nil,
+        tableKey: ColumnLayoutTableKey? = nil,
+        awaitsResultReplacement: Bool = false,
+        on tab: QueryTab
+    ) {
+        fixture.coordinator.dataGridEntries[tab.id]?.adapter.pendingColumnJump = ColumnJumpRequest(
+            name: name,
+            dataIndex: dataIndex,
+            tableKey: tableKey,
+            awaitsResultReplacement: awaitsResultReplacement
+        )
+    }
+
+    private func parked(on tab: QueryTab) -> ColumnJumpRequest? {
+        fixture.coordinator.dataGridEntries[tab.id]?.adapter.pendingColumnJump
+    }
+
+    private func consume(_ tab: QueryTab, contentReplaced: Bool) {
+        fixture.coordinator.consumePendingColumnJump(forTab: tab.id, contentReplaced: contentReplaced)
+    }
+
+    // MARK: - A column on screen
+
+    @Test("A jump puts the active cell in the column on the first row when nothing is selected")
+    func jumpSeedsTheActiveCell() {
+        let (tab, model) = mountGrid()
+
+        jump(to: entry("email", dataIndex: 2), tab: tab, model: model)
+
+        #expect(model.selection == GridSelectionReducer.cursor(
+            GridCoord(row: 0, displayColumn: 2),
+            in: GridSelectionContext(rowCount: model.rowCount, columnCount: model.columns.count)
+        ))
+        #expect(model.activeCell?.column.name == "email")
+        #expect(mounted.revealed.last?.row == 0)
+        #expect(mounted.revealed.last?.displayColumn == 2)
+        #expect(mounted.focusRequests == 1)
+    }
+
+    @Test("A jump with nothing selected lands on the first visible row, not the top")
+    func jumpWithoutSelectionKeepsTheScrolledPlace() {
+        let (tab, model) = mountGrid(rowCount: 50)
+        mounted.firstVisibleRow = 30
+
+        jump(to: entry("email", dataIndex: 2), tab: tab, model: model)
+
+        #expect(model.selection.activeCell == GridCoord(row: 30, displayColumn: 2))
+        #expect(mounted.revealed.last?.row == 30)
+    }
+
+    @Test("A jump keeps the active row")
+    func jumpKeepsTheActiveRow() {
+        let (tab, model) = mountGrid()
+        model.setSelection(GridSelectionReducer.single(GridCoord(row: 1, displayColumn: 0)))
+
+        jump(to: entry("name", dataIndex: 1), tab: tab, model: model)
+
+        #expect(model.selection.activeCell == GridCoord(row: 1, displayColumn: 1))
+        #expect(model.activeCell?.column.name == "name")
+    }
+
+    @Test("A jump with no rows seeds no active cell")
+    func jumpWithoutRows() {
+        let (tab, model) = mountGrid(rowCount: 0)
+
+        jump(to: entry("email", dataIndex: 2), tab: tab, model: model)
+
+        #expect(model.selection == .empty)
+        #expect(mounted.revealed.isEmpty)
+    }
+
+    @Test("A jump from a panel opened over another tab does nothing")
+    func jumpFromAnotherTabIsDropped() {
+        let (_, model) = mountGrid()
+
+        fixture.coordinator.jumpToColumn(entry("email", dataIndex: 2), from: ColumnJumpOrigin(tabId: UUID(), model: model))
+
+        #expect(model.selection == .empty)
+    }
+
+    @Test("A jump whose column moved off its index does nothing")
+    func staleEntryIsDropped() {
+        let (tab, model) = mountGrid()
+
+        jump(to: entry("email", dataIndex: 1), tab: tab, model: model)
+
+        #expect(model.selection == .empty)
+    }
+
+    @Test("A frozen column is a jump target like any other")
+    func jumpToAFrozenColumn() {
+        let (tab, model) = mountGrid()
+        model.updateColumnLayout { $0.frozenColumnCount = 1 }
+
+        jump(to: entry("id", dataIndex: 0), tab: tab, model: model)
+
+        #expect(model.activeCell?.column.name == "id")
+    }
+
+    // MARK: - A parked jump
+
+    @Test("A parked jump waits for its column to be presented, then lands once")
+    func parkedJumpLandsWhenPresented() {
+        let (tab, model) = mountGrid()
+        model.updateColumnLayout { $0.hiddenColumns = ["name"] }
+        park("name", on: tab)
+
+        consume(tab, contentReplaced: false)
+        #expect(parked(on: tab)?.name == "name")
+        #expect(model.selection == .empty)
+
+        model.updateColumnLayout { $0.hiddenColumns = [] }
+        consume(tab, contentReplaced: false)
+
+        #expect(parked(on: tab) == nil)
+        #expect(model.activeCell?.column.name == "name")
+    }
+
+    @Test("A parked jump on a duplicate name lands on the chosen column")
+    func parkedJumpKeepsTheChosenDuplicate() {
+        let (tab, model) = mountGrid(columns: ["id", "name", "name"])
+        model.updateColumnLayout { $0.hiddenColumns = ["name"] }
+        park("name", dataIndex: 2, on: tab)
+
+        model.updateColumnLayout { $0.hiddenColumns = [] }
+        consume(tab, contentReplaced: false)
+
+        #expect(parked(on: tab) == nil)
+        #expect(model.activeCell?.column.dataIndex == 2)
+    }
+
+    @Test("A jump parked for a refetch waits for the new result")
+    func parkedJumpWaitsForTheResult() {
+        let (tab, model) = mountGrid()
+        park("name", dataIndex: 1, awaitsResultReplacement: true, on: tab)
+
+        consume(tab, contentReplaced: false)
+        #expect(parked(on: tab) != nil)
+        #expect(model.selection == .empty)
+
+        consume(tab, contentReplaced: true)
+        #expect(parked(on: tab) == nil)
+        #expect(model.activeCell?.column.name == "name")
+    }
+
+    @Test("A new result that lacks the column drops the parked jump instead of arming it forever")
+    func replacementWithoutTheColumnDropsTheJump() {
+        let (tab, _) = mountGrid()
+        park("elsewhere", on: tab)
+
+        consume(tab, contentReplaced: false)
+        #expect(parked(on: tab) != nil)
+
+        consume(tab, contentReplaced: true)
+        #expect(parked(on: tab) == nil)
+    }
+
+    @Test("A jump that lands supersedes a jump still parked")
+    func directJumpSupersedesTheParkedJump() {
+        let (tab, model) = mountGrid()
+        park("name", dataIndex: 1, on: tab)
+
+        jump(to: entry("email", dataIndex: 2), tab: tab, model: model)
+
+        #expect(parked(on: tab) == nil)
+        #expect(model.activeCell?.column.name == "email")
+    }
+
+    @Test("A parked jump made against another table is dropped")
+    func parkedJumpForAnotherTableIsDropped() {
+        let (tab, model) = mountGrid()
+        let otherTable = ColumnLayoutTableKey(connectionId: UUID(), databaseName: "db", schemaName: nil, tableName: "other")
+        park("name", dataIndex: 1, tableKey: otherTable, on: tab)
+
+        consume(tab, contentReplaced: false)
+
+        #expect(parked(on: tab) == nil)
+        #expect(model.selection == .empty)
+    }
+
+    @Test("Releasing the grid drops a parked jump")
+    func releaseDropsTheParkedJump() {
+        let (tab, _) = mountGrid()
+        park("name", dataIndex: 1, on: tab)
+
+        fixture.coordinator.releaseGridModel(forTab: tab.id)
+
+        #expect(parked(on: tab) == nil)
+        #expect(fixture.coordinator.existingGridModel(forTab: tab.id) == nil)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/DataTabColumnLayoutStoreTests.swift b/apple/TableProTests/Views/DataGrid/DataTabColumnLayoutStoreTests.swift
new file mode 100644
index 0000000000..cd86911560
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/DataTabColumnLayoutStoreTests.swift
@@ -0,0 +1,230 @@
+//
+//  DataTabColumnLayoutStoreTests.swift
+//  TableProTests
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+private final class IsolatedLayoutPersister {
+    let directory: URL
+    let persister: FileColumnLayoutPersister
+
+    init() {
+        directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("TableProTests-\(UUID().uuidString)", isDirectory: true)
+        persister = FileColumnLayoutPersister(storageDirectory: directory)
+    }
+
+    deinit {
+        try? FileManager.default.removeItem(at: directory)
+    }
+}
+
+// The data tab's grid store: what layout a tab's grid reads, and when a table's layout is written.
+@MainActor
+struct DataTabColumnLayoutStoreTests {
+    private let fixture = CoordinatorFixture()
+    private let storage = IsolatedLayoutPersister()
+
+    private static func rows(_ columns: [String]) -> TableRows {
+        TableRows.from(
+            queryRows: [columns.map { PluginCellValue.text("\($0) value") }],
+            columns: columns,
+            columnTypes: Array(repeating: .text(rawType: "TEXT"), count: columns.count)
+        )
+    }
+
+    private static func layout(
+        widths: [String: CGFloat] = [:],
+        order: [String]? = nil,
+        hidden: Set<String> = []
+    ) -> ColumnLayoutState {
+        var layout = ColumnLayoutState()
+        layout.columnWidths = widths
+        layout.columnOrder = order
+        layout.hiddenColumns = hidden
+        return layout
+    }
+
+    private func makeStore(
+        for tab: QueryTab,
+        rows: TableRows,
+        layout: ColumnLayoutState = ColumnLayoutState()
+    ) -> QueryTabGridStateStore {
+        var tab = tab
+        tab.columnLayout = layout
+        fixture.addTab(tab, rows: rows)
+        return QueryTabGridStateStore(tabId: tab.id, coordinator: fixture.coordinator, persister: storage.persister)
+    }
+
+    private func tableTab(_ name: String? = "users") -> QueryTab {
+        QueryTab(title: name ?? "table", query: "SELECT * FROM \(name ?? "t")", tabType: .table, tableName: name)
+    }
+
+    private func queryTab() -> QueryTab {
+        QueryTab(title: "Query 1", query: "SELECT 1", tabType: .query)
+    }
+
+    private func savedTab(_ id: UUID) -> QueryTab? {
+        fixture.tabManager.tabs.first { $0.id == id }
+    }
+
+    // MARK: - What a tab reads
+
+    @Test("A table tab reads its geometry from the saved table layout over the tab's own")
+    func tableTabPrefersTheSavedLayout() throws {
+        let tab = tableTab()
+        let key = try #require(fixture.coordinator.columnLayoutTableKey(for: tab))
+        storage.persister.save(Self.layout(widths: ["id": 60]), for: key)
+
+        let store = makeStore(
+            for: tab,
+            rows: Self.rows(["id", "name"]),
+            layout: Self.layout(widths: ["other": 999], hidden: ["name"])
+        )
+
+        #expect(store.layoutScope == .table(key))
+        #expect(store.columnLayout.columnWidths == ["id": 60])
+        #expect(store.columnLayout.hiddenColumns == ["name"])
+    }
+
+    @Test("A table tab with nothing saved reads the tab's own layout")
+    func tableTabFallsBackToTheTab() {
+        let store = makeStore(for: tableTab(), rows: Self.rows(["id"]), layout: Self.layout(widths: ["id": 60]))
+
+        #expect(store.columnLayout.columnWidths == ["id": 60])
+    }
+
+    @Test("A table tab with no table name keeps its layout on the tab")
+    func tableTabWithoutATableIsEphemeral() throws {
+        let saved = tableTab()
+        let key = try #require(fixture.coordinator.columnLayoutTableKey(for: saved))
+        storage.persister.save(Self.layout(widths: ["id": 60]), for: key)
+
+        let store = makeStore(for: tableTab(nil), rows: Self.rows(["id"]), layout: Self.layout(widths: ["fallback": 42]))
+
+        #expect(store.layoutScope == .ephemeral)
+        #expect(store.columnLayout.columnWidths == ["fallback": 42])
+    }
+
+    @Test("A query tab drops a saved order its columns no longer match and keeps the widths")
+    func queryTabDropsAStaleOrder() {
+        let store = makeStore(
+            for: queryTab(),
+            rows: Self.rows(["id", "business_model", "region"]),
+            layout: Self.layout(widths: ["id": 60, "business_model": 120], order: ["id", "business_model"])
+        )
+
+        #expect(store.layoutScope == .ephemeral)
+        #expect(store.columnLayout.columnOrder == nil)
+        #expect(store.columnLayout.columnWidths == ["id": 60, "business_model": 120])
+    }
+
+    @Test("A query tab keeps an order saved for the same columns")
+    func queryTabKeepsAMatchingOrder() {
+        let store = makeStore(
+            for: queryTab(),
+            rows: Self.rows(["id", "business_model"]),
+            layout: Self.layout(order: ["business_model", "id"])
+        )
+
+        #expect(store.columnLayout.columnOrder == ["business_model", "id"])
+    }
+
+    @Test("A query tab drops an order when two columns share a name")
+    func queryTabDropsAnOrderOverDuplicateNames() {
+        let store = makeStore(
+            for: queryTab(),
+            rows: Self.rows(["id", "id"]),
+            layout: Self.layout(widths: ["id": 60], order: ["id", "id"])
+        )
+
+        #expect(store.columnLayout.columnOrder == nil)
+        #expect(store.columnLayout.columnWidths == ["id": 60])
+    }
+
+    @Test("A query tab's dropped order stays on the tab for when its columns come back")
+    func droppedOrderStaysOnTheTab() {
+        let tab = queryTab()
+        let store = makeStore(
+            for: tab,
+            rows: Self.rows(["id", "region"]),
+            layout: Self.layout(order: ["id", "business_model"])
+        )
+
+        var layout = store.columnLayout
+        layout.columnWidths = ["id": 80]
+        store.columnLayout = layout
+
+        #expect(savedTab(tab.id)?.columnLayout.columnWidths == ["id": 80])
+        #expect(savedTab(tab.id)?.columnLayout.columnOrder == ["id", "business_model"])
+    }
+
+    // MARK: - When a table's layout is written
+
+    @Test("A table tab's layout reaches the saved table layout only once the write is flushed")
+    func writeWaitsForTheFlush() throws {
+        let tab = tableTab()
+        let key = try #require(fixture.coordinator.columnLayoutTableKey(for: tab))
+        let store = makeStore(for: tab, rows: Self.rows(["name"]))
+
+        store.columnLayout = Self.layout(widths: ["name": 180])
+
+        #expect(storage.persister.load(for: key) == nil)
+        #expect(store.columnLayout.columnWidths == ["name": 180])
+        #expect(savedTab(tab.id)?.columnLayout.columnWidths == ["name": 180])
+
+        store.flushPendingLayout()
+
+        #expect(storage.persister.load(for: key)?.columnWidths == ["name": 180])
+    }
+
+    @Test("Discarding a pending write persists nothing")
+    func discardDropsThePendingWrite() throws {
+        let tab = tableTab()
+        let key = try #require(fixture.coordinator.columnLayoutTableKey(for: tab))
+        let store = makeStore(for: tab, rows: Self.rows(["name"]))
+        store.columnLayout = Self.layout(widths: ["name": 180])
+
+        store.discardPendingLayout()
+        store.flushPendingLayout()
+
+        #expect(storage.persister.load(for: key) == nil)
+    }
+
+    @Test("A reset clears the saved geometry and drops a pending write")
+    func resetClearsTheSavedGeometry() throws {
+        let tab = tableTab()
+        let key = try #require(fixture.coordinator.columnLayoutTableKey(for: tab))
+        storage.persister.save(Self.layout(widths: ["name": 120]), for: key)
+        let store = makeStore(for: tab, rows: Self.rows(["name"]))
+        store.columnLayout = Self.layout(widths: ["name": 180])
+
+        var reset = store.columnLayout
+        reset.resetGeometry()
+        store.columnLayout = reset
+        store.flushPendingLayout()
+
+        #expect(storage.persister.load(for: key) == nil)
+    }
+
+    @Test("A pending write lands on the table it was made for after the tab moves on")
+    func pendingWriteKeepsItsTable() throws {
+        let tab = tableTab("users")
+        let usersKey = try #require(fixture.coordinator.columnLayoutTableKey(for: tab))
+        let store = makeStore(for: tab, rows: Self.rows(["name"]))
+        store.columnLayout = Self.layout(widths: ["name": 180])
+
+        _ = fixture.tabManager.mutate(tabId: tab.id) { $0.tableContext.tableName = "projects" }
+        let moved = try #require(savedTab(tab.id))
+        let projectsKey = try #require(fixture.coordinator.columnLayoutTableKey(for: moved))
+        store.flushPendingLayout()
+
+        #expect(storage.persister.load(for: usersKey)?.columnWidths == ["name": 180])
+        #expect(storage.persister.load(for: projectsKey) == nil)
+    }
+}
diff --git a/apple/TableProTests/Views/DataGrid/HeaderSortCycleTests.swift b/apple/TableProTests/Views/DataGrid/HeaderSortCycleTests.swift
new file mode 100644
index 0000000000..1b9010f000
--- /dev/null
+++ b/apple/TableProTests/Views/DataGrid/HeaderSortCycleTests.swift
@@ -0,0 +1,156 @@
+//
+//  HeaderSortCycleTests.swift
+//  TableProTests
+//
+
+import Foundation
+@testable import TablePro
+import Testing
+
+struct HeaderSortCycleTests {
+    private func click(
+        _ state: SortState,
+        column: Int,
+        addsKey: Bool = false,
+        first: SortDirection = .ascending
+    ) -> SortState {
+        HeaderSortCycle.nextTransition(
+            state: state,
+            clickedColumn: column,
+            isMultiSort: addsKey,
+            firstClickDirection: first
+        ).newState
+    }
+
+    // MARK: - Plain click
+
+    @Test("A click with no sort sorts by that column in the first-click direction")
+    func clickWithNoSortStarts() {
+        #expect(click(SortState(), column: 2).columns == [SortColumn(columnIndex: 2, direction: .ascending)])
+    }
+
+    @Test("A click on the sorted column flips it")
+    func clickOnSortedColumnFlips() {
+        let ascending = SortState(columns: [SortColumn(columnIndex: 2, direction: .ascending)])
+        let descending = click(ascending, column: 2)
+        #expect(descending.columns == [SortColumn(columnIndex: 2, direction: .descending)])
+        #expect(click(descending, column: 2).columns == [SortColumn(columnIndex: 2, direction: .ascending)])
+    }
+
+    @Test("A click never clears the sort: Don't Sort lives in the header menu")
+    func clickNeverClears() {
+        var state = SortState()
+        for _ in 0..<4 {
+            state = click(state, column: 1)
+            #expect(state.columns.count == 1)
+        }
+    }
+
+    @Test("A click on another column replaces the sort with that column")
+    func clickOnOtherColumnReplaces() {
+        let state = SortState(columns: [SortColumn(columnIndex: 1, direction: .descending)])
+        #expect(click(state, column: 4).columns == [SortColumn(columnIndex: 4, direction: .ascending)])
+    }
+
+    @Test("A click on the primary key flips it and drops the secondary keys")
+    func clickOnPrimaryDropsSecondaries() {
+        let state = SortState(columns: [
+            SortColumn(columnIndex: 1, direction: .ascending),
+            SortColumn(columnIndex: 3, direction: .descending),
+        ])
+        #expect(click(state, column: 1).columns == [SortColumn(columnIndex: 1, direction: .descending)])
+    }
+
+    @Test("A click on a secondary key makes it the only key")
+    func clickOnSecondaryReplaces() {
+        let state = SortState(columns: [
+            SortColumn(columnIndex: 1, direction: .ascending),
+            SortColumn(columnIndex: 3, direction: .descending),
+        ])
+        #expect(click(state, column: 3).columns == [SortColumn(columnIndex: 3, direction: .ascending)])
+    }
+
+    @Test("A descending first-click direction starts descending and flips to ascending")
+    func descendingFirstClickDirection() {
+        let first = click(SortState(), column: 1, first: .descending)
+        #expect(first.columns == [SortColumn(columnIndex: 1, direction: .descending)])
+        #expect(click(first, column: 1, first: .descending).columns == [SortColumn(columnIndex: 1, direction: .ascending)])
+    }
+
+    // MARK: - Option-click
+
+    @Test("Option-click on an unsorted column appends it")
+    func optionClickAppends() {
+        let state = SortState(columns: [SortColumn(columnIndex: 1, direction: .ascending)])
+        #expect(click(state, column: 3, addsKey: true).columns == [
+            SortColumn(columnIndex: 1, direction: .ascending),
+            SortColumn(columnIndex: 3, direction: .ascending),
+        ])
+    }
+
+    @Test("Option-click with no sort adds the first key")
+    func optionClickOnEmptyAdds() {
+        #expect(click(SortState(), column: 0, addsKey: true).columns == [SortColumn(columnIndex: 0, direction: .ascending)])
+    }
+
+    @Test("Option-click on a key flips it in place and keeps the others")
+    func optionClickFlipsInPlace() {
+        let state = SortState(columns: [
+            SortColumn(columnIndex: 1, direction: .ascending),
+            SortColumn(columnIndex: 3, direction: .ascending),
+        ])
+        let flipped = click(state, column: 3, addsKey: true)
+        #expect(flipped.columns == [
+            SortColumn(columnIndex: 1, direction: .ascending),
+            SortColumn(columnIndex: 3, direction: .descending),
+        ])
+        #expect(click(flipped, column: 3, addsKey: true).columns == [
+            SortColumn(columnIndex: 1, direction: .ascending),
+            SortColumn(columnIndex: 3, direction: .ascending),
+        ])
+    }
+
+    @Test("Option-click on the primary key flips it and keeps the secondary")
+    func optionClickOnPrimaryKeepsSecondary() {
+        let state = SortState(columns: [
+            SortColumn(columnIndex: 1, direction: .ascending),
+            SortColumn(columnIndex: 3, direction: .descending),
+        ])
+        #expect(click(state, column: 1, addsKey: true).columns == [
+            SortColumn(columnIndex: 1, direction: .descending),
+            SortColumn(columnIndex: 3, direction: .descending),
+        ])
+    }
+
+    @Test("A descending first-click direction appends descending keys")
+    func descendingOptionClickAppends() {
+        let base = SortState(columns: [SortColumn(columnIndex: 0, direction: .descending)], source: .user)
+        let added = click(base, column: 2, addsKey: true, first: .descending)
+        #expect(added.columns.map { $0.direction } == [.descending, .descending])
+        #expect(click(added, column: 2, addsKey: true, first: .descending).columns.map { $0.direction } == [.descending, .ascending])
+    }
+
+    // MARK: - Source
+
+    @Test("A click on a default sort flips it and the result is the user's")
+    func defaultSortClickBecomesUsers() {
+        let state = SortState(columns: [SortColumn(columnIndex: 0, direction: .ascending)], source: .defaultSort)
+        let next = click(state, column: 0)
+        #expect(next.columns == [SortColumn(columnIndex: 0, direction: .descending)])
+        #expect(next.source == .user)
+    }
+
+    @Test("An Option-click on a default sort becomes the user's")
+    func optionClickPromotesDefaultToUser() {
+        let state = SortState(columns: [SortColumn(columnIndex: 0, direction: .ascending)], source: .defaultSort)
+        let next = click(state, column: 3, addsKey: true)
+        #expect(next.columns.map { $0.columnIndex } == [0, 3])
+        #expect(next.source == .user)
+    }
+
+    @Test("A click from an unset sort is the user's")
+    func unsetBecomesUsers() {
+        #expect(click(SortState(), column: 1).source == .user)
+        #expect(click(SortState(), column: 1, addsKey: true).source == .user)
+    }
+}
diff --git a/apple/TableProTests/Views/Results/RowVisualIndexTests.swift b/apple/TableProTests/Views/DataGrid/RowVisualIndexTests.swift
similarity index 81%
rename from apple/TableProTests/Views/Results/RowVisualIndexTests.swift
rename to apple/TableProTests/Views/DataGrid/RowVisualIndexTests.swift
index 671a41f240..395c5de217 100644
--- a/apple/TableProTests/Views/Results/RowVisualIndexTests.swift
+++ b/apple/TableProTests/Views/DataGrid/RowVisualIndexTests.swift
@@ -3,12 +3,12 @@
 //  TableProTests
 //
 
-import Foundation
+import AppKit
+@testable import TablePro
 import TableProPluginKit
+import TableProTheme
 import Testing
 
-@testable import TablePro
-
 @MainActor
 struct RowVisualIndexTests {
     private func makeManager() -> DataChangeManager {
@@ -109,4 +109,20 @@ struct RowVisualIndexTests {
         #expect(index.visualState(for: .existing(2)).expressionColumns.isEmpty)
         #expect(index.visualState(for: inserted).expressionColumns == [1])
     }
+
+    @Test("A deleted or new row tints the whole row from its theme slot, a highlighted one with the rule's wash")
+    func rowTintFollowsTheState() {
+        let scope = ThemeScope.live
+        let highlighted = RowVisualState(
+            isDeleted: false,
+            isInserted: false,
+            modifiedColumns: [],
+            highlight: RowHighlight(rowRule: HighlightRule(columnName: "name", value: "Ann", color: .blue), cellRules: [:])
+        )
+
+        #expect(RowVisualState(isDeleted: true, isInserted: false, modifiedColumns: []).tint(in: scope) == scope.resolved[.gridDeleted])
+        #expect(RowVisualState(isDeleted: false, isInserted: true, modifiedColumns: []).tint(in: scope) == scope.resolved[.gridInserted])
+        #expect(highlighted.tint(in: scope) == HighlightColor.blue.washColor)
+        #expect(RowVisualState.empty.tint(in: scope) == nil)
+    }
 }
diff --git a/apple/TableProTests/Views/DetailSurfaceThemeTests.swift b/apple/TableProTests/Views/DetailSurfaceThemeTests.swift
index bcfaca56a6..d7d0110b7e 100644
--- a/apple/TableProTests/Views/DetailSurfaceThemeTests.swift
+++ b/apple/TableProTests/Views/DetailSurfaceThemeTests.swift
@@ -23,7 +23,7 @@ struct DetailSurfaceThemeTests {
         .gridBackground: ThemeTestFixture.gridHex,
     ]
 
-    /// Under the default pair the surface draws `native`; under its own slot it draws the theme; under every other slot it still draws `native`.
+    // Native under the default pair and under other slots; the theme only under its own slot.
     private func assertSurface(_ view: some View, at point: CGPoint, slot: ThemeSlot, native: NSColor) throws {
         let hex = try #require(Self.slotColors[slot])
         let others = Self.slotColors.filter { $0.key != slot }
@@ -84,7 +84,7 @@ struct DetailSurfaceThemeTests {
         #expect(controller.loadState == .loaded)
         #expect(controller.tableRows.rows.isEmpty)
 
-        let view = DataFileContentView(controller: controller, gridDelegate: DataFileGridDelegate(controller: controller))
+        let view = DataFileContentView(controller: controller)
             .frame(width: Self.size.width, height: Self.size.height)
         try assertSurface(view, at: CGPoint(x: 0.03, y: 0.05), slot: .gridBackground, native: .textBackgroundColor)
     }
diff --git a/apple/TableProTests/Views/ERDiagram/ERDiagramThemeTests.swift b/apple/TableProTests/Views/ERDiagram/ERDiagramThemeTests.swift
index baddf3ebcf..da4945ac10 100644
--- a/apple/TableProTests/Views/ERDiagram/ERDiagramThemeTests.swift
+++ b/apple/TableProTests/Views/ERDiagram/ERDiagramThemeTests.swift
@@ -1,19 +1,9 @@
-//
-//  ERDiagramThemeTests.swift
-//  TableProTests
-//
-//  Tables on the ER canvas take the data grid's slots and the canvas takes the window background,
-//  while the default pair draws exactly the system colors the diagram drew before themes reached it.
-//  An export renders what the canvas shows.
-//
-
 import AppKit
 @testable import TablePro
 import TableProTheme
 import Testing
 
-/// A bitmap cache converts through its own color space, so a theme color is held to the same color
-/// drawn by a plain fill into the same kind of cache.
+// A bitmap cache converts through its own color space, so a theme color is held to a plain fill in the same cache.
 @MainActor
 private final class ThemeFillView: NSView {
     let color: NSColor
@@ -39,11 +29,8 @@ struct ERDiagramThemeTests {
     private static let themed: [ThemeSlot: String] = [
         .windowBackdrop: "#1E2030",
         .gridBackground: "#2A6F4E",
-        .gridHeaderBackground: "#7A3B8F",
-        .gridHeaderText: "#F8F8F2",
         .gridText: "#E0E0E0",
         .gridLine: "#6272A4",
-        .gridFocusBorder: "#FF79C6",
     ]
 
     private func appearance(_ name: NSAppearance.Name) throws -> NSAppearance {
@@ -82,19 +69,17 @@ struct ERDiagramThemeTests {
 
             #expect(palette.backdrop == Fixture.baked(.controlBackgroundColor, in: appearance))
             #expect(palette.nodeFill == Fixture.baked(.controlBackgroundColor, in: appearance))
-            #expect(palette.headerFill == nil)
             #expect(palette.headerWash(cluster: nil) == mainAccentWash(in: appearance))
             #expect(palette.headerWash(cluster: .systemGreen) == mainClusterWash(.systemGreen, in: appearance))
             #expect(palette.rule == Fixture.baked(.tertiaryLabelColor, in: appearance))
             #expect(palette.selectionRule == Fixture.baked(.controlAccentColor, in: appearance))
             #expect(palette.edge == mainEdge(in: appearance))
             #expect(palette.text == .labelColor)
-            #expect(palette.headerText == .labelColor)
             #expect(palette.secondaryText == .secondaryLabelColor)
         }
     }
 
-    @Test("A theme colors the tables from the grid's slots and keeps meaning hues and connectors system")
+    @Test("A theme colors the tables from the grid's slots and keeps the header wash, selection, meaning hues and connectors system")
     func themeColorsTablesFromGridSlots() throws {
         try Fixture.preservingEngine {
             try Fixture.adopt(Self.themed, appearance: .light)
@@ -103,11 +88,10 @@ struct ERDiagramThemeTests {
 
             #expect(Fixture.hex(palette.backdrop) == "#1E2030")
             #expect(Fixture.hex(palette.nodeFill) == "#2A6F4E")
-            #expect(Fixture.hex(palette.headerFill) == "#7A3B8F")
+            #expect(palette.headerWash(cluster: nil) == mainAccentWash(in: appearance))
             #expect(Fixture.hex(palette.rule) == "#6272A4")
-            #expect(Fixture.hex(palette.selectionRule) == "#FF79C6")
+            #expect(palette.selectionRule == Fixture.baked(.controlAccentColor, in: appearance))
             #expect(HexColor.string(from: palette.text) == "#E0E0E0")
-            #expect(HexColor.string(from: palette.headerText) == "#F8F8F2")
             #expect(palette.secondaryText == .secondaryLabelColor)
             #expect(palette.edge == mainEdge(in: appearance))
             #expect(palette.headerWash(cluster: .systemGreen) == mainClusterWash(.systemGreen, in: appearance))
@@ -130,24 +114,12 @@ struct ERDiagramThemeTests {
             ))
 
             #expect(Fixture.hex(palette.nodeFill) == "#2A6F4E")
-            #expect(palette.headerFill == nil)
             #expect(palette.headerWash(cluster: nil) == mainAccentWash(in: appearance))
             #expect(Fixture.matches(body, try reference(palette.nodeFill)))
             #expect(!Fixture.matches(header, try reference(palette.nodeFill)))
         }
     }
 
-    @Test("A header the theme sets apart from the body fills with its own color")
-    func distinctHeaderFillsItsOwnColor() throws {
-        try Fixture.preservingEngine {
-            try Fixture.adopt([.gridBackground: "#2A6F4E", .gridHeaderBackground: "#2A6F4E"], appearance: .light)
-            #expect(ERDiagramPalette(appearance: try appearance(.aqua)).headerFill == nil)
-
-            try Fixture.adopt([.gridHeaderBackground: "#7A3B8F"], appearance: .light)
-            #expect(Fixture.hex(ERDiagramPalette(appearance: try appearance(.aqua)).headerFill) == "#7A3B8F")
-        }
-    }
-
     @Test("A canvas bakes the theme of its own appearance, not the active one")
     func paletteFollowsTheCanvasAppearance() throws {
         try Fixture.preservingEngine {
@@ -267,17 +239,16 @@ struct ERDiagramThemeTests {
 
             #expect(Fixture.matches(backdrop, try reference(palette.backdrop)))
             #expect(Fixture.matches(body, try reference(palette.nodeFill)))
+            #expect(!Fixture.matches(header, try reference(palette.nodeFill)))
             if themed {
                 #expect(Fixture.hex(palette.backdrop) == "#1E2030")
-                #expect(Fixture.matches(header, try reference(try #require(palette.headerFill))))
             } else {
                 #expect(palette.backdrop == Fixture.baked(.controlBackgroundColor, in: appearance))
-                #expect(!Fixture.matches(header, try reference(palette.nodeFill)))
             }
         }
     }
 
-    /// Filled into the same kind of bitmap the export draws into, so the conversion cancels out.
+    // Filled into the same kind of bitmap the export draws into, so the conversion cancels out.
     private func reference(_ color: CGColor) throws -> NSColor {
         let rep = try #require(NSBitmapImageRep(
             bitmapDataPlanes: nil,
diff --git a/apple/TableProTests/Views/Main/CatalogChangeWindowTests.swift b/apple/TableProTests/Views/Main/CatalogChangeWindowTests.swift
index e8bc27ad9d..b6d9c1d808 100644
--- a/apple/TableProTests/Views/Main/CatalogChangeWindowTests.swift
+++ b/apple/TableProTests/Views/Main/CatalogChangeWindowTests.swift
@@ -513,6 +513,29 @@ struct CatalogChangeWindowTests {
         #expect(Self.totalRowCount(of: selected.id, in: tabManager) == nil)
     }
 
+    @Test("a change put off while a cell editor was open reloads the tab once the editor closes, even with nothing typed")
+    func deferredChangeReloadsOnceTheEditorCloses() async throws {
+        let connection = TestFixtures.makeConnection(database: "shop")
+        defer { DatabaseManager.shared.removeSession(for: connection.id) }
+        let (coordinator, tabManager) = makeCoordinator(connection: connection)
+        let selected = Self.loadedTab("users", rowCount: 3, totalRowCount: 42, in: coordinator)
+        tabManager.tabs = [selected]
+        tabManager.selectedTabId = selected.id
+        let model = coordinator.gridModel(forTab: selected.id)
+        let mount = DataTabGridMountStub()
+        mount.isEditing = true
+        model.attach(mount)
+
+        coordinator.applyObjectChange(Self.change(connection, name: "users", database: "shop", schema: nil, kind: .rows))
+        #expect(Self.totalRowCount(of: selected.id, in: tabManager) == 42)
+
+        model.discardEditing()
+        model.editingDidEnd()
+
+        try await Self.waitForReload(of: selected.id, in: tabManager)
+        #expect(Self.totalRowCount(of: selected.id, in: tabManager) == nil)
+    }
+
     /// Waits for a reload the change manager's cleared edits start on a later turn. A timeout
     /// returns too, so the case's own expectation reports it.
     private static func waitForReload(of tabId: UUID, in tabManager: QueryTabManager) async throws {
diff --git a/apple/TableProTests/Views/Main/CellFilterApplyTests.swift b/apple/TableProTests/Views/Main/CellFilterApplyTests.swift
index 3f298e07d8..b36520ba59 100644
--- a/apple/TableProTests/Views/Main/CellFilterApplyTests.swift
+++ b/apple/TableProTests/Views/Main/CellFilterApplyTests.swift
@@ -5,19 +5,11 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class CellFilterLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// The cell menu's Filter item, from the menu the data tab's delegate builds to the query it runs.
+// The cell menu's Filter item, from the items the data tab's adapter contributes to the query it runs.
 @MainActor
 struct CellFilterApplyTests {
     private let rows = TableRows.from(
@@ -26,12 +18,24 @@ struct CellFilterApplyTests {
         columnTypes: [.integer(rawType: "INT"), .text(rawType: "VARCHAR(20)")]
     )
 
+    @MainActor
     private struct Harness {
         let coordinator: MainContentCoordinator
         let tabManager: QueryTabManager
-        let grid: TableViewCoordinator
-        let delegate: DataTabGridDelegate
         let tabId: UUID
+
+        func cellMenuItems(row: Int, dataColumn: Int) -> [NSMenuItem] {
+            let model = coordinator.gridModel(forTab: tabId)
+            guard let adapter = coordinator.dataGridEntries[tabId]?.adapter,
+                  let rowID = model.rowID(at: row),
+                  let position = model.columns.displayPosition(ofDataIndex: dataColumn),
+                  let column = model.columns.column(at: position) else { return [] }
+            return adapter.gridCellMenuItems(for: rowID, column: column)
+        }
+
+        func filterMenuItem(row: Int, dataColumn: Int) -> NSMenuItem? {
+            cellMenuItems(row: row, dataColumn: dataColumn).first { $0.title == String(localized: "Filter") }
+        }
     }
 
     private func makeHarness(tabType: TabType = .table, changeManager: DataChangeManager = DataChangeManager()) -> Harness {
@@ -53,25 +57,7 @@ struct CellFilterApplyTests {
         tabManager.tabs.append(tab)
         tabManager.selectedTabId = tab.id
         coordinator.setActiveTableRows(rows, for: tab.id)
-
-        let grid = TableViewCoordinator(
-            changeManager: AnyChangeManager(changeManager),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: CellFilterLayoutPersister()
-        )
-        let tableRows = rows
-        grid.tableRowsProvider = { tableRows }
-        grid.rebuildColumnMetadataCache(from: tableRows)
-        grid.updateCache()
-        grid.visualIndex.rebuild(from: grid.changeManager)
-
-        let delegate = DataTabGridDelegate()
-        delegate.coordinator = coordinator
-        delegate.dataGridAttach(tableViewCoordinator: grid)
-        coordinator.dataTabDelegate = delegate
-        return Harness(coordinator: coordinator, tabManager: tabManager, grid: grid, delegate: delegate, tabId: tab.id)
+        return Harness(coordinator: coordinator, tabManager: tabManager, tabId: tab.id)
     }
 
     private func editedStatusOfFirstRow() -> DataChangeManager {
@@ -109,7 +95,7 @@ struct CellFilterApplyTests {
         let harness = makeHarness()
         defer { harness.coordinator.teardown() }
 
-        let item = try #require(harness.delegate.dataGridFilterMenuItem(forRow: 1, dataColumn: 1))
+        let item = try #require(harness.filterMenuItem(row: 1, dataColumn: 1))
 
         #expect(item.submenu?.items.map(\.title) == ["status = “open”", "status != “open”"])
     }
@@ -121,7 +107,7 @@ struct CellFilterApplyTests {
             clearSavedFilters(harness)
             harness.coordinator.teardown()
         }
-        let item = try #require(harness.delegate.dataGridFilterMenuItem(forRow: 0, dataColumn: 1))
+        let item = try #require(harness.filterMenuItem(row: 0, dataColumn: 1))
 
         item.submenu?.performActionForItem(at: 0)
 
@@ -141,9 +127,9 @@ struct CellFilterApplyTests {
             harness.coordinator.teardown()
         }
 
-        try #require(harness.delegate.dataGridFilterMenuItem(forRow: 0, dataColumn: 1))
+        try #require(harness.filterMenuItem(row: 0, dataColumn: 1))
             .submenu?.performActionForItem(at: 1)
-        try #require(harness.delegate.dataGridFilterMenuItem(forRow: 1, dataColumn: 0))
+        try #require(harness.filterMenuItem(row: 1, dataColumn: 0))
             .submenu?.performActionForItem(at: 2)
 
         let state = try #require(harness.tabManager.tabs.first { $0.id == harness.tabId }?.filterState)
@@ -153,14 +139,13 @@ struct CellFilterApplyTests {
         #expect(state.filterLogicMode == .and)
     }
 
-    /// The declined branch is reached by pretending an alert is already up, which is what
-    /// `confirmDiscardChangesIfNeeded` answers false to once there are edits to lose.
+    // Pretends an alert is already up, which `confirmDiscardChangesIfNeeded` answers false to once there are edits.
     @Test("Nothing changes while the discard alert is unanswered")
     func declinedDiscardChangesNothing() throws {
         let harness = makeHarness(changeManager: editedStatusOfFirstRow())
         defer { harness.coordinator.teardown() }
         #expect(harness.coordinator.changeManager.hasChanges)
-        let item = try #require(harness.delegate.dataGridFilterMenuItem(forRow: 1, dataColumn: 1))
+        let item = try #require(harness.filterMenuItem(row: 1, dataColumn: 1))
         let before = try #require(harness.tabManager.tabs.first { $0.id == harness.tabId })
         harness.coordinator.isShowingConfirmAlert = true
 
@@ -176,7 +161,7 @@ struct CellFilterApplyTests {
         let harness = makeHarness(tabType: .query)
         defer { harness.coordinator.teardown() }
 
-        #expect(harness.delegate.dataGridFilterMenuItem(forRow: 0, dataColumn: 1) == nil)
+        #expect(harness.filterMenuItem(row: 0, dataColumn: 1) == nil)
     }
 
     @Test("An edited cell has no Filter item, because the server does not hold its value")
@@ -184,28 +169,20 @@ struct CellFilterApplyTests {
         let harness = makeHarness(changeManager: editedStatusOfFirstRow())
         defer { harness.coordinator.teardown() }
 
-        #expect(harness.delegate.dataGridFilterMenuItem(forRow: 0, dataColumn: 1) == nil)
-        #expect(harness.delegate.dataGridFilterMenuItem(forRow: 0, dataColumn: 0) != nil)
-        #expect(harness.delegate.dataGridFilterMenuItem(forRow: 1, dataColumn: 1) != nil)
+        #expect(harness.filterMenuItem(row: 0, dataColumn: 1) == nil)
+        #expect(harness.filterMenuItem(row: 0, dataColumn: 0) != nil)
+        #expect(harness.filterMenuItem(row: 1, dataColumn: 1) != nil)
     }
 
-    @Test("The Filter item sits just before Highlight in the cell menu")
-    func rowMenuPlacesFilterBeforeHighlight() throws {
+    @Test("The Filter item sits just before Highlight in the cell items the adapter adds")
+    func filterComesBeforeHighlight() throws {
         let harness = makeHarness()
         defer { harness.coordinator.teardown() }
-        harness.grid.delegate = harness.delegate
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = harness.grid
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        harness.grid.tableView = tableView
-        let rowView = DataGridRowView()
-        rowView.coordinator = harness.grid
-        rowView.rowIndex = 0
-
-        let titles = try #require(rowView.contextMenu(target: .cell(dataColumn: 1))).items.map(\.title)
-
-        let filterIndex = try #require(titles.firstIndex(of: "Filter"))
+
+        let titles = harness.cellMenuItems(row: 0, dataColumn: 1).map(\.title)
+
+        let filterIndex = try #require(titles.firstIndex(of: String(localized: "Filter")))
         #expect(titles.indices.contains(filterIndex + 1))
-        #expect(titles[filterIndex + 1] == "Highlight")
+        #expect(titles.dropFirst(filterIndex + 1).first == String(localized: "Highlight"))
     }
 }
diff --git a/apple/TableProTests/Views/Main/CommandActionsBulkCloseTests.swift b/apple/TableProTests/Views/Main/CommandActionsBulkCloseTests.swift
index b296fbf147..313f4300ca 100644
--- a/apple/TableProTests/Views/Main/CommandActionsBulkCloseTests.swift
+++ b/apple/TableProTests/Views/Main/CommandActionsBulkCloseTests.swift
@@ -29,7 +29,6 @@ struct CommandActionsBulkCloseTests {
         let actions = MainContentCommandActions(
             coordinator: coordinator,
             connection: connection,
-            selectionState: coordinator.selectionState,
             selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
             pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
             pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
@@ -67,9 +66,7 @@ struct CommandActionsBulkCloseTests {
 
     // MARK: - Database scope
 
-    /// A connection keeps one tab list now, so the scope of a database-scoped close is that list.
-    /// These used to spread a connection's tabs over sibling windows and check that the command
-    /// reached across them, which is a shape the app can no longer be in.
+    // A connection keeps one tab list, which is the whole scope of a database-scoped close.
     @Test("a tab on another database is offered for closing")
     func canCloseTabsForOtherDatabasesWhenATabIsForeign() {
         let connection = TestFixtures.makeConnection(database: "db_a")
@@ -95,8 +92,7 @@ struct CommandActionsBulkCloseTests {
         #expect(!current.actions.canCloseTabsForOtherDatabases)
     }
 
-    /// Another connection's tabs are out of scope by construction rather than by a filter: they
-    /// live in that connection's own tab list, which this command never reads.
+    // Out of scope by construction, not a filter: they live in that connection's own tab list, which this command never reads.
     @Test("another connection's tabs are never a database-scoped target")
     func otherConnectionsAreOutOfScope() {
         let connection = TestFixtures.makeConnection(database: "db_a")
@@ -117,9 +113,7 @@ struct CommandActionsBulkCloseTests {
 
     // MARK: - Schema scope
 
-    /// Only `.table` tabs are given a schema, so on a schema-switching engine every query tab
-    /// named no container. Comparing that nil against the browsed name made all of them foreign,
-    /// and the command closed the user's whole editor with no prompt.
+    // Only `.table` tabs get a schema; comparing a query tab's nil to the browsed name closed the whole editor with no prompt.
     @Test("query tabs are never foreign on a schema-switching engine")
     func queryTabsAreNotForeignOnASchemaSwitchingEngine() {
         let connection = TestFixtures.makeConnection(database: "ORCL", type: .oracle)
@@ -151,8 +145,7 @@ struct CommandActionsBulkCloseTests {
         #expect(current.actions.canCloseTabsForOtherDatabases)
     }
 
-    /// A tab opened without a database is bound to the entry it was opened in, so it is in this
-    /// database rather than in another one.
+    // A tab opened without a database is bound to the entry it was opened in.
     @Test("a tab with no database of its own is not foreign")
     func tabWithoutADatabaseIsNotForeign() {
         let connection = TestFixtures.makeConnection(database: "db_a")
@@ -164,8 +157,7 @@ struct CommandActionsBulkCloseTests {
         #expect(!current.actions.canCloseTabsForOtherDatabases)
     }
 
-    /// Every tab names its entry and keeps it listed, so an untouched scratch tab behind another
-    /// entry is one of the tabs the command closes. Leaving it kept the other entry in the strip.
+    // Every tab keeps its entry listed, so leaving an untouched scratch tab kept the other entry in the strip.
     @Test("an empty scratch tab on another database is closed too")
     func emptyScratchTabOnAnotherDatabaseIsForeign() {
         let connection = TestFixtures.makeConnection(database: "db_a")
@@ -178,7 +170,7 @@ struct CommandActionsBulkCloseTests {
         #expect(current.actions.canCloseTabsForOtherDatabases)
     }
 
-    /// The strip lists one entry, and a close never takes tabs the user cannot see.
+    // The strip lists one entry, and a close never takes tabs the user cannot see.
     @Test("close all and close others act on the entry on screen")
     func closeAllAndOthersStayInTheShownEntry() async {
         let connection = TestFixtures.makeConnection(database: "db_a")
@@ -197,8 +189,7 @@ struct CommandActionsBulkCloseTests {
         #expect(manager.tabs.map(\.tableContext.databaseName) == ["db_b"])
     }
 
-    /// The enablement flag and the close itself read the same victim list, so this drives the real
-    /// command and checks what survives rather than trusting the boolean.
+    // Enablement and the close share one victim list, so this drives the real command and checks what survives.
     @Test("closing for other schemas keeps the query tabs and closes the foreign table tab")
     func closingForOtherSchemasKeepsQueryTabs() async throws {
         let connection = TestFixtures.makeConnection(database: "ORCL", type: .oracle)
@@ -222,8 +213,7 @@ struct CommandActionsBulkCloseTests {
 
     // MARK: - Container wording
 
-    /// Both titles were computed and then never used: the menu items carry hardcoded literals and
-    /// `applyDynamicTitle` had no case for either selector.
+    // Both titles were computed and never used: the items had hardcoded literals and `applyDynamicTitle` had no case for them.
     @Test("container commands are worded for the dimension the engine switches")
     func containerCommandTitlesFollowTheSwitchTarget() {
         let schemaEngine = makeWindow(connection: TestFixtures.makeConnection(database: "ORCL", type: .oracle))
@@ -241,10 +231,7 @@ struct CommandActionsBulkCloseTests {
 
     // MARK: - What a save can reach
 
-    /// The alert and the save read one classifier. A batch close saves what it can reach and leaves
-    /// the rest open, so "is there work" and "can Save have it" have to be the same switch: Save
-    /// used to run on the selected tab whatever the victims were, which on Close Other Tabs and
-    /// Close Tabs for Other Databases is never one of them.
+    // Alert and save share one classifier: Save used to run on the selected tab, which a batch close never targets.
     @Test("a background tab's file is saveable, its grid edits are not")
     func savabilitySeparatesFileWorkFromGridWork() throws {
         let connection = TestFixtures.makeConnection(database: "db_a")
@@ -267,9 +254,7 @@ struct CommandActionsBulkCloseTests {
         #expect(current.coordinator.savability(of: dirtyFile) == .saveable)
     }
 
-    /// A tab can hold more than one kind at once: a query opened from a file, edited, with unsaved
-    /// cell edits in its result. Answering "saveable" for the file would let a close write the file
-    /// and destroy the grid edits beside it, which is the loss the category exists to prevent.
+    // Calling a file-plus-grid-edits tab saveable would let a close write the file and destroy the grid edits beside it.
     @Test("grid edits outrank a dirty file on a background tab")
     func savabilityPrefersTheKindNoSaveCanReach() throws {
         let connection = TestFixtures.makeConnection(database: "db_a")
@@ -304,8 +289,6 @@ struct CommandActionsBulkCloseTests {
         #expect(current.coordinator.savability(of: selected) == .nothingAtRisk)
     }
 
-    /// Nothing at risk means no prompt and every victim closes, which is the path a batch close
-    /// takes almost every time.
     @Test("a clean batch closes without asking")
     func cleanBatchNeedsNoPrompt() async {
         let connection = TestFixtures.makeConnection(database: "db_a")
diff --git a/apple/TableProTests/Views/Main/CommandActionsCloseSelectionTests.swift b/apple/TableProTests/Views/Main/CommandActionsCloseSelectionTests.swift
index 414a8c2946..3cba063947 100644
--- a/apple/TableProTests/Views/Main/CommandActionsCloseSelectionTests.swift
+++ b/apple/TableProTests/Views/Main/CommandActionsCloseSelectionTests.swift
@@ -2,9 +2,6 @@
 //  CommandActionsCloseSelectionTests.swift
 //  TableProTests
 //
-//  Closing a tab that holds unsaved work selects it first so the save question has something to
-//  point at. Whatever the answer, the selection then goes back to the tab the user was working in.
-//
 
 import AppKit
 import Foundation
@@ -33,7 +30,6 @@ struct CommandActionsCloseSelectionTests {
         let actions = MainContentCommandActions(
             coordinator: coordinator,
             connection: connection,
-            selectionState: coordinator.selectionState,
             selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
             pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
             pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
@@ -51,8 +47,7 @@ struct CommandActionsCloseSelectionTests {
         return Harness(actions: actions, coordinator: coordinator, window: window)
     }
 
-    /// Three query tabs, the middle one holding a `.sql` file emptied since it was saved. Empty, so
-    /// no close here files an entry in the Recently Closed Tabs history of whoever runs the suite.
+    // Emptied, so no close here files an entry in the runner's Recently Closed Tabs history.
     private func openTabs(in harness: Harness) throws -> (first: UUID, dirty: UUID, last: UUID) {
         let manager = harness.coordinator.tabManager
         for title in ["First", "Dirty", "Last"] {
@@ -69,8 +64,6 @@ struct CommandActionsCloseSelectionTests {
         return (first, manager.tabs[dirtyIndex].id, last)
     }
 
-    /// The reported case: the background tab closed after Don't Save, and the window showed its
-    /// neighbour instead of the tab the user had in front.
     @Test("Don't Save on a background tab leaves the tab the user was on in front")
     func dontSaveKeepsTheTabInFront() async throws {
         let harness = makeHarness()
@@ -99,8 +92,7 @@ struct CommandActionsCloseSelectionTests {
         #expect(harness.coordinator.tabManager.selectedTabId == tabs.first)
     }
 
-    /// A save can wait on the server after the prompt with the strip still live. Whatever the user
-    /// picked in that time is newer than the tab the close set aside.
+    // A save can wait on the server with the strip still live.
     @Test("A tab picked while the close was pending stays in front after the close")
     func aTabPickedMeanwhileStaysInFront() async throws {
         let harness = makeHarness()
diff --git a/apple/TableProTests/Views/Main/CommandActionsDispatchTests.swift b/apple/TableProTests/Views/Main/CommandActionsDispatchTests.swift
index 32cb8c7f4e..ccc647cc31 100644
--- a/apple/TableProTests/Views/Main/CommandActionsDispatchTests.swift
+++ b/apple/TableProTests/Views/Main/CommandActionsDispatchTests.swift
@@ -8,13 +8,6 @@ import SwiftUI
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class CommandActionsLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
@@ -35,7 +28,6 @@ extension GlobalStateSuites {
             let actions = MainContentCommandActions(
                 coordinator: coordinator,
                 connection: connection,
-                selectionState: coordinator.selectionState,
                 selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
                 pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
                 pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
@@ -51,8 +43,7 @@ extension GlobalStateSuites {
 
         // MARK: - Query text
 
-        /// The Query menu used to test the text for emptiness while the editor bar trimmed it, so
-        /// Run and Explain Query stayed enabled over an editor holding only whitespace.
+        // The menu tested the text for emptiness while the editor bar trimmed it, so Run stayed lit over whitespace.
         @Test("An editor holding only whitespace or invisible characters has no query text for the menu")
         func blankEditorHasNoQueryText() {
             let (actions, coordinator) = makeSUT()
@@ -110,10 +101,7 @@ extension GlobalStateSuites {
 
             actions.insertQueryFromAI("SELECT 2")
 
-            /// Left alone. Appending was removed on purpose in #1257, and `aiInsertReusesSelectedQueryTab`
-            /// is true only for a query tab that is empty, so generated SQL takes over a blank tab and
-            /// otherwise opens its own. A tab the user has typed into is never rewritten, which is the
-            /// property worth holding; this case asserted the concatenation that fix removed.
+            // Appending went in #1257: generated SQL takes over only an empty query tab and otherwise opens its own.
             #expect(coordinator.tabManager.selectedTab?.content.query == "SELECT 1")
         }
 
@@ -218,9 +206,7 @@ extension GlobalStateSuites {
 
         // MARK: - saveChanges (createTable tab)
 
-        /// A Create Table tab is answered by `createTableActions` and nothing else. The structure arm
-        /// sits below it and would otherwise try to apply the staged edits of whatever session the tab
-        /// id happens to carry.
+        // The structure arm below would otherwise apply the staged edits of whatever session the tab id carries.
         @Test("saveChanges dispatches createTableActions when the selected tab is createTable")
         func saveChanges_createTableTab_callsCreateTableAction() {
             let (actions, coordinator) = makeSUT()
@@ -280,53 +266,45 @@ extension GlobalStateSuites {
             coordinator.setActiveTableRows(tableRows, for: tabId)
         }
 
-        private func attachGridWithRangeSelection(
-            to coordinator: MainContentCoordinator
-        ) -> (DataTabGridDelegate, TableViewCoordinator) {
-            let delegate = DataTabGridDelegate()
-            let tableViewCoordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: true,
-                selectedRowIndices: .constant([]),
-                delegate: delegate,
-                layoutPersister: CommandActionsLayoutPersister()
-            )
-            tableViewCoordinator.selectionController.update(
+        private func selectRange(in coordinator: MainContentCoordinator) throws -> DataGridModel {
+            let tabId = try #require(coordinator.tabManager.selectedTabId)
+            let model = coordinator.gridModel(forTab: tabId)
+            model.setSelection(
                 .single(
                     GridRect(rows: 0...1, columns: 0...0),
                     anchor: GridCoord(row: 0, displayColumn: 0),
                     active: GridCoord(row: 1, displayColumn: 0)
                 )
             )
-            delegate.dataGridAttach(tableViewCoordinator: tableViewCoordinator)
-            coordinator.dataTabDelegate = delegate
-            return (delegate, tableViewCoordinator)
+            return model
         }
 
-        @Test("copySelectedRowsAsJson honors the grid range selection")
+        @Test("copySelectedRowsAsJson honors the model's range selection")
         func copySelectedRowsAsJson_usesRangeSelection() throws {
             let clipboard = try #require(RecordingClipboard.current)
 
             let (actions, coordinator) = makeSUT()
             coordinator.tabManager.addTab(databaseName: "testdb")
             seedRows(coordinator)
-            let attached = attachGridWithRangeSelection(to: coordinator)
+            _ = try selectRange(in: coordinator)
 
             actions.copySelectedRowsAsJson()
 
             #expect(clipboard.text?.contains("Alice") == true)
             #expect(clipboard.text?.contains("Bob") == true)
-            withExtendedLifetime(attached) {}
         }
 
-        @Test("copySelectedRowsAsJson falls back to the row selection without a grid")
-        func copySelectedRowsAsJson_fallsBackWithoutGrid() throws {
+        @Test("copySelectedRowsAsJson reads the model's row selection with no grid mounted")
+        func copySelectedRowsAsJson_readsTheModelWithoutAGrid() throws {
             let clipboard = try #require(RecordingClipboard.current)
 
             let (actions, coordinator) = makeSUT()
             coordinator.tabManager.addTab(databaseName: "testdb")
             seedRows(coordinator)
-            coordinator.selectionState.indices = [0]
+            let tabId = try #require(coordinator.tabManager.selectedTabId)
+            let model = coordinator.gridModel(forTab: tabId)
+            model.selectRows([.existing(0)])
+            #expect(!model.isMounted)
 
             actions.copySelectedRowsAsJson()
 
@@ -334,15 +312,81 @@ extension GlobalStateSuites {
             #expect(clipboard.text?.contains("Bob") != true)
         }
 
-        @Test("hasRowSelection reflects a grid range selection")
-        func hasRowSelection_reflectsRangeSelection() {
+        @Test("Copy Rows in Data mode copies the rows the model selected")
+        func copySelectedRows_dataMode_readsTheModel() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+
+            let (actions, coordinator) = makeSUT()
+            coordinator.tabManager.addTab(databaseName: "testdb")
+            seedRows(coordinator)
+            let tabId = try #require(coordinator.tabManager.selectedTabId)
+            coordinator.gridModel(forTab: tabId).selectRows([.existing(1)])
+
+            actions.copySelectedRows()
+
+            #expect(clipboard.writes.last == "2\tBob")
+        }
+
+        @Test(
+            "Copy with the grid not focused writes the selected rows in the row copy format",
+            .appSettings { $0.dataGrid.rowCopyFormat = .csvWithHeaders }
+        )
+        func copyInCopyFormat_unfocusedGrid_usesTheFormat() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+
             let (actions, coordinator) = makeSUT()
             coordinator.tabManager.addTab(databaseName: "testdb")
             seedRows(coordinator)
-            let attached = attachGridWithRangeSelection(to: coordinator)
+            let tabId = try #require(coordinator.tabManager.selectedTabId)
+            coordinator.gridModel(forTab: tabId).selectCell(GridCoord(row: 1, displayColumn: 1))
+
+            actions.copySelectedRowsInCopyFormat()
+
+            #expect(clipboard.writes.last == "id,name\n2,Bob\n")
+        }
+
+        @Test("hasRowSelection reflects the model's range selection")
+        func hasRowSelection_reflectsRangeSelection() throws {
+            let (actions, coordinator) = makeSUT()
+            coordinator.tabManager.addTab(databaseName: "testdb")
+            seedRows(coordinator)
+            #expect(!actions.hasRowSelection)
+
+            _ = try selectRange(in: coordinator)
 
             #expect(actions.hasRowSelection)
-            withExtendedLifetime(attached) {}
+            #expect(actions.hasDataGridRowSelection)
+        }
+
+        // MARK: - Use Selection for Find
+
+        // The menu lit the item over a query result's selection while the window sent it to the editor.
+        @Test("Use Selection for Find over a query result's selection goes to its grid unless the editor has a selection")
+        func useSelectionForFind_queryResult_reachesTheGrid() throws {
+            let (actions, coordinator) = makeSUT()
+            coordinator.tabManager.addTab(databaseName: "testdb")
+            seedRows(coordinator)
+            let tabId = try #require(coordinator.tabManager.selectedTabId)
+            #expect(coordinator.tabManager.selectedTab?.tabType == .query)
+            let model = coordinator.gridModel(forTab: tabId)
+            let mounted = DataTabGridMountStub()
+            model.attach(mounted)
+            defer { model.detach(mounted) }
+            model.selectCell(GridCoord(row: 1, displayColumn: 1))
+
+            var context = MenuValidationContext()
+            context.isConnected = true
+            context.canUseGridFindCommands = actions.canUseGridFindCommands
+            context.hasDataGridRowSelection = actions.hasDataGridRowSelection
+            #expect(context.usesGridSelectionForFind)
+            #expect(MainSplitViewController.isEnabled(#selector(MainSplitViewController.useSelectionForFind(_:)), context: context))
+            context.hasSelectionForFind = true
+            #expect(!context.usesGridSelectionForFind)
+
+            actions.useGridSelectionForFind()
+
+            #expect(model.find.term == "Bob")
+            #expect(model.find.isVisible)
         }
     }
 }
diff --git a/apple/TableProTests/Views/Main/CommandActionsFocusGateTests.swift b/apple/TableProTests/Views/Main/CommandActionsFocusGateTests.swift
index cc75669e48..3f519226a6 100644
--- a/apple/TableProTests/Views/Main/CommandActionsFocusGateTests.swift
+++ b/apple/TableProTests/Views/Main/CommandActionsFocusGateTests.swift
@@ -27,7 +27,6 @@ struct CommandActionsFocusGateTests {
         return MainContentCommandActions(
             coordinator: coordinator,
             connection: connection,
-            selectionState: coordinator.selectionState,
             selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
             pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
             pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
@@ -136,8 +135,7 @@ struct CommandActionsFocusGateTests {
         return MenuEquivalent(characters: resolved.characters, modifiers: resolved.modifiers)
     }
 
-    /// The restore assertions only mean something when the defaults actually bind these
-    /// actions, which a runner without a keyboard layout could break silently.
+    // The restore assertions mean something only while the defaults bind these actions.
     private func expectSyncedActionsAreBound(_ keyboard: KeyboardSettings) {
         #expect(bound(.delete, keyboard) != MenuEquivalent.cleared)
         #expect(bound(.truncateTable, keyboard) != MenuEquivalent.cleared)
diff --git a/apple/TableProTests/Views/Main/CoordinatorColumnVisibilityTests.swift b/apple/TableProTests/Views/Main/CoordinatorColumnVisibilityTests.swift
index 8cd01a0272..a8cc2d0b5c 100644
--- a/apple/TableProTests/Views/Main/CoordinatorColumnVisibilityTests.swift
+++ b/apple/TableProTests/Views/Main/CoordinatorColumnVisibilityTests.swift
@@ -5,7 +5,6 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 import TableProPluginKit
 import Testing
 
@@ -60,13 +59,8 @@ struct CoordinatorColumnVisibilityTests {
         )
     }
 
-    /// Hiding or showing a column re-runs the table's query with a different column list, so the
-    /// rows are replaced and an unsaved edit goes with them. Sort, pagination and the WHERE filter
-    /// all confirm first; this reload used to do it without asking.
-    ///
-    /// The declined branch is reached by pretending an alert is already up, which is what
-    /// `confirmDiscardChangesIfNeeded` answers false to. That keeps the test off the real modal,
-    /// which would hang it.
+    // Hiding a column re-queries, so an unsaved edit would go with the rows. The declined branch pretends an alert
+    // is already up, which `confirmDiscardChangesIfNeeded` answers false to, keeping the test off the real modal.
     @Test("hiding a column changes nothing while the discard is unanswered")
     func hidingWaitsForTheDiscardAnswer() throws {
         let (coordinator, tabManager) = makeCoordinator()
@@ -108,7 +102,7 @@ struct CoordinatorColumnVisibilityTests {
         #expect(tab.columnLayout.hiddenColumns == ["name"])
     }
 
-    /// With nothing staged the gate answers immediately, so the common case takes no round trip.
+    // With nothing staged the gate answers at once.
     @Test("hiding a column with no unsaved edits applies straight away")
     func hidingWithNoEditsAppliesImmediately() throws {
         let (coordinator, tabManager) = makeCoordinator()
@@ -155,83 +149,61 @@ struct CoordinatorColumnVisibilityTests {
         #expect(FileColumnLayoutPersister.shared.loadHiddenColumns(for: key) == ["email"])
     }
 
-    @Test("Applying column geometry after hiding columns keeps the hidden set and syncs the session")
-    func applyColumnGeometryPreservesHiddenColumns() {
+    private func usersKey(_ coordinator: MainContentCoordinator, _ tab: QueryTab, table: String = "users") -> ColumnLayoutTableKey {
+        ColumnLayoutTableKey(
+            connectionId: coordinator.connectionId,
+            databaseName: tab.tableContext.databaseName,
+            schemaName: tab.tableContext.schemaName,
+            tableName: table
+        )
+    }
+
+    @Test("A grid geometry change after hiding columns keeps the hidden set and reaches the tab")
+    func gridGeometryPreservesHiddenColumns() throws {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addTableTab(to: tabManager, tableName: "users")
+        let key = usersKey(coordinator, try #require(tabManager.selectedTab))
+        defer {
+            coordinator.releaseGridModel(forTab: tabId, persistingLayout: false)
+            FileColumnLayoutPersister.shared.clear(for: key)
+        }
         coordinator.hideColumn("email")
 
-        var geometry = ColumnLayoutState()
-        geometry.columnWidths = ["id": 80, "name": 220]
-        geometry.columnOrder = ["id", "name"]
-        coordinator.applyColumnGeometry(from: geometry, toTabId: tabId)
+        coordinator.gridModel(forTab: tabId).columnGeometryDidChange(widths: ["id": 80, "name": 220], order: ["id", "name"])
 
-        guard let index = tabManager.tabs.firstIndex(where: { $0.id == tabId }) else {
-            Issue.record("Expected tab to exist")
-            return
-        }
-        let layout = tabManager.tabs[index].columnLayout
+        let layout = try #require(tabManager.tabs.first { $0.id == tabId }).columnLayout
         #expect(layout.hiddenColumns == ["email"])
         #expect(layout.columnWidths == ["id": 80, "name": 220])
         #expect(layout.columnOrder == ["id", "name"])
     }
 
-    @Test("Clearing layout after a schema reorder clears every geometry owner")
+    @Test("Clearing layout after a schema reorder clears the tab, the store and a pending write")
     func clearColumnLayoutForSelectedTableClearsEveryGeometryOwner() throws {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addTableTab(to: tabManager, tableName: "users")
-        guard let tabIndex = tabManager.tabs.firstIndex(where: { $0.id == tabId }) else {
-            Issue.record("Expected table tab")
-            return
-        }
+        let tabIndex = try #require(tabManager.tabs.firstIndex(where: { $0.id == tabId }))
         tabManager.mutate(at: tabIndex) { tab in
             tab.columnLayout.columnWidths = ["name": 180]
             tab.columnLayout.columnContentWidths = ["name": 160]
             tab.columnLayout.columnOrder = ["name", "id"]
             tab.columnLayout.hiddenColumns = ["email"]
         }
-
-        let key = ColumnLayoutTableKey(
-            connectionId: coordinator.connectionId,
-            databaseName: tabManager.tabs[tabIndex].tableContext.databaseName,
-            schemaName: tabManager.tabs[tabIndex].tableContext.schemaName,
-            tableName: "users"
-        )
+        let key = usersKey(coordinator, tabManager.tabs[tabIndex])
         FileColumnLayoutPersister.shared.save(tabManager.tabs[tabIndex].columnLayout, for: key)
         FileColumnLayoutPersister.shared.saveHiddenColumns(["email"], for: key)
-        defer { FileColumnLayoutPersister.shared.clear(for: key) }
-
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FileColumnLayoutPersister.shared
+        defer {
+            coordinator.releaseGridModel(forTab: tabId, persistingLayout: false)
+            FileColumnLayoutPersister.shared.clear(for: key)
+        }
+        coordinator.setActiveTableRows(
+            TableRows.from(queryRows: [[.text("Ada")]], columns: ["name"], columnTypes: [.text(rawType: "TEXT")]),
+            for: tabId
         )
-        gridCoordinator.connectionId = coordinator.connectionId
-        gridCoordinator.databaseName = ""
-        gridCoordinator.tableName = "users"
-        gridCoordinator.tabType = .table
-        gridCoordinator.tableRowsProvider = { rows }
-        gridCoordinator.rebuildColumnMetadataCache(from: rows)
-        let tableView = NSTableView()
-        gridCoordinator.tableView = tableView
-        let column = NSTableColumn(identifier: try #require(gridCoordinator.columnIdentifier(for: 0)))
-        column.width = 180
-        tableView.addTableColumn(column)
-        #expect(gridCoordinator.markColumnWidthUserSized(column))
-        gridCoordinator.scheduleLayoutPersist()
-
-        let gridDelegate = DataTabGridDelegate()
-        gridDelegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = gridDelegate
+        let model = coordinator.gridModel(forTab: tabId)
+        model.columnGeometryDidChange(widths: ["name": 200], order: nil)
 
         coordinator.clearColumnLayoutForSelectedTable()
+        coordinator.flushColumnLayoutPersistence()
 
         let layout = tabManager.tabs[tabIndex].columnLayout
         #expect(layout.columnWidths.isEmpty)
@@ -240,9 +212,8 @@ struct CoordinatorColumnVisibilityTests {
         #expect(layout.hiddenColumns == ["email"])
         #expect(FileColumnLayoutPersister.shared.load(for: key) == nil)
         #expect(FileColumnLayoutPersister.shared.loadHiddenColumns(for: key) == ["email"])
-        #expect(gridCoordinator.userSizedColumnNames.isEmpty)
-        #expect(gridCoordinator.shouldRecalculateAutomaticColumnWidths)
-        #expect(gridCoordinator.pendingColumnLayoutPersistence == nil)
+        #expect(model.store.columnLayout.columnWidths.isEmpty)
+        #expect(model.store.columnLayout.columnContentWidths == nil)
     }
 
     @Test("A delayed schema reorder clears only its captured table layout")
@@ -263,21 +234,12 @@ struct CoordinatorColumnVisibilityTests {
             tab.columnLayout.columnOrder = ["id", "name"]
         }
 
-        let sourceKey = ColumnLayoutTableKey(
-            connectionId: coordinator.connectionId,
-            databaseName: "",
-            schemaName: nil,
-            tableName: "users"
-        )
-        let destinationKey = ColumnLayoutTableKey(
-            connectionId: coordinator.connectionId,
-            databaseName: "",
-            schemaName: nil,
-            tableName: "orders"
-        )
+        let sourceKey = usersKey(coordinator, tabManager.tabs[sourceIndex])
+        let destinationKey = usersKey(coordinator, tabManager.tabs[destinationIndex], table: "orders")
         FileColumnLayoutPersister.shared.save(tabManager.tabs[sourceIndex].columnLayout, for: sourceKey)
         FileColumnLayoutPersister.shared.save(tabManager.tabs[destinationIndex].columnLayout, for: destinationKey)
         defer {
+            coordinator.releaseGridModel(forTab: destinationTabId, persistingLayout: false)
             FileColumnLayoutPersister.shared.clear(for: sourceKey)
             FileColumnLayoutPersister.shared.clear(for: destinationKey)
         }
@@ -285,35 +247,12 @@ struct CoordinatorColumnVisibilityTests {
         tabManager.selectedTabId = sourceTabId
         let target = try #require(coordinator.selectedColumnLayoutClearTarget())
         tabManager.selectedTabId = destinationTabId
-
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FileColumnLayoutPersister.shared
+        coordinator.setActiveTableRows(
+            TableRows.from(queryRows: [[.text("Ada")]], columns: ["name"], columnTypes: [.text(rawType: "TEXT")]),
+            for: destinationTabId
         )
-        gridCoordinator.connectionId = coordinator.connectionId
-        gridCoordinator.databaseName = ""
-        gridCoordinator.tableName = "orders"
-        gridCoordinator.tabType = .table
-        gridCoordinator.tableRowsProvider = { rows }
-        gridCoordinator.rebuildColumnMetadataCache(from: rows)
-        let tableView = NSTableView()
-        gridCoordinator.tableView = tableView
-        let column = NSTableColumn(identifier: try #require(gridCoordinator.columnIdentifier(for: 0)))
-        column.width = 240
-        tableView.addTableColumn(column)
-        #expect(gridCoordinator.markColumnWidthUserSized(column))
-
-        let gridDelegate = DataTabGridDelegate()
-        gridDelegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = gridDelegate
+        let destinationModel = coordinator.gridModel(forTab: destinationTabId)
+        #expect(destinationModel.store.columnLayout.columnWidths == ["name": 240])
 
         coordinator.clearColumnLayout(target)
 
@@ -327,54 +266,73 @@ struct CoordinatorColumnVisibilityTests {
         #expect(destinationLayout.columnOrder == ["id", "name"])
         #expect(FileColumnLayoutPersister.shared.load(for: sourceKey) == nil)
         #expect(FileColumnLayoutPersister.shared.load(for: destinationKey)?.columnWidths == ["name": 240])
-        #expect(gridCoordinator.userSizedColumnNames == ["name"])
-        #expect(!gridCoordinator.shouldRecalculateAutomaticColumnWidths)
+        #expect(destinationModel.store.columnLayout.columnWidths == ["name": 240])
     }
 
-    @Test("clearing a table's layout unfreezes its mounted grid, whose tab never recorded the freeze")
-    func clearingTheLayoutUnfreezesTheMountedGrid() throws {
+    // The freeze lives in the table's stored layout, which the tab's own copy never records.
+    @Test("clearing a table's layout unfreezes its grid model")
+    func clearingTheLayoutUnfreezesTheModel() throws {
         let (coordinator, tabManager) = makeCoordinator()
-        _ = addTableTab(to: tabManager, tableName: "orders")
+        let tabId = addTableTab(to: tabManager, tableName: "orders")
         let target = try #require(coordinator.selectedColumnLayoutClearTarget())
         var stored = ColumnLayoutState()
         stored.columnOrder = ["id", "name"]
         stored.frozenColumnCount = 2
         FileColumnLayoutPersister.shared.save(stored, for: target.tableKey)
-        defer { FileColumnLayoutPersister.shared.clear(for: target.tableKey) }
-
-        let rows = TableRows.from(
-            queryRows: [[.text("1"), .text("Ada")]],
-            columns: ["id", "name"],
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
-        )
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FileColumnLayoutPersister.shared
+        defer {
+            coordinator.releaseGridModel(forTab: tabId, persistingLayout: false)
+            FileColumnLayoutPersister.shared.clear(for: target.tableKey)
+        }
+        coordinator.setActiveTableRows(
+            TableRows.from(
+                queryRows: [[.text("1"), .text("Ada")]],
+                columns: ["id", "name"],
+                columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
+            ),
+            for: tabId
         )
-        gridCoordinator.connectionId = coordinator.connectionId
-        gridCoordinator.databaseName = ""
-        gridCoordinator.tableName = "orders"
-        gridCoordinator.tabType = .table
-        gridCoordinator.tableRowsProvider = { rows }
-        gridCoordinator.rebuildColumnMetadataCache(from: rows)
-        gridCoordinator.tableView = NSTableView()
-        gridCoordinator.frozenColumnCount = 2
-        #expect(gridCoordinator.columnLayoutKey == target.tableKey)
+        let model = coordinator.gridModel(forTab: tabId)
+        #expect(model.columns.frozenCount == 2)
         #expect(tabManager.selectedTab?.columnLayout.frozenColumnCount == 0)
 
-        let gridDelegate = DataTabGridDelegate()
-        gridDelegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = gridDelegate
-
         coordinator.clearColumnLayout(target)
 
-        #expect(gridCoordinator.frozenColumnCount == 0)
+        #expect(model.columns.frozenCount == 0)
         #expect(FileColumnLayoutPersister.shared.load(for: target.tableKey) == nil)
     }
 
+    // A query tab's requery reloads nothing, so only the model can bring the hidden columns back to its grid.
+    @Test("Reset Columns on a query tab shows the hidden columns in its grid and keeps Show All Columns working")
+    func resetOnAQueryTabShowsHiddenColumnsInTheGrid() throws {
+        let (coordinator, tabManager) = makeCoordinator()
+        let tab = QueryTab(title: "Query 1", query: "SELECT 1", tabType: .query)
+        tabManager.tabs.append(tab)
+        tabManager.selectedTabId = tab.id
+        defer { coordinator.releaseGridModel(forTab: tab.id, persistingLayout: false) }
+        coordinator.setActiveTableRows(
+            TableRows.from(
+                queryRows: [[.text("1"), .text("Ada"), .text("ada@example.com")]],
+                columns: ["id", "name", "email"],
+                columnTypes: Array(repeating: .text(rawType: "TEXT"), count: 3)
+            ),
+            for: tab.id
+        )
+        let model = coordinator.gridModel(forTab: tab.id)
+        coordinator.hideColumn("email")
+        #expect(model.columns.orderedNames == ["id", "name"])
+
+        coordinator.resetColumns()
+
+        #expect(model.columns.orderedNames == ["id", "name", "email"])
+        let layout = try #require(tabManager.selectedTab).columnLayout
+        #expect(layout == ColumnLayoutState())
+
+        coordinator.hideColumn("name")
+        coordinator.showAllColumns()
+
+        #expect(model.columns.orderedNames == ["id", "name", "email"])
+    }
+
     @Test("showColumn removes from the active tab's hidden set")
     func showColumn() {
         let (coordinator, tabManager) = makeCoordinator()
diff --git a/apple/TableProTests/Views/Main/DataTabGridEditCommitTests.swift b/apple/TableProTests/Views/Main/DataTabGridEditCommitTests.swift
new file mode 100644
index 0000000000..f37e88ffb6
--- /dev/null
+++ b/apple/TableProTests/Views/Main/DataTabGridEditCommitTests.swift
@@ -0,0 +1,300 @@
+//
+//  DataTabGridEditCommitTests.swift
+//  TableProTests
+//
+//  An open cell editor holds an edit nothing has recorded yet. Everything that repoints or replaces
+//  what the edit was made against commits it first, into the tab it was made in (H2).
+//
+
+import Foundation
+import SwiftUI
+import TableProPluginKit
+import TableProTestSupport
+import Testing
+
+@testable import TablePro
+
+@MainActor
+struct DataTabGridEditCommitTests {
+    private let fixtures = CoordinatorFixtures()
+
+    private static let rows = TableRows.from(
+        queryRows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
+        columns: ["id", "name"],
+        columnTypes: [.text(rawType: nil), .text(rawType: nil)],
+        hasAuthoritativeSchema: true
+    )
+
+    @discardableResult
+    private func addTableTab(_ coordinator: MainContentCoordinator, name: String) -> UUID {
+        var tab = QueryTab(title: name, query: "SELECT * FROM \(name)", tabType: .table, tableName: name)
+        tab.execution.lastExecutedAt = Date()
+        tab.display.resultsViewMode = .data
+        coordinator.tabManager.tabs.append(tab)
+        coordinator.setActiveTableRows(Self.rows, for: tab.id)
+        return tab.id
+    }
+
+    // The change manager holds the selected tab's edits.
+    private func select(_ tabId: UUID, in coordinator: MainContentCoordinator) {
+        coordinator.tabManager.selectedTabId = tabId
+        let name = coordinator.tabManager.tabs.first { $0.id == tabId }?.tableContext.tableName ?? ""
+        coordinator.changeManager.configureForTable(
+            tableName: name,
+            columns: ["id", "name"],
+            primaryKeyColumns: ["id"],
+            databaseType: .mysql,
+            generatedColumns: []
+        )
+    }
+
+    private func nameEdit(_ model: DataGridModel, _ text: String) throws -> DataGridCellEdit {
+        let position = try #require(model.columns.displayPosition(ofDataIndex: 1))
+        let column = try #require(model.columns.column(at: position))
+        return DataGridCellEdit(rowID: .existing(1), columnID: column.id, value: .value(.text(text), isExpression: false))
+    }
+
+    // A mounted grid with an editor open on Bob's name; committing it hands `text` to the model.
+    private func openEditor(
+        _ coordinator: MainContentCoordinator,
+        tabId: UUID,
+        text: String
+    ) throws -> (DataGridModel, DataTabGridMountStub) {
+        let model = coordinator.gridModel(forTab: tabId)
+        model.configuration.isEditable = true
+        let edit = try nameEdit(model, text)
+        let mount = DataTabGridMountStub()
+        mount.isEditing = true
+        mount.onCommit = { [weak model] in
+            _ = model?.commit([edit], actionName: "Edit")
+        }
+        model.attach(mount)
+        return (model, mount)
+    }
+
+    private func name(_ coordinator: MainContentCoordinator, tabId: UUID) -> PluginCellValue? {
+        coordinator.tabSessionRegistry.tableRows(for: tabId).row(withID: .existing(1))?.values[1]
+    }
+
+    private func makeActions(_ coordinator: MainContentCoordinator) -> MainContentCommandActions {
+        var selectedTables: Set<DatabaseTreeTableRef> = []
+        var pendingTruncates: Set<DatabaseTreeTableRef> = []
+        var pendingDeletes: Set<DatabaseTreeTableRef> = []
+        var tableOperationOptions: [DatabaseTreeTableRef: TableOperationOptions] = [:]
+        return MainContentCommandActions(
+            coordinator: coordinator,
+            connection: coordinator.connection,
+            selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
+            pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
+            pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
+            tableOperationOptions: Binding(get: { tableOperationOptions }, set: { tableOperationOptions = $0 }),
+            trailingPaneState: TrailingPaneState()
+        )
+    }
+
+    // MARK: - Tab switch
+
+    @Test("a tab switch commits the open edit into the tab it was made in")
+    func tabSwitchCommitsIntoTheOutgoingTab() throws {
+        let coordinator = fixtures.make().coordinator
+        let outgoing = addTableTab(coordinator, name: "users")
+        let incoming = addTableTab(coordinator, name: "orders")
+        select(outgoing, in: coordinator)
+        let (_, mount) = try openEditor(coordinator, tabId: outgoing, text: "Zed")
+
+        coordinator.tabManager.selectedTabId = incoming
+        coordinator.handleTabChange(from: outgoing, to: incoming, tabs: coordinator.tabManager.tabs)
+
+        #expect(mount.commitCount == 1)
+        #expect(coordinator.tabManager.tabs.first { $0.id == outgoing }?.pendingChanges.hasChanges == true)
+        #expect(name(coordinator, tabId: outgoing) == .text("Zed"))
+        #expect(name(coordinator, tabId: incoming) == .text("Bob"))
+        #expect(!coordinator.changeManager.hasChanges)
+    }
+
+    @Test("a commit from the selected tab's grid is recorded and written to its rows")
+    func selectedTabCommitIsAccepted() throws {
+        let coordinator = fixtures.make().coordinator
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        let model = coordinator.gridModel(forTab: tabId)
+        model.configuration.isEditable = true
+
+        let committed = model.commit([try nameEdit(model, "Zed")], actionName: "Edit")
+
+        #expect(committed)
+        #expect(coordinator.changeManager.isCellModified(rowID: .existing(1), columnIndex: 1))
+        #expect(name(coordinator, tabId: tabId) == .text("Zed"))
+    }
+
+    @Test("the adapter refuses a commit for a tab that no longer holds the change manager")
+    func commitForAnotherTabIsRefused() throws {
+        let coordinator = fixtures.make().coordinator
+        let outgoing = addTableTab(coordinator, name: "users")
+        let incoming = addTableTab(coordinator, name: "orders")
+        select(outgoing, in: coordinator)
+        let model = coordinator.gridModel(forTab: outgoing)
+        model.configuration.isEditable = true
+        coordinator.tabManager.selectedTabId = incoming
+        coordinator.handleTabChange(from: outgoing, to: incoming, tabs: coordinator.tabManager.tabs)
+
+        let committed = model.commit([try nameEdit(model, "Zed")], actionName: "Edit")
+
+        #expect(!committed)
+        #expect(!coordinator.changeManager.hasChanges)
+        #expect(name(coordinator, tabId: outgoing) == .text("Bob"))
+        #expect(name(coordinator, tabId: incoming) == .text("Bob"))
+    }
+
+    // MARK: - Save, close, refresh and mode switch
+
+    @Test("A refresh keeps the place the mounted grid is scrolled to, not one it saved earlier")
+    func refreshKeepsTheScrolledPlace() throws {
+        let state = SessionStateFactory.create(connection: TestFixtures.makeConnection(), payload: nil)
+        let coordinator = state.coordinator
+        defer { coordinator.teardown() }
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        let model = coordinator.gridModel(forTab: tabId)
+        let mount = DataTabGridMountStub()
+        mount.sample = (row: 1, offset: 4)
+        model.attach(mount)
+
+        let snapshot = withExtendedLifetime(mount) {
+            coordinator.viewportSnapshot(forTab: tabId, intent: .keepPlace, keyColumns: ["id"])
+        }
+
+        #expect(snapshot.firstVisiblePosition == 1)
+        #expect(snapshot.firstVisibleOffset == 4)
+    }
+
+    @Test("Save is offered while the first edit is still open in the grid")
+    func saveIsOfferedForAnOpenEdit() throws {
+        let state = SessionStateFactory.create(connection: TestFixtures.makeConnection(), payload: nil)
+        let coordinator = state.coordinator
+        defer { coordinator.teardown() }
+        let actions = makeActions(coordinator)
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        #expect(!actions.hasOpenGridEdit)
+
+        // The model holds its mounted view weakly, so the test holds it.
+        let (_, mount) = try openEditor(coordinator, tabId: tabId, text: "Zed")
+
+        withExtendedLifetime(mount) {
+            #expect(!actions.hasPendingChanges)
+            #expect(actions.hasOpenGridEdit)
+        }
+    }
+
+    // A gate that refuses the save fails it with its reason, which shows the save ran with the edit the editor held.
+    @Test("Save commits the open edit before it looks for changes")
+    func saveCommitsTheOpenEditFirst() async throws {
+        let state = SessionStateFactory.create(connection: TestFixtures.makeConnection(), payload: nil)
+        let coordinator = state.coordinator
+        defer { coordinator.teardown() }
+        coordinator.executionGate = AlwaysDenyGate(reason: "Refused by the test")
+        let actions = makeActions(coordinator)
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        let (_, mount) = try openEditor(coordinator, tabId: tabId, text: "Zed")
+
+        actions.saveChanges()
+
+        #expect(mount.commitCount == 1)
+        #expect(coordinator.changeManager.isCellModified(rowID: .existing(1), columnIndex: 1))
+        try await waitUntil(timeout: .seconds(5)) {
+            coordinator.tabManager.selectedTab?.execution.errorMessage == "Refused by the test"
+        }
+    }
+
+    @Test("Closing a tab commits the open edit, so the save question covers it")
+    func closeCommitsTheOpenEditFirst() async throws {
+        let state = SessionStateFactory.create(connection: TestFixtures.makeConnection(), payload: nil)
+        let coordinator = state.coordinator
+        defer { coordinator.teardown() }
+        let actions = makeActions(coordinator)
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        let (_, mount) = try openEditor(coordinator, tabId: tabId, text: "Zed")
+        var prompts = 0
+        actions.confirmSaveChanges = { _, _ in
+            prompts += 1
+            return .cancel
+        }
+
+        await actions.closeTabAwaiting(id: tabId)
+
+        #expect(mount.commitCount == 1)
+        #expect(prompts == 1)
+        #expect(coordinator.tabManager.tabs.contains { $0.id == tabId })
+        #expect(coordinator.changeManager.hasChanges)
+    }
+
+    // The alert stands answered "no", so a refresh that saw the edit refuses instead of running.
+    @Test("Refresh commits the open edit before it decides whether there is work to lose")
+    func refreshCommitsTheOpenEditFirst() throws {
+        let coordinator = fixtures.make().coordinator
+        defer { coordinator.cancelAllQueryTasks() }
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        let (_, mount) = try openEditor(coordinator, tabId: tabId, text: "Zed")
+        coordinator.isShowingConfirmAlert = true
+
+        coordinator.handleRefresh(hasPendingTableOps: false, onDiscard: {})
+
+        #expect(mount.commitCount == 1)
+        #expect(coordinator.changeManager.hasChanges)
+        #expect(!coordinator.queryTasks.hasTask(for: tabId))
+        #expect(name(coordinator, tabId: tabId) == .text("Zed"))
+    }
+
+    @Test("Switching the result view commits the open edit first")
+    func resultViewSwitchCommitsTheOpenEditFirst() throws {
+        let state = SessionStateFactory.create(connection: TestFixtures.makeConnection(), payload: nil)
+        let coordinator = state.coordinator
+        defer { coordinator.teardown() }
+        let actions = makeActions(coordinator)
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        let (_, mount) = try openEditor(coordinator, tabId: tabId, text: "Zed")
+
+        actions.setResultsViewMode(.json)
+
+        #expect(mount.commitCount == 1)
+        #expect(coordinator.changeManager.isCellModified(rowID: .existing(1), columnIndex: 1))
+        #expect(coordinator.tabManager.selectedTab?.display.resultsViewMode == .json)
+    }
+
+    // MARK: - Model lifetime
+
+    @Test("closing a tab releases its model and discards an editor still open in it")
+    func closingATabReleasesItsModel() throws {
+        let coordinator = fixtures.make().coordinator
+        let tabId = addTableTab(coordinator, name: "users")
+        select(tabId, in: coordinator)
+        let mount = DataTabGridMountStub()
+        coordinator.gridModel(forTab: tabId).attach(mount)
+        defer { RecentlyClosedTabStore.shared.removeEntries(for: coordinator.connectionId) }
+
+        coordinator.closeTabsByUser(ids: [tabId])
+
+        #expect(coordinator.existingGridModel(forTab: tabId) == nil)
+        #expect(mount.discardCount > 0)
+    }
+
+    @Test("teardown releases every tab's model")
+    func teardownReleasesEveryModel() {
+        let coordinator = fixtures.make().coordinator
+        let first = addTableTab(coordinator, name: "users")
+        let second = addTableTab(coordinator, name: "orders")
+        select(first, in: coordinator)
+        _ = coordinator.gridModel(forTab: first)
+        _ = coordinator.gridModel(forTab: second)
+
+        coordinator.teardown()
+
+        #expect(coordinator.existingGridModel(forTab: first) == nil)
+        #expect(coordinator.existingGridModel(forTab: second) == nil)
+    }
+}
diff --git a/apple/TableProTests/Views/Main/DataTabGridMountStub.swift b/apple/TableProTests/Views/Main/DataTabGridMountStub.swift
new file mode 100644
index 0000000000..14cd971406
--- /dev/null
+++ b/apple/TableProTests/Views/Main/DataTabGridMountStub.swift
@@ -0,0 +1,51 @@
+//
+//  DataTabGridMountStub.swift
+//  TableProTests
+//
+
+import AppKit
+
+@testable import TablePro
+
+// Stands in for a grid on screen: the coordinator asks a model whether it is mounted, and an open
+// cell editor commits through the mounted view.
+@MainActor
+final class DataTabGridMountStub: DataGridMountedView {
+    var isEditing = false
+    // The first visible row and its offset, as a scrolled grid reports them.
+    var sample: (row: Int, offset: CGFloat)?
+    private(set) var changes: [DataGridChange] = []
+    private(set) var commitCount = 0
+    private(set) var discardCount = 0
+    // Runs when an open editor commits, the way the field editor hands its text to the model.
+    var onCommit: (@MainActor () -> Void)?
+
+    func apply(_ change: DataGridChange) {
+        changes.append(change)
+    }
+    func selectionDidChange() {}
+    func configurationDidChange() {}
+    func reveal(row: Int, displayColumn: Int?) {}
+    func revealColumn(_ displayColumn: Int) {}
+    func sortDidChange() {}
+    func summaryRulesDidChange() {}
+    func viewportSample() -> (row: Int, offset: CGFloat)? { sample }
+    func beginEditing(row: Int, displayColumn: Int) -> Bool { false }
+
+    func commitEditing() -> Bool {
+        commitCount += 1
+        if isEditing {
+            isEditing = false
+            onCommit?()
+        }
+        return true
+    }
+
+    func discardEditing() {
+        discardCount += 1
+        isEditing = false
+    }
+
+    func focus() -> Bool { false }
+    func anchor(forColumn displayColumn: Int) -> (view: NSView, rect: NSRect)? { nil }
+}
diff --git a/apple/TableProTests/Views/Main/DocumentEditingAvailabilityTests.swift b/apple/TableProTests/Views/Main/DocumentEditingAvailabilityTests.swift
index b3724e0a37..934f1592a1 100644
--- a/apple/TableProTests/Views/Main/DocumentEditingAvailabilityTests.swift
+++ b/apple/TableProTests/Views/Main/DocumentEditingAvailabilityTests.swift
@@ -55,15 +55,15 @@ struct DocumentEditingAvailabilityTests {
     func offeredOnALocatedRow() {
         let coordinator = makeCoordinator()
         #expect(coordinator.documentEditingAvailable)
-        #expect(coordinator.canEditDocument(atDisplayRow: 0))
-        #expect(coordinator.documentLocator(forDisplayRow: 1) == #"{"$numberInt":"2"}"#)
+        #expect(coordinator.canEditDocument(rowID: .existing(0)))
+        #expect(coordinator.documentLocator(for: .existing(1)) == #"{"$numberInt":"2"}"#)
     }
 
     @Test("A row with no locator, or no row at all, is not offered")
     func notOfferedWithoutALocator() {
         let coordinator = makeCoordinator()
-        #expect(!coordinator.canEditDocument(atDisplayRow: 2))
-        #expect(!coordinator.canEditDocument(atDisplayRow: 9))
+        #expect(!coordinator.canEditDocument(rowID: .existing(2)))
+        #expect(!coordinator.canEditDocument(rowID: .existing(9)))
     }
 
     @Test("A value filter resolves the shown row to its own document, not the one at that storage index")
@@ -72,17 +72,20 @@ struct DocumentEditingAvailabilityTests {
         let tabId = try #require(coordinator.tabManager.selectedTab?.id)
         var filter = GridValueFilterState()
         filter.set(ColumnValueFilter(selectedValues: ["Bob"], includesNull: false), columnName: "name", forColumn: 1)
-        coordinator.setValueFilter(filter, forTab: tabId)
+        let model = coordinator.gridModel(forTab: tabId)
+        model.setValueFilter(filter)
 
-        #expect(coordinator.documentLocator(forDisplayRow: 0) == #"{"$numberInt":"2"}"#)
-        #expect(coordinator.documentLocator(forDisplayRow: 1) == #"{"$numberInt":"4"}"#)
+        let shown = (0..<model.rowCount).compactMap { model.rowID(at: $0) }
+        let shownLocators = shown.map { coordinator.documentLocator(for: $0) }
+
+        #expect(shownLocators == [#"{"$numberInt":"2"}"#, #"{"$numberInt":"4"}"#])
     }
 
     @Test("A query tab never offers Edit Document, whatever its rows carry")
     func queryTabIsNotOffered() {
         let coordinator = makeCoordinator(tabType: .query)
         #expect(!coordinator.documentEditingAvailable)
-        #expect(!coordinator.canEditDocument(atDisplayRow: 0))
+        #expect(!coordinator.canEditDocument(rowID: .existing(0)))
     }
 
     @Test("Staged grid edits keep Edit Document away")
@@ -97,20 +100,20 @@ struct DocumentEditingAvailabilityTests {
             originalRow: [.text("2"), .text("Bob")]
         )
         #expect(coordinator.changeManager.hasChanges)
-        #expect(!coordinator.canEditDocument(atDisplayRow: 0))
+        #expect(!coordinator.canEditDocument(rowID: .existing(0)))
     }
 
     @Test("A read-only connection does not offer Edit Document")
     func readOnlyIsRefused() {
         let coordinator = makeCoordinator()
         coordinator.toolbarState.safeModeLevel = .readOnly
-        #expect(!coordinator.canEditDocument(atDisplayRow: 0))
+        #expect(!coordinator.canEditDocument(rowID: .existing(0)))
     }
 
     @Test("An engine that stores rows does not offer it")
     func rowEngineIsRefused() {
         let coordinator = makeCoordinator(type: .postgresql)
-        #expect(!coordinator.canEditDocument(atDisplayRow: 0))
+        #expect(!coordinator.canEditDocument(rowID: .existing(0)))
     }
 
     @Test("The sheet opens on the locator it was given, as an edit of that collection")
diff --git a/apple/TableProTests/Views/Main/GridReloadViewportTests.swift b/apple/TableProTests/Views/Main/GridReloadViewportTests.swift
index c8ccf5d2ac..7de3db2103 100644
--- a/apple/TableProTests/Views/Main/GridReloadViewportTests.swift
+++ b/apple/TableProTests/Views/Main/GridReloadViewportTests.swift
@@ -3,29 +3,24 @@
 //  TableProTests
 //
 
-import AppKit
 import Foundation
-import SwiftUI
 import TableProPluginKit
 import Testing
 
 @testable import TablePro
 
-@MainActor
-private final class NoopReloadLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 @MainActor
 struct GridReloadViewportTests {
+    @MainActor
     private struct Fixture {
         let coordinator: MainContentCoordinator
         let tabId: UUID
-        let delegate: DataTabGridDelegate
-        let grid: TableViewCoordinator
-        let tableView: NSTableView
+        let model: DataGridModel
+        let mount: DataTabGridMountStub
+
+        func takePlacement() -> GridViewportPlacement? {
+            coordinator.tabSessionRegistry.takeViewportPlacement(for: tabId)
+        }
     }
 
     private static func rows(ids: [Int]) -> TableRows {
@@ -51,22 +46,13 @@ struct GridReloadViewportTests {
         tabManager.tabs.append(tab)
         tabManager.selectedTabId = tab.id
 
-        let delegate = DataTabGridDelegate()
-        let tableView = NSTableView()
-        let grid = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopReloadLayoutPersister()
-        )
-        grid.tableView = tableView
-        delegate.dataGridAttach(tableViewCoordinator: grid)
-        coordinator.dataTabDelegate = delegate
+        let model = coordinator.gridModel(forTab: tab.id)
+        let mount = DataTabGridMountStub()
+        model.attach(mount)
 
         coordinator.setActiveTableRows(Self.rows(ids: Array(1 ... 10)), for: tab.id)
-        _ = coordinator.takeViewportPlacement(forTab: tab.id)
-        return Fixture(coordinator: coordinator, tabId: tab.id, delegate: delegate, grid: grid, tableView: tableView)
+        _ = coordinator.tabSessionRegistry.takeViewportPlacement(for: tab.id)
+        return Fixture(coordinator: coordinator, tabId: tab.id, model: model, mount: mount)
     }
 
     @Test("A table tab's grid on screen is handed its placement once")
@@ -76,19 +62,30 @@ struct GridReloadViewportTests {
 
         fixture.coordinator.setActiveTableRows(Self.rows(ids: Array(1 ... 10)), for: fixture.tabId)
 
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId) == .firstRow)
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId) == nil)
+        #expect(fixture.takePlacement() == .firstRow)
+        #expect(fixture.takePlacement() == nil)
         withExtendedLifetime(fixture) {}
     }
 
-    @Test("A grid that is not on screen is handed no placement")
+    @Test("A table tab whose model has no grid mounted is handed no placement")
+    func unmountedModelStagesNothing() {
+        let fixture = makeFixture()
+        defer { fixture.coordinator.teardown() }
+        fixture.model.detach(fixture.mount)
+
+        fixture.coordinator.setActiveTableRows(Self.rows(ids: Array(1 ... 10)), for: fixture.tabId)
+
+        #expect(fixture.takePlacement() == nil)
+    }
+
+    @Test("A grid outside Data mode is handed no placement")
     func unmountedGridStagesNothing() {
         let fixture = makeFixture(mode: .json)
         defer { fixture.coordinator.teardown() }
 
         fixture.coordinator.setActiveTableRows(Self.rows(ids: Array(0 ... 10)), for: fixture.tabId, viewport: .keepPlace)
 
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId) == nil)
+        #expect(fixture.takePlacement() == nil)
         withExtendedLifetime(fixture) {}
     }
 
@@ -99,7 +96,7 @@ struct GridReloadViewportTests {
 
         fixture.coordinator.setActiveTableRows(Self.rows(ids: Array(0 ... 10)), for: fixture.tabId, viewport: .firstRow)
 
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId) == nil)
+        #expect(fixture.takePlacement() == nil)
         withExtendedLifetime(fixture) {}
     }
 
@@ -111,7 +108,7 @@ struct GridReloadViewportTests {
 
         fixture.coordinator.tabSessionRegistry.setTableRows(Self.rows(ids: [42]), for: fixture.tabId)
 
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId) == nil)
+        #expect(fixture.takePlacement() == nil)
         withExtendedLifetime(fixture) {}
     }
 
@@ -128,7 +125,7 @@ struct GridReloadViewportTests {
 
         fixture.coordinator.applyResultSetSwitch(to: second.id, in: fixture.tabId)
 
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId) == nil)
+        #expect(fixture.takePlacement() == nil)
         withExtendedLifetime(fixture) {}
     }
 
@@ -136,7 +133,7 @@ struct GridReloadViewportTests {
     func sameSourceRestoresTheSelectionByKey() {
         let fixture = makeFixture()
         defer { fixture.coordinator.teardown() }
-        fixture.coordinator.selectionState.indices = [2, 5]
+        fixture.model.selectRows([.existing(2), .existing(5)])
 
         fixture.coordinator.setActiveTableRows(
             Self.rows(ids: Array((1 ... 10).reversed())),
@@ -145,7 +142,7 @@ struct GridReloadViewportTests {
             source: .sameSource
         )
 
-        let placement = fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId)
+        let placement = fixture.takePlacement()
         #expect(Set(placement?.selectedRows ?? []) == [.existing(7), .existing(4)])
         withExtendedLifetime(fixture) {}
     }
@@ -154,11 +151,11 @@ struct GridReloadViewportTests {
     func newSourceRestoresNoSelection() {
         let fixture = makeFixture()
         defer { fixture.coordinator.teardown() }
-        fixture.coordinator.selectionState.indices = [2]
+        fixture.model.selectRows([.existing(2)])
 
         fixture.coordinator.setActiveTableRows(Self.rows(ids: Array(1 ... 10)), for: fixture.tabId, viewport: .keepPlace)
 
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId)?.selectedRows.isEmpty == true)
+        #expect(fixture.takePlacement()?.selectedRows.isEmpty == true)
         withExtendedLifetime(fixture) {}
     }
 
@@ -166,7 +163,7 @@ struct GridReloadViewportTests {
     func queryTabRereadStagesTheSelection() {
         let fixture = makeFixture(tabType: .query)
         defer { fixture.coordinator.teardown() }
-        fixture.coordinator.selectionState.indices = [1]
+        fixture.model.selectRows([.existing(1)])
 
         fixture.coordinator.setActiveTableRows(
             Self.rows(ids: Array(1 ... 10)),
@@ -175,7 +172,7 @@ struct GridReloadViewportTests {
             source: .sameSource
         )
 
-        #expect(fixture.coordinator.takeViewportPlacement(forTab: fixture.tabId)?.selectedRows == [.existing(1)])
+        #expect(fixture.takePlacement()?.selectedRows == [.existing(1)])
         withExtendedLifetime(fixture) {}
     }
 }
diff --git a/apple/TableProTests/Views/Main/InspectorExpressionStagingTests.swift b/apple/TableProTests/Views/Main/InspectorExpressionStagingTests.swift
index 5f655076f7..29f5e79cce 100644
--- a/apple/TableProTests/Views/Main/InspectorExpressionStagingTests.swift
+++ b/apple/TableProTests/Views/Main/InspectorExpressionStagingTests.swift
@@ -52,13 +52,12 @@ struct InspectorExpressionStagingTests {
         coordinator.tabSessionRegistry.tableRows(for: tabId).rows[row].values[column]
     }
 
-    /// Wired the way `MainContentView.updateSidebarEditState` wires the inspector.
+    // Wired the way `MainContentView.updateSidebarEditState` wires the inspector.
     private func configuredEditState(_ tabId: UUID, rows rowIDs: [RowID]) -> MultiRowEditState {
         let tableRows = coordinator.tabSessionRegistry.tableRows(for: tabId)
         let selected = rowIDs.compactMap { tableRows.row(withID: $0) }
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: Set(selected.indices),
             rowIDs: selected.map(\.id),
             allRows: selected.map { $0.values.map(\.asText) },
             expressionCells: selected.map { changeManager.expressionColumns(forRow: $0.id) },
@@ -135,8 +134,7 @@ struct InspectorExpressionStagingTests {
         #expect(value(tabId, row: 0, column: 3) == .text("now()"))
     }
 
-    /// The grid staged `now()` on two rows. Typing over it in the inspector and clearing the field again used to
-    /// re-stage the configured text as a literal, which then saved as the string `'now()'`.
+    // Clearing the field after typing over a staged `now()` used to re-stage the text as the literal `'now()'`.
     @Test("Clearing an inspector edit over SQL the grid staged puts the SQL back")
     func revertRestoresTheExpression() {
         let tabId = makeTable()
@@ -195,8 +193,8 @@ struct InspectorExpressionStagingTests {
 
     @Test("An inspector-only save writes a picked function unquoted")
     func sidebarSaveWritesPickedFunction() throws {
-        _ = makeTable()
-        coordinator.selectionState.indices = [0]
+        let tabId = makeTable()
+        coordinator.gridModel(forTab: tabId).selectRows([.existing(0)])
 
         let statements = try coordinator.sidebarEditStatements(editedFields: [
             InspectorFieldEdit(columnIndex: 2, columnName: "created_at", newValue: "now()", isExpression: true)
@@ -209,8 +207,8 @@ struct InspectorExpressionStagingTests {
 
     @Test("An inspector-only save reads a typed function name as the function on a timestamp, as text elsewhere")
     func sidebarSavePromotesTypedText() throws {
-        _ = makeTable()
-        coordinator.selectionState.indices = [0]
+        let tabId = makeTable()
+        coordinator.gridModel(forTab: tabId).selectRows([.existing(0)])
 
         let timestamp = try #require(try coordinator.sidebarEditStatements(editedFields: [
             InspectorFieldEdit(columnIndex: 2, columnName: "created_at", newValue: "NOW()")
diff --git a/apple/TableProTests/Views/Main/InspectorFieldEditStagingTests.swift b/apple/TableProTests/Views/Main/InspectorFieldEditStagingTests.swift
index 20707e5759..fe2cf2db52 100644
--- a/apple/TableProTests/Views/Main/InspectorFieldEditStagingTests.swift
+++ b/apple/TableProTests/Views/Main/InspectorFieldEditStagingTests.swift
@@ -39,13 +39,11 @@ struct InspectorFieldEditStagingTests {
             stage(value, column: column, rows: rows, continuity: .typing)
         }
 
-        /// A real `MultiRowEditState` wired the way the inspector wires it, so a field edit takes
-        /// the same route from the editor's binding to the staged change.
+        // Wired the way the inspector wires it, so a field edit takes the same route to the staged change.
         func configuredEditState(rows: [RowID]) -> MultiRowEditState {
             let state = MultiRowEditState()
             let selected = rows.compactMap { tableRows.row(withID: $0) }
             state.configure(
-                selectedRowIndices: Set(selected.indices),
                 rowIDs: selected.map(\.id),
                 allRows: selected.map { $0.values.map(\.asText) },
                 columns: tableRows.columns,
@@ -122,8 +120,7 @@ struct InspectorFieldEditStagingTests {
         #expect(cellChange(fixture, rowID: .existing(1), column: 1)?.newValue == .text("Zed"))
     }
 
-    /// The inspector rebuilds its fields from the same buffer on the next selection change, so an
-    /// edit that never reached it came back showing the value before the edit (#2851).
+    // The inspector rebuilds its fields from the same buffer on the next selection change (#2851).
     @Test("reconfiguring the inspector from the edited row shows the edited value")
     func theInspectorRebuildsFromTheEditedRow() {
         let fixture = makeFixture()
@@ -132,7 +129,6 @@ struct InspectorFieldEditStagingTests {
         let editState = MultiRowEditState()
         let row = fixture.tableRows.rows[1]
         editState.configure(
-            selectedRowIndices: [1],
             rowIDs: [row.id],
             allRows: [row.values.map(\.asText)],
             columns: ["id", "name"],
@@ -153,8 +149,7 @@ struct InspectorFieldEditStagingTests {
         #expect(!fixture.coordinator.changeManager.hasChanges)
     }
 
-    /// Every row used to be recorded with one shared previous value taken from the inspector's
-    /// field, which is nil, and so NULL, whenever the selected rows disagree.
+    // One shared previous value from the inspector's field was nil, so NULL, whenever the rows disagreed.
     @Test("each row in a multi-row edit keeps its own previous value")
     func multiRowEditKeepsEachRowsPreviousValue() {
         let fixture = makeFixture()
@@ -181,8 +176,7 @@ struct InspectorFieldEditStagingTests {
         #expect(!fixture.coordinator.changeManager.hasChanges)
     }
 
-    /// `originalValue` is nil both for a stored NULL and for a selection whose rows disagree, and
-    /// sending that nil as one value wrote NULL into every selected row.
+    // `originalValue` is nil for a stored NULL and for rows that disagree; sent as one value it wrote NULL everywhere.
     @Test("clearing a field the selected rows disagree on puts each row's own value back")
     func clearingAMultiValueFieldRestoresEachRow() {
         let fixture = makeFixture()
@@ -240,8 +234,7 @@ struct InspectorFieldEditStagingTests {
         #expect(fixture.value(row: 1, column: 1) == .text("Bob"))
     }
 
-    /// Rows are named by identity, so an edit staged while a value filter is hiding rows cannot
-    /// land on whatever row sits at the same display position.
+    // Rows are named by identity, so an edit under a value filter cannot land on the row at the same position.
     @Test("a value filter does not move the edit to another row")
     func aValueFilterDoesNotMoveTheEdit() {
         let fixture = makeFixture()
@@ -251,8 +244,9 @@ struct InspectorFieldEditStagingTests {
             columnName: "name",
             forColumn: 1
         )
-        fixture.coordinator.setValueFilter(filter, forTab: fixture.tabId)
-        #expect(fixture.coordinator.activeGridDisplayIDs == [.existing(1), .existing(2)])
+        let model = fixture.coordinator.gridModel(forTab: fixture.tabId)
+        model.setValueFilter(filter)
+        #expect(model.displayedRowIDs == [.existing(1), .existing(2)])
 
         fixture.stage(.text("Zed"), rows: [.existing(2)])
 
@@ -260,8 +254,7 @@ struct InspectorFieldEditStagingTests {
         #expect(fixture.value(row: 1, column: 1) == .text("Bob"))
     }
 
-    /// A `TextField` bound to a string writes its binding per character, so a typed word reached
-    /// the undo stack one character at a time.
+    // A `TextField` writes its binding per character, so a typed word reached the undo stack a character at a time.
     @Test("a typed word is one undo step")
     func typingIsOneUndoStep() {
         let fixture = makeFixture()
@@ -316,8 +309,7 @@ struct InspectorFieldEditStagingTests {
         #expect(!undoManager.canUndo)
     }
 
-    /// A row that already held the typed text joins the run on the keystroke that first changes it,
-    /// with its own starting value.
+    // A row that already held the typed text joins the run on the keystroke that first changes it.
     @Test("a row that only changes later still comes back with the rest")
     func aLateJoiningRowIsRestored() {
         let fixture = makeFixture()
diff --git a/apple/TableProTests/Views/Main/MainContentCoordinatorAddRowTests.swift b/apple/TableProTests/Views/Main/MainContentCoordinatorAddRowTests.swift
index cd3ff2d2fb..a48b92dfed 100644
--- a/apple/TableProTests/Views/Main/MainContentCoordinatorAddRowTests.swift
+++ b/apple/TableProTests/Views/Main/MainContentCoordinatorAddRowTests.swift
@@ -43,9 +43,7 @@ struct MainContentCoordinatorAddRowTests {
         return coordinator
     }
 
-    /// `addNewRow()` resolves its target through `GridSelectionOwner`, which answers `.none` in
-    /// Chart mode and `.schemaGrid` in Structure mode. Offering the command outside Data mode makes
-    /// it either inert or a column insert wearing a row's name.
+    // Outside Data mode `GridSelectionOwner` answers `.none` or `.schemaGrid`, making Add Row inert or a column insert.
     @Test("Only the data grid takes a row")
     func addRowFollowsTheResultMode() {
         #expect(makeCoordinator(viewMode: .data).canAddRow)
@@ -61,8 +59,7 @@ struct MainContentCoordinatorAddRowTests {
         #expect(!makeCoordinator(isView: true).canAddRow)
     }
 
-    /// A new row is pre-filled from the schema's account of which columns the server fills in, so
-    /// offering the command before that account arrives stages NULL into an identity column.
+    // Offered before the schema arrives, a new row stages NULL into an identity column.
     @Test("A row waits for the schema that says which columns the server fills in")
     func addRowWaitsForTheAuthoritativeSchema() {
         #expect(!makeCoordinator(hasAuthoritativeSchema: false).canAddRow)
@@ -80,6 +77,33 @@ struct MainContentCoordinatorAddRowTests {
         #expect(!unresolved.canAddRow)
     }
 
+    // The grid's text editor refuses bytes, so the caret on a BLOB column would open nothing.
+    @Test("Add Row and Duplicate Row put the caret past a BLOB column, on the first one that takes text")
+    func newRowSkipsABlobColumn() throws {
+        let fixture = fixtures.make()
+        var tab = QueryTab(title: "files", query: "SELECT * FROM files", tabType: .table)
+        tab.tableContext.tableName = "files"
+        tab.tableContext.isEditable = true
+        tab.display.resultsViewMode = .data
+        fixture.addTab(tab, rows: TableRows.from(
+            queryRows: [[.bytes(Data([0x01, 0x02])), .text("a")]],
+            columns: ["payload", "name"],
+            columnTypes: [.blob(rawType: "BYTEA"), .text(rawType: "TEXT")],
+            hasAuthoritativeSchema: true
+        ))
+        let coordinator = fixture.coordinator
+        let model = coordinator.gridModel(forTab: tab.id)
+
+        coordinator.addNewRow()
+        let added = try #require(model.selection.activeCell)
+        #expect(model.columns.column(at: added.displayColumn)?.name == "name")
+
+        coordinator.duplicateRow(.existing(0))
+        let duplicated = try #require(model.selection.activeCell)
+        #expect(duplicated.row != added.row)
+        #expect(model.columns.column(at: duplicated.displayColumn)?.name == "name")
+    }
+
     private func makeQueryCoordinator(keysResolved: Bool) throws -> MainContentCoordinator {
         let fixture = fixtures.make()
         let tabManager = fixture.tabManager
@@ -133,7 +157,6 @@ struct MainContentCommandActionsResultViewTests {
         let actions = MainContentCommandActions(
             coordinator: coordinator,
             connection: connection,
-            selectionState: coordinator.selectionState,
             selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
             pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
             pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
@@ -162,8 +185,7 @@ struct MainContentCommandActionsResultViewTests {
         #expect(mode(coordinator, tabId) == .json)
     }
 
-    /// The menu lists every mode, so the command has to refuse the ones this tab cannot show rather
-    /// than leaving it on a mode with nothing to render.
+    // The menu lists every mode, so the command refuses ones this tab cannot show rather than render nothing.
     @Test("A mode the tab does not offer is refused")
     func refusesAnUnavailableMode() {
         let (actions, coordinator, tabId) = makeActions(tabType: .query, tableName: nil)
diff --git a/apple/TableProTests/Views/Main/MainContentCoordinatorDisplayStateTests.swift b/apple/TableProTests/Views/Main/MainContentCoordinatorDisplayStateTests.swift
index 50736d9ec4..8228adc933 100644
--- a/apple/TableProTests/Views/Main/MainContentCoordinatorDisplayStateTests.swift
+++ b/apple/TableProTests/Views/Main/MainContentCoordinatorDisplayStateTests.swift
@@ -3,10 +3,7 @@
 //  TableProTests
 //
 
-import AppKit
 import Foundation
-import SwiftUI
-import TableProEditorKit
 import TableProPluginKit
 import Testing
 
@@ -50,7 +47,15 @@ struct MainContentCoordinatorDisplayStateTests {
         coordinator.setActiveTableRows(tableRows, for: tabId)
     }
 
-    @Test("Two tabs keep their own formatted text, and a switch between them reuses both")
+    private func cache(_ coordinator: MainContentCoordinator, _ tabId: UUID, rows: [Int]) -> RowDisplayCache {
+        let cache = coordinator.gridModel(forTab: tabId).display.cache
+        for row in rows {
+            cache.setBox(RowDisplayBox(["formatted \(row)", nil]), forID: .existing(row))
+        }
+        return cache
+    }
+
+    @Test("Two tabs keep their own model and formatted text, and a switch between them reuses both")
     func alternatingTabsReuseTheirOwnState() {
         let (coordinator, tabManager) = makeCoordinator()
         let first = addTableTab(to: tabManager, tableName: "orders")
@@ -58,24 +63,31 @@ struct MainContentCoordinatorDisplayStateTests {
         seedRows(coordinator, for: first.id)
         seedRows(coordinator, for: second.id)
 
-        let firstState = coordinator.displayState(for: tabManager.tabs[0])
-        let secondState = coordinator.displayState(for: tabManager.tabs[1])
-        #expect(firstState !== secondState)
+        let firstModel = coordinator.gridModel(forTab: first.id)
+        let secondModel = coordinator.gridModel(forTab: second.id)
+        #expect(firstModel !== secondModel)
+        #expect(firstModel.display !== secondModel.display)
+        let firstCache = cache(coordinator, first.id, rows: [0])
 
-        #expect(coordinator.displayState(for: tabManager.tabs[0]) === firstState)
-        #expect(coordinator.displayState(for: tabManager.tabs[1]) === secondState)
-        #expect(coordinator.displayState(for: tabManager.tabs[0]) === firstState)
+        coordinator.handleTabChange(from: second.id, to: first.id, tabs: tabManager.tabs)
+        coordinator.handleTabChange(from: first.id, to: second.id, tabs: tabManager.tabs)
+
+        #expect(coordinator.gridModel(forTab: first.id) === firstModel)
+        #expect(coordinator.gridModel(forTab: second.id) === secondModel)
+        #expect(firstCache.box(forID: .existing(0)) != nil)
     }
 
-    @Test("Replacing a tab's rows replaces its formatted text")
+    @Test("Replacing a tab's rows drops its formatted text")
     func newRowsReplaceTheState() {
         let (coordinator, tabManager) = makeCoordinator()
         let tab = addTableTab(to: tabManager, tableName: "orders")
         seedRows(coordinator, for: tab.id)
-        let before = coordinator.displayState(for: tabManager.tabs[0])
+        let formatted = cache(coordinator, tab.id, rows: [0, 1])
 
         seedRows(coordinator, for: tab.id)
-        #expect(coordinator.displayState(for: tabManager.tabs[0]) !== before)
+
+        #expect(formatted.box(forID: .existing(0)) == nil)
+        #expect(formatted.box(forID: .existing(1)) == nil)
     }
 
     @Test("An in-place edit keeps the text formatted for the rest of the page")
@@ -83,28 +95,28 @@ struct MainContentCoordinatorDisplayStateTests {
         let (coordinator, tabManager) = makeCoordinator()
         let tab = addTableTab(to: tabManager, tableName: "orders")
         seedRows(coordinator, for: tab.id)
-        let before = coordinator.displayState(for: tabManager.tabs[0])
+        let formatted = cache(coordinator, tab.id, rows: [0, 1])
 
-        coordinator.tabSessionRegistry.updateTableRows(for: tab.id) { _ in .none }
-        #expect(coordinator.displayState(for: tabManager.tabs[0]) === before)
+        coordinator.mutateActiveTableRows(for: tab.id) { rows in
+            rows.edit(row: 0, column: 1, value: .text("edited"))
+        }
+
+        let editedRow = formatted.box(forID: .existing(0))?.values ?? []
+        #expect(editedRow.compactMap { $0 }.isEmpty)
+        #expect(formatted.box(forID: .existing(1))?.values.first == "formatted 1")
     }
 
-    @Test("A different set of columns replaces the formatted text")
+    @Test("A different set of columns replaces the model's columns and its formatted text")
     func newColumnsReplaceTheState() {
         let (coordinator, tabManager) = makeCoordinator()
         let tab = addTableTab(to: tabManager, tableName: "orders")
         seedRows(coordinator, for: tab.id, columns: ["id", "name"])
-        let before = coordinator.displayState(for: tabManager.tabs[0])
-
-        coordinator.tabSessionRegistry.setTableRows(
-            TableRows.from(
-                queryRows: [[.text("1")]],
-                columns: ["id"],
-                columnTypes: [.text(rawType: nil)]
-            ),
-            for: tab.id
-        )
-        #expect(coordinator.displayState(for: tabManager.tabs[0]) !== before)
+        let formatted = cache(coordinator, tab.id, rows: [0])
+
+        seedRows(coordinator, for: tab.id, columns: ["id"])
+
+        #expect(coordinator.gridModel(forTab: tab.id).columns.count == 1)
+        #expect(formatted.box(forID: .existing(0)) == nil)
     }
 
     @Test("Evicting a tab's rows drops the text formatted from them")
@@ -114,26 +126,43 @@ struct MainContentCoordinatorDisplayStateTests {
         let second = addTableTab(to: tabManager, tableName: "customers")
         seedRows(coordinator, for: first.id)
         seedRows(coordinator, for: second.id)
-        _ = coordinator.displayState(for: tabManager.tabs[0])
-        #expect(coordinator.displayStateCache[first.id] != nil)
+        let formatted = cache(coordinator, first.id, rows: [0])
 
         #expect(coordinator.evictReloadableTableRows(for: first.id))
-        #expect(coordinator.displayStateCache[first.id] == nil)
+        #expect(formatted.box(forID: .existing(0)) == nil)
+        #expect(coordinator.gridModel(forTab: first.id).rowCount == 0)
     }
 
-    @Test("Closed tabs take their formatted text with them")
+    @Test("Closed tabs take their grid model with them")
     func closingATabPrunesTheState() {
         let (coordinator, tabManager) = makeCoordinator()
         let first = addTableTab(to: tabManager, tableName: "orders")
         let second = addTableTab(to: tabManager, tableName: "customers")
         seedRows(coordinator, for: first.id)
         seedRows(coordinator, for: second.id)
-        _ = coordinator.displayState(for: tabManager.tabs[0])
-        _ = coordinator.displayState(for: tabManager.tabs[1])
+        _ = coordinator.gridModel(forTab: first.id)
+        _ = coordinator.gridModel(forTab: second.id)
 
         coordinator.cleanupTabCaches(openTabIds: [second.id])
-        #expect(coordinator.displayStateCache[first.id] == nil)
-        #expect(coordinator.displayStateCache[second.id] != nil)
+
+        #expect(coordinator.existingGridModel(forTab: first.id) == nil)
+        #expect(coordinator.existingGridModel(forTab: second.id) != nil)
+    }
+
+    // Formatted text an unmounted model kept goes stale once the settings it was formatted with move.
+    @Test("A model whose display inputs moved drops its formatted text before it is shown again")
+    func staleDisplayInputsDropTheState() {
+        let (coordinator, tabManager) = makeCoordinator()
+        let tab = addTableTab(to: tabManager, tableName: "orders")
+        seedRows(coordinator, for: tab.id)
+        let formatted = cache(coordinator, tab.id, rows: [0])
+
+        coordinator.prepareGridModelForDisplay(forTab: tab.id)
+        #expect(formatted.box(forID: .existing(0)) != nil)
+
+        coordinator.dataGridEntries[tab.id]?.displayInputs = nil
+        coordinator.prepareGridModelForDisplay(forTab: tab.id)
+        #expect(formatted.box(forID: .existing(0)) == nil)
     }
 
     @Test("A tab switch is not a content change")
diff --git a/apple/TableProTests/Views/Main/MainContentCoordinatorGridSelectionTests.swift b/apple/TableProTests/Views/Main/MainContentCoordinatorGridSelectionTests.swift
index 3dbb77e614..db94322a53 100644
--- a/apple/TableProTests/Views/Main/MainContentCoordinatorGridSelectionTests.swift
+++ b/apple/TableProTests/Views/Main/MainContentCoordinatorGridSelectionTests.swift
@@ -2,35 +2,26 @@
 //  MainContentCoordinatorGridSelectionTests.swift
 //  TableProTests
 //
-//  A tab's grid selection has to survive the grid being destroyed, which happens on every tab
-//  switch and on every result-mode switch. `handleTabChange` always restored it; nothing ever
-//  captured it, so the restore replayed an empty set over the reader's selection. (#2667)
+//  A tab's grid selection lives on the tab's model, which outlives every mount of its grid, so a
+//  tab switch or a result-mode switch never loses it (#2667).
 //
 
 import AppKit
 import Foundation
 import SwiftUI
 import TableProPluginKit
+import TableProTestSupport
 import Testing
 
 @testable import TablePro
 
-@MainActor
-private final class StubColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 @MainActor
 struct MainContentCoordinatorGridSelectionTests {
     private let fixtures = CoordinatorFixtures()
 
     private func makeCoordinator() -> (MainContentCoordinator, QueryTabManager) {
         let fixture = fixtures.make()
-        let tabManager = fixture.tabManager
-        let coordinator = fixture.coordinator
-        return (coordinator, tabManager)
+        return (fixture.coordinator, fixture.tabManager)
     }
 
     @discardableResult
@@ -47,10 +38,10 @@ struct MainContentCoordinatorGridSelectionTests {
     private func makeRows(_ count: Int) -> TableRows {
         let rows = ContiguousArray(
             (0..<count).map { index in
-                Row(id: .existing(index), values: [.text("row\(index)")])
+                Row(id: .existing(index), values: [.text("row\(index)"), .text("value\(index)")])
             }
         )
-        return TableRows(rows: rows, columns: ["name"], columnTypes: [.text(rawType: nil)])
+        return TableRows(rows: rows, columns: ["name", "value"], columnTypes: [.text(rawType: nil), .text(rawType: nil)])
     }
 
     private func block(rows: ClosedRange<Int>, columns: ClosedRange<Int>) -> GridSelection {
@@ -61,274 +52,219 @@ struct MainContentCoordinatorGridSelectionTests {
         )
     }
 
-    // MARK: - Capture
-
-    @Test("a grid's teardown keeps its row selection on the tab")
-    func teardownKeepsRowSelection() throws {
-        let (coordinator, tabManager) = makeCoordinator()
-        let tabId = addQueryTab(to: tabManager, title: "A")
-
-        coordinator.storeGridSelection(rows: [3, 5, 7], cells: .empty, forTab: tabId)
-
-        let tab = try #require(tabManager.tabs.first { $0.id == tabId })
-        #expect(tab.selectedRowIndices == [3, 5, 7])
-        #expect(tab.cellSelection.isEmpty)
-    }
-
-    @Test("a grid's teardown keeps its cell rectangle on the tab")
-    func teardownKeepsCellSelection() throws {
-        let (coordinator, tabManager) = makeCoordinator()
-        let tabId = addQueryTab(to: tabManager, title: "A")
-        let cells = block(rows: 1...4, columns: 2...3)
-
-        coordinator.storeGridSelection(rows: [1], cells: cells, forTab: tabId)
-
-        let tab = try #require(tabManager.tabs.first { $0.id == tabId })
-        #expect(tab.cellSelection == cells)
+    private func switchTab(_ coordinator: MainContentCoordinator, from old: UUID, to new: UUID) {
+        coordinator.tabManager.selectedTabId = new
+        coordinator.handleTabChange(from: old, to: new, tabs: coordinator.tabManager.tabs)
     }
 
-    /// The capture is keyed by the tab the grid was built for, not by whichever tab is selected when
-    /// the teardown happens to run. SwiftUI does not order a teardown against the switch that caused
-    /// it, so reading the selected tab here would sometimes write the wrong one.
-    @Test("the capture writes the tab it names, not the selected one")
-    func captureWritesTheNamedTab() throws {
-        let (coordinator, tabManager) = makeCoordinator()
-        let outgoing = addQueryTab(to: tabManager, title: "A", select: false)
-        let incoming = addQueryTab(to: tabManager, title: "B")
-
-        coordinator.storeGridSelection(rows: [8], cells: .empty, forTab: outgoing)
-
-        let outgoingTab = try #require(tabManager.tabs.first { $0.id == outgoing })
-        let incomingTab = try #require(tabManager.tabs.first { $0.id == incoming })
-        #expect(outgoingTab.selectedRowIndices == [8])
-        #expect(incomingTab.selectedRowIndices.isEmpty)
-    }
+    // MARK: - Across a switch
 
-    /// The teardown capture is only believable while its tab is still the selected one. On a tab
-    /// switch the shared selection channel is repointed at the incoming tab while the outgoing grid
-    /// is still bound to it, so the outgoing table view is cleared before its teardown runs and the
-    /// capture would store emptiness over what `handleTabChange` just saved (measured).
-    @Test("a teardown after the tab was deselected does not overwrite the saved selection")
-    func teardownAfterDeselectionDoesNotClobber() throws {
+    @Test("switching back finds the row selection the tab was left with")
+    func switchingBackKeepsRows() {
         let (coordinator, tabManager) = makeCoordinator()
         let tabA = addQueryTab(to: tabManager, title: "A")
         let tabB = addQueryTab(to: tabManager, title: "B")
-        coordinator.storeGridSelection(rows: [4, 6], cells: .empty, forTab: tabA)
-        tabManager.selectedTabId = tabB
-
-        coordinator.storeGridSelectionOnTeardown(rows: [], cells: .empty, forTab: tabA)
-
-        let tab = try #require(tabManager.tabs.first { $0.id == tabA })
-        #expect(tab.selectedRowIndices == [4, 6])
-    }
-
-    /// A result-mode switch destroys the grid without changing tabs, and there the table view still
-    /// holds what the reader selected, so the teardown capture is the one that must land.
-    @Test("a teardown while the tab is still selected is written through")
-    func teardownWhileSelectedIsWritten() throws {
-        let (coordinator, tabManager) = makeCoordinator()
-        let tabId = addQueryTab(to: tabManager, title: "A")
+        coordinator.setActiveTableRows(makeRows(20), for: tabA)
+        coordinator.setActiveTableRows(makeRows(20), for: tabB)
+        coordinator.gridModel(forTab: tabA).selectRows([.existing(4), .existing(6)])
 
-        coordinator.storeGridSelectionOnTeardown(rows: [2, 3], cells: .empty, forTab: tabId)
+        switchTab(coordinator, from: tabB, to: tabA)
 
-        let tab = try #require(tabManager.tabs.first { $0.id == tabId })
-        #expect(tab.selectedRowIndices == [2, 3])
+        #expect(coordinator.activeGridModel?.selectedRowIDs == [.existing(4), .existing(6)])
     }
 
-    /// The switch itself is what captures the outgoing tab, because by the time that tab's grid is
-    /// torn down its table view has already been cleared through the shared channel.
-    @Test("switching away captures the outgoing tab's live grid selection")
-    func switchingAwayCapturesTheOutgoingSelection() throws {
+    // A cell drag selects a block of cells, and restoring it as whole rows would make Copy copy whole rows.
+    @Test("switching back finds the cell rectangle, not only its rows")
+    func switchingBackKeepsTheCellRectangle() {
         let (coordinator, tabManager) = makeCoordinator()
         let tabA = addQueryTab(to: tabManager, title: "A")
         let tabB = addQueryTab(to: tabManager, title: "B")
         coordinator.setActiveTableRows(makeRows(20), for: tabA)
         coordinator.setActiveTableRows(makeRows(20), for: tabB)
-        tabManager.selectedTabId = tabA
-
-        let tableView = NSTableView()
-        let delegate = DataTabGridDelegate()
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubColumnLayoutPersister()
-        )
-        gridCoordinator.tableView = tableView
-        delegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = delegate
-        gridCoordinator.selectionController.update(block(rows: 5...8, columns: 0...1))
+        switchTab(coordinator, from: tabB, to: tabA)
+        coordinator.gridModel(forTab: tabA).setSelection(block(rows: 2...5, columns: 1...1))
 
-        tabManager.selectedTabId = tabB
-        coordinator.handleTabChange(from: tabA, to: tabB, tabs: tabManager.tabs)
+        switchTab(coordinator, from: tabA, to: tabB)
+        switchTab(coordinator, from: tabB, to: tabA)
 
-        let stored = try #require(tabManager.tabs.first { $0.id == tabA })
-        #expect(stored.cellSelection.rectangles == [GridRect(rows: 5...8, columns: 0...1)])
-        #expect(stored.selectedDisplayRows == [5, 6, 7, 8])
+        let selection = coordinator.activeGridModel?.selection
+        #expect(selection?.rectangles == [GridRect(rows: 2...5, columns: 1...1)])
+        #expect(selection?.affectedRows == IndexSet(integersIn: 2...5))
     }
 
-    // MARK: - Restore
-
-    @Test("switching back restores the row selection the tab was left with")
-    func switchingBackRestoresRows() {
+    @Test("two tabs keep their own selections across a round trip")
+    func twoTabsKeepTheirOwnSelections() {
         let (coordinator, tabManager) = makeCoordinator()
         let tabA = addQueryTab(to: tabManager, title: "A")
         let tabB = addQueryTab(to: tabManager, title: "B")
         coordinator.setActiveTableRows(makeRows(20), for: tabA)
         coordinator.setActiveTableRows(makeRows(20), for: tabB)
+        coordinator.gridModel(forTab: tabA).selectRows([.existing(1)])
+        coordinator.gridModel(forTab: tabB).selectRows([.existing(9)])
 
-        coordinator.storeGridSelection(rows: [4, 6], cells: .empty, forTab: tabA)
-        coordinator.handleTabChange(from: tabA, to: tabB, tabs: tabManager.tabs)
-        #expect(coordinator.selectionState.indices.isEmpty)
-
-        coordinator.handleTabChange(from: tabB, to: tabA, tabs: tabManager.tabs)
+        switchTab(coordinator, from: tabB, to: tabA)
+        #expect(coordinator.activeGridModel?.selectedRowIDs == [.existing(1)])
 
-        #expect(coordinator.selectionState.indices == [4, 6])
+        switchTab(coordinator, from: tabA, to: tabB)
+        #expect(coordinator.activeGridModel?.selectedRowIDs == [.existing(9)])
     }
 
-    /// A cell drag pins the table view's row selection to its anchor row, so restoring from the
-    /// stored rows alone would shrink the reader's block to that one row.
-    @Test("switching back restores every row a cell rectangle covers")
-    func switchingBackRestoresCellRectangleRows() {
+    @Test("a result-mode switch keeps the selection the grid had")
+    func resultModeSwitchKeepsTheSelection() {
         let (coordinator, tabManager) = makeCoordinator()
-        let tabA = addQueryTab(to: tabManager, title: "A")
-        let tabB = addQueryTab(to: tabManager, title: "B")
-        coordinator.setActiveTableRows(makeRows(20), for: tabA)
-        coordinator.setActiveTableRows(makeRows(20), for: tabB)
+        let tabId = addQueryTab(to: tabManager, title: "A")
+        coordinator.setActiveTableRows(makeRows(5), for: tabId)
+        coordinator.gridModel(forTab: tabId).selectRows([.existing(3)])
 
-        coordinator.storeGridSelection(rows: [2], cells: block(rows: 2...5, columns: 0...1), forTab: tabA)
-        coordinator.handleTabChange(from: tabA, to: tabB, tabs: tabManager.tabs)
-        coordinator.handleTabChange(from: tabB, to: tabA, tabs: tabManager.tabs)
+        tabManager.mutate(tabId: tabId) { $0.display.resultsViewMode = .json }
+        #expect(coordinator.activeGridModel?.selectedRowIDs == [.existing(3)])
+        tabManager.mutate(tabId: tabId) { $0.display.resultsViewMode = .data }
 
-        #expect(coordinator.selectionState.indices == [2, 3, 4, 5])
+        #expect(coordinator.activeGridModel?.selectedRowIDs == [.existing(3)])
     }
 
-    @Test("two tabs keep their own selections across a round trip")
-    func twoTabsKeepTheirOwnSelections() throws {
+    @Test("the active grid model is the data tab's in Data, JSON and Map, and nobody's in Chart")
+    func activeGridModelFollowsTheResultMode() {
         let (coordinator, tabManager) = makeCoordinator()
-        let tabA = addQueryTab(to: tabManager, title: "A")
-        let tabB = addQueryTab(to: tabManager, title: "B")
-        coordinator.setActiveTableRows(makeRows(20), for: tabA)
-        coordinator.setActiveTableRows(makeRows(20), for: tabB)
+        let tabId = addQueryTab(to: tabManager, title: "A")
+        coordinator.setActiveTableRows(makeRows(3), for: tabId)
+        let model = coordinator.gridModel(forTab: tabId)
 
-        coordinator.storeGridSelection(rows: [1], cells: .empty, forTab: tabA)
-        coordinator.storeGridSelection(rows: [9], cells: .empty, forTab: tabB)
+        for mode in [ResultsViewMode.data, .json, .map] {
+            tabManager.mutate(tabId: tabId) { $0.display.resultsViewMode = mode }
+            #expect(coordinator.activeGridModel === model, "\(mode)")
+        }
+        tabManager.mutate(tabId: tabId) { $0.display.resultsViewMode = .chart }
+        #expect(coordinator.activeGridModel == nil)
+    }
 
-        coordinator.handleTabChange(from: tabA, to: tabB, tabs: tabManager.tabs)
-        #expect(coordinator.selectionState.indices == [9])
+    // MARK: - Watching from outside the grid
+
+    private final class WatchedChanges {
+        var appeared = false
+        var rowsChanged: [Bool] = []
+    }
 
-        coordinator.handleTabChange(from: tabB, to: tabA, tabs: tabManager.tabs)
-        #expect(coordinator.selectionState.indices == [1])
+    private func settle(_ window: NSWindow, until condition: () -> Bool) async throws {
+        try await waitUntil {
+            window.contentView?.layoutSubtreeIfNeeded()
+            return condition()
+        }
+    }
 
-        let stored = try #require(tabManager.tabs.first { $0.id == tabB })
-        #expect(stored.selectedRowIndices == [9])
+    // The window reopens the inspector only when other rows are picked, so a closed one stays closed under arrow keys.
+    @Test("the selection watcher tells a move of the cursor within the selected row from picking another row")
+    func watcherReportsWhetherTheSelectedRowsChanged() async throws {
+        let (coordinator, tabManager) = makeCoordinator()
+        let tabId = addQueryTab(to: tabManager, title: "A")
+        coordinator.setActiveTableRows(makeRows(5), for: tabId)
+        let model = coordinator.gridModel(forTab: tabId)
+        let changes = WatchedChanges()
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 40, height: 40),
+            styleMask: [.titled],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        window.contentView = NSHostingView(rootView: GridSelectionWatcher(
+            model: model,
+            onAttach: { changes.appeared = true },
+            onChange: { changes.rowsChanged.append($0) }
+        ))
+        defer { window.orderOut(nil) }
+        try await settle(window) { changes.appeared }
+
+        model.selectCell(GridCoord(row: 1, displayColumn: 0))
+        try await settle(window) { changes.rowsChanged.count == 1 }
+        model.selectCell(GridCoord(row: 1, displayColumn: 1))
+        try await settle(window) { changes.rowsChanged.count == 2 }
+        model.selectCell(GridCoord(row: 2, displayColumn: 1))
+        try await settle(window) { changes.rowsChanged.count == 3 }
+
+        #expect(changes.rowsChanged == [true, false, true])
     }
 
     // MARK: - Invalidation
 
-    /// Display positions mean nothing against rows that were replaced wholesale, so both halves of
-    /// the stored selection go, not just the rows.
-    @Test("a new result clears the tab's stored cell rectangle too")
-    func newResultClearsStoredCellSelection() throws {
+    // Row ids are positional per page, so a selection means nothing against rows replaced wholesale.
+    @Test("a new result clears the model's selection and its stored snapshot")
+    func newResultClearsTheSelection() {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager, title: "A")
-        coordinator.storeGridSelection(rows: [1], cells: block(rows: 1...3, columns: 0...2), forTab: tabId)
+        coordinator.setActiveTableRows(makeRows(5), for: tabId)
+        let model = coordinator.gridModel(forTab: tabId)
+        model.setSelection(block(rows: 1...3, columns: 0...1))
 
         coordinator.setActiveTableRows(makeRows(5), for: tabId)
 
-        let tab = try #require(tabManager.tabs.first { $0.id == tabId })
-        #expect(tab.selectedRowIndices.isEmpty)
-        #expect(tab.cellSelection.isEmpty)
+        #expect(model.selection.isEmpty)
+        #expect(model.store.selectionSnapshot.isEmpty)
     }
 
-    @Test("retargeting a tab to another table clears its stored selection")
+    @Test("retargeting a tab to another table clears the selection it carries")
     func retargetClearsStoredSelection() throws {
-        let (coordinator, tabManager) = makeCoordinator()
+        let (_, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager, title: "A")
-        coordinator.storeGridSelection(rows: [2], cells: block(rows: 2...2, columns: 0...0), forTab: tabId)
+        tabManager.mutate(tabId: tabId) {
+            $0.selectionSnapshot = GridSelectionSnapshot(rowIDs: [.existing(2)], rectangles: [], activeCell: nil, anchor: nil)
+        }
 
         try tabManager.replaceTabContent(tableName: "orders")
 
         let tab = try #require(tabManager.tabs.first { $0.id == tabId })
-        #expect(tab.selectedRowIndices.isEmpty)
-        #expect(tab.cellSelection.isEmpty)
+        #expect(tab.selectionSnapshot.isEmpty)
     }
 
-    /// `selectedDisplayRows` gives a stored rectangle precedence, so a later row-only writer has to
-    /// clear it or the rectangle comes back instead of the rows that writer chose.
-    @Test("a stored cell rectangle does not outrank rows a paste selected")
-    func pasteSupersedesAStoredCellRectangle() throws {
+    // MARK: - Moving a tab to another window
+
+    @Test("a tab enriched for another window carries its model's selection")
+    func enrichedTabCarriesTheSelection() throws {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager, title: "A")
-        coordinator.storeGridSelection(rows: [1], cells: block(rows: 1...4, columns: 0...1), forTab: tabId)
+        coordinator.setActiveTableRows(makeRows(5), for: tabId)
+        coordinator.gridModel(forTab: tabId).setSelection(block(rows: 0...2, columns: 0...1))
+        let tab = try #require(tabManager.tabs.first { $0.id == tabId })
 
-        tabManager.mutate(tabId: tabId) { tab in
-            tab.selectedRowIndices = [9]
-            tab.cellSelection = .empty
-        }
+        let enriched = coordinator.enrichedForPersistence(tab)
 
-        let tab = try #require(tabManager.tabs.first { $0.id == tabId })
-        #expect(tab.selectedDisplayRows == [9])
+        #expect(enriched.selectionSnapshot.rowIDs == [.existing(0), .existing(1), .existing(2)])
+        #expect(enriched.selectionSnapshot.rectangles.count == 1)
     }
 
-    // MARK: - Moving a tab to another window
-
-    /// A tab handed to another window is snapshotted while its grid is still mounted, so the
-    /// teardown capture has not run and the tab's own copy is still the one from the last switch.
-    @Test("a tab enriched for another window carries the live grid selection")
-    func enrichedTabCarriesLiveSelection() {
+    @Test("a background tab is enriched from its own model, not the selected tab's")
+    func enrichedBackgroundTabUsesItsOwnModel() throws {
         let (coordinator, tabManager) = makeCoordinator()
-        let tabId = addQueryTab(to: tabManager, title: "A")
-        let tab = tabManager.tabs[0]
-
-        let tableView = NSTableView()
-        let delegate = DataTabGridDelegate()
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubColumnLayoutPersister()
-        )
-        gridCoordinator.tableView = tableView
-        delegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = delegate
-        gridCoordinator.selectionController.update(block(rows: 0...2, columns: 0...1))
+        let background = addQueryTab(to: tabManager, title: "A", select: false)
+        let selected = addQueryTab(to: tabManager, title: "B")
+        coordinator.setActiveTableRows(makeRows(10), for: background)
+        coordinator.setActiveTableRows(makeRows(10), for: selected)
+        coordinator.gridModel(forTab: background).selectRows([.existing(7)])
+        coordinator.gridModel(forTab: selected).selectRows([.existing(1)])
+        let tab = try #require(tabManager.tabs.first { $0.id == background })
 
         let enriched = coordinator.enrichedForPersistence(tab)
 
-        #expect(enriched.cellSelection.rectangles == [GridRect(rows: 0...2, columns: 0...1)])
-        #expect(enriched.selectedDisplayRows == [0, 1, 2])
-        #expect(tabId == enriched.id)
+        #expect(enriched.selectionSnapshot.rowIDs == [.existing(7)])
     }
 
-    @Test("a background tab is enriched from its own stored selection, not the mounted grid's")
-    func enrichedBackgroundTabIgnoresMountedGrid() {
+    // The model's store starts from the selection a tab carried in from another window.
+    @Test("a model created for a tab starts from the selection the tab carries")
+    func modelStartsFromTheCarriedSelection() throws {
         let (coordinator, tabManager) = makeCoordinator()
-        let background = addQueryTab(to: tabManager, title: "A", select: false)
-        addQueryTab(to: tabManager, title: "B")
-        coordinator.storeGridSelection(rows: [7], cells: .empty, forTab: background)
-
-        let tableView = NSTableView()
-        let delegate = DataTabGridDelegate()
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubColumnLayoutPersister()
-        )
-        gridCoordinator.tableView = tableView
-        delegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = delegate
-
-        guard let tab = tabManager.tabs.first(where: { $0.id == background }) else {
-            Issue.record("Expected the background tab to exist")
-            return
+        let tabId = addQueryTab(to: tabManager, title: "A")
+        coordinator.setActiveTableRows(makeRows(5), for: tabId)
+        tabManager.mutate(tabId: tabId) {
+            $0.selectionSnapshot = GridSelectionSnapshot(
+                rowIDs: [.existing(2), .existing(3)],
+                rectangles: [],
+                activeCell: nil,
+                anchor: nil
+            )
         }
-        let enriched = coordinator.enrichedForPersistence(tab)
 
-        #expect(enriched.selectedRowIndices == [7])
+        let model = coordinator.gridModel(forTab: tabId)
+
+        #expect(model.selectedRowIDs == [.existing(2), .existing(3)])
     }
 }
diff --git a/apple/TableProTests/Views/Main/MainContentCoordinatorSelectionResetTests.swift b/apple/TableProTests/Views/Main/MainContentCoordinatorSelectionResetTests.swift
index ea3ebab713..fbd0fd38ea 100644
--- a/apple/TableProTests/Views/Main/MainContentCoordinatorSelectionResetTests.swift
+++ b/apple/TableProTests/Views/Main/MainContentCoordinatorSelectionResetTests.swift
@@ -2,10 +2,8 @@
 //  MainContentCoordinatorSelectionResetTests.swift
 //  TableProTests
 //
-//  A row selection is a set of display positions into the result that produced it. Replacing
-//  the rows wholesale, by running a query or switching result set, has to drop it: consumers
-//  that keep reading it, the JSON results view and the row inspector, would otherwise resolve
-//  positions that belong to rows the user never selected.
+//  Row ids are positional per page, so a selection means nothing once its rows are replaced
+//  wholesale. The JSON view and the inspector would otherwise read rows the user never selected.
 //
 
 import Foundation
@@ -45,44 +43,52 @@ struct MainContentCoordinatorSelectionResetTests {
         return TableRows(rows: rows, columns: ["name"], columnTypes: [.text(rawType: nil)])
     }
 
-    @Test("a new result clears the live selection of the active tab")
+    private func snapshot(rows: [Int]) -> GridSelectionSnapshot {
+        GridSelectionSnapshot(rowIDs: rows.map { RowID.existing($0) }, rectangles: [], activeCell: nil, anchor: nil)
+    }
+
+    @Test("a new result clears the active tab's model selection")
     func newResultClearsLiveSelection() {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager)
         coordinator.setActiveTableRows(makeRows(5), for: tabId)
-        coordinator.selectionState.indices = [1, 3]
+        let model = coordinator.gridModel(forTab: tabId)
+        model.selectRows([.existing(1), .existing(3)])
 
         coordinator.setActiveTableRows(makeRows(5), for: tabId)
 
-        #expect(coordinator.selectionState.indices.isEmpty)
+        #expect(model.selection.isEmpty)
+        #expect(model.store.selectionSnapshot.isEmpty)
     }
 
-    @Test("a new result clears the tab's persisted selection")
+    @Test("a new result clears the selection the tab carries")
     func newResultClearsPersistedSelection() throws {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager)
-        tabManager.mutate(tabId: tabId) { $0.selectedRowIndices = [0, 2] }
+        tabManager.mutate(tabId: tabId) { $0.selectionSnapshot = snapshot(rows: [0, 2]) }
 
         coordinator.setActiveTableRows(makeRows(3), for: tabId)
 
         let tab = try #require(tabManager.tabs.first { $0.id == tabId })
-        #expect(tab.selectedRowIndices.isEmpty)
+        #expect(tab.selectionSnapshot.isEmpty)
     }
 
-    @Test("a result for a background tab leaves the active tab's live selection alone")
+    @Test("a result for a background tab clears that tab's selection and leaves the active tab's alone")
     func backgroundTabResultKeepsActiveSelection() throws {
         let (coordinator, tabManager) = makeCoordinator()
         let backgroundTabId = addQueryTab(to: tabManager, select: false)
         let activeTabId = addQueryTab(to: tabManager)
-        tabManager.mutate(tabId: backgroundTabId) { $0.selectedRowIndices = [4] }
+        coordinator.setActiveTableRows(makeRows(5), for: backgroundTabId)
         coordinator.setActiveTableRows(makeRows(5), for: activeTabId)
-        coordinator.selectionState.indices = [2]
+        let background = coordinator.gridModel(forTab: backgroundTabId)
+        background.selectRows([.existing(4)])
+        let active = coordinator.gridModel(forTab: activeTabId)
+        active.selectRows([.existing(2)])
 
         coordinator.setActiveTableRows(makeRows(5), for: backgroundTabId)
 
-        #expect(coordinator.selectionState.indices == [2])
-        let background = try #require(tabManager.tabs.first { $0.id == backgroundTabId })
-        #expect(background.selectedRowIndices.isEmpty)
+        #expect(active.selectedRowIDs == [.existing(2)])
+        #expect(background.selection.isEmpty)
     }
 
     @Test("an incremental row edit keeps the selection")
@@ -90,13 +96,13 @@ struct MainContentCoordinatorSelectionResetTests {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager)
         coordinator.setActiveTableRows(makeRows(4), for: tabId)
-        coordinator.selectionState.indices = [1]
+        let model = coordinator.gridModel(forTab: tabId)
+        model.selectRows([.existing(1)])
 
         coordinator.mutateActiveTableRows(for: tabId) { rows in
-            rows.rows[1].values[0] = .text("edited")
-            return .none
+            rows.edit(row: 1, column: 0, value: .text("edited"))
         }
 
-        #expect(coordinator.selectionState.indices == [1])
+        #expect(model.selectedRowIDs == [.existing(1)])
     }
 }
diff --git a/apple/TableProTests/Views/Main/MainContentCoordinatorTabSwitchTests.swift b/apple/TableProTests/Views/Main/MainContentCoordinatorTabSwitchTests.swift
index f203f5800e..f7692219d0 100644
--- a/apple/TableProTests/Views/Main/MainContentCoordinatorTabSwitchTests.swift
+++ b/apple/TableProTests/Views/Main/MainContentCoordinatorTabSwitchTests.swift
@@ -12,23 +12,6 @@ import Testing
 
 @testable import TablePro
 
-@MainActor
-private final class RetargetColumnLayoutPersister: ColumnLayoutPersisting {
-    var stored: [String: ColumnLayoutState] = [:]
-
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? {
-        stored[key.tableName]
-    }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {
-        stored[key.tableName] = layout
-    }
-
-    func clear(for key: ColumnLayoutTableKey) {
-        stored.removeValue(forKey: key.tableName)
-    }
-}
-
 @MainActor
 struct MainContentCoordinatorTabSwitchTests {
     private func makeCoordinator(
@@ -87,84 +70,32 @@ struct MainContentCoordinatorTabSwitchTests {
         coordinator.setActiveTableRows(tableRows, for: tabId)
     }
 
-    private func attachPendingQueryGrid(
-        to coordinator: MainContentCoordinator,
-        tabId: UUID,
-        width: CGFloat
-    ) throws -> (TableViewCoordinator, DataTabGridDelegate) {
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: RetargetColumnLayoutPersister()
+    // A width the user dragged in a query tab's grid: the model writes it to the tab, which saves it.
+    private func resizeQueryColumn(_ coordinator: MainContentCoordinator, tabId: UUID, width: CGFloat) {
+        coordinator.setActiveTableRows(
+            TableRows.from(queryRows: [[.text("Ada")]], columns: ["name"], columnTypes: [.text(rawType: "TEXT")]),
+            for: tabId
         )
-        gridCoordinator.tabType = .query
-        gridCoordinator.tableRowsProvider = { rows }
-        gridCoordinator.rebuildColumnMetadataCache(from: rows)
-
-        let tableView = NSTableView()
-        gridCoordinator.tableView = tableView
-        let column = NSTableColumn(identifier: try #require(gridCoordinator.columnIdentifier(for: 0)))
-        column.width = width
-        tableView.addTableColumn(column)
-        gridCoordinator.updateColumnPresentations(from: rows)
-        #expect(gridCoordinator.markColumnWidthUserSized(column))
-        gridCoordinator.onColumnLayoutDidChange = { [weak coordinator] layout in
-            coordinator?.applyColumnGeometry(from: layout, toTabId: tabId)
-        }
-        gridCoordinator.scheduleLayoutPersist()
-
-        let gridDelegate = DataTabGridDelegate()
-        gridDelegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = gridDelegate
-        return (gridCoordinator, gridDelegate)
+        coordinator.gridModel(forTab: tabId).columnGeometryDidChange(widths: ["name": width], order: nil)
     }
 
     @Test("Retargeting a table flushes its pending width before the tab geometry resets")
     func retargetFlushesOutgoingColumnLayoutBeforeReset() throws {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addTableTab(to: tabManager, tableName: "orders", databaseName: "app")
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let persister = RetargetColumnLayoutPersister()
-        let gridCoordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: persister
-        )
-        gridCoordinator.connectionId = coordinator.connectionId
-        gridCoordinator.databaseName = "app"
-        gridCoordinator.tableName = "orders"
-        gridCoordinator.tabType = .table
-        gridCoordinator.tableRowsProvider = { rows }
-        gridCoordinator.rebuildColumnMetadataCache(from: rows)
-
-        let tableView = NSTableView()
-        gridCoordinator.tableView = tableView
-        let column = NSTableColumn(identifier: try #require(gridCoordinator.columnIdentifier(for: 0)))
-        column.width = 180
-        tableView.addTableColumn(column)
-        gridCoordinator.updateColumnPresentations(from: rows)
-        #expect(gridCoordinator.markColumnWidthUserSized(column))
-        gridCoordinator.onColumnLayoutDidChange = { [weak coordinator] layout in
-            coordinator?.applyColumnGeometry(from: layout, toTabId: tabId)
+        let tab = try #require(tabManager.selectedTab)
+        let key = try #require(coordinator.columnLayoutTableKey(for: tab))
+        FileColumnLayoutPersister.shared.clear(for: key)
+        defer {
+            coordinator.teardown()
+            FileColumnLayoutPersister.shared.clear(for: key)
         }
-        gridCoordinator.scheduleLayoutPersist()
-
-        let gridDelegate = DataTabGridDelegate()
-        gridDelegate.dataGridAttach(tableViewCoordinator: gridCoordinator)
-        coordinator.dataTabDelegate = gridDelegate
+        coordinator.setActiveTableRows(
+            TableRows.from(queryRows: [[.text("Ada")]], columns: ["name"], columnTypes: [.text(rawType: "TEXT")]),
+            for: tabId
+        )
+        coordinator.gridModel(forTab: tabId).columnGeometryDidChange(widths: ["name": 180], order: nil)
+        #expect(FileColumnLayoutPersister.shared.load(for: key) == nil)
 
         try tabManager.replaceTabContent(
             tableName: "customers",
@@ -173,26 +104,20 @@ struct MainContentCoordinatorTabSwitchTests {
         )
 
         let retargetedTab = try #require(tabManager.tabs.first(where: { $0.id == tabId }))
-        #expect(persister.stored["orders"]?.columnWidths == ["name": 180])
-        #expect(gridCoordinator.pendingColumnLayoutPersistence == nil)
+        #expect(FileColumnLayoutPersister.shared.load(for: key)?.columnWidths == ["name": 180])
         #expect(retargetedTab.tableContext.tableName == "customers")
         #expect(retargetedTab.columnLayout == ColumnLayoutState())
     }
 
-    @Test("Closing a window flushes a pending query width before saving tabs")
-    func windowCloseFlushesPendingQueryColumnLayout() async throws {
+    @Test("Closing a window saves a query tab's grid widths")
+    func windowCloseSavesQueryColumnLayout() async throws {
         let wasTerminating = MainContentCoordinator.isAppTerminating
         MainContentCoordinator.isAppTerminating = false
         defer { MainContentCoordinator.isAppTerminating = wasTerminating }
 
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager)
-        let (gridCoordinator, gridDelegate) = try attachPendingQueryGrid(
-            to: coordinator,
-            tabId: tabId,
-            width: 180
-        )
-        _ = gridDelegate
+        resizeQueryColumn(coordinator, tabId: tabId, width: 180)
         coordinator.registerEagerly()
         coordinator.persistence.markObservedTabs()
         TabDiskActor.clearSync(connectionId: coordinator.connectionId)
@@ -200,31 +125,21 @@ struct MainContentCoordinatorTabSwitchTests {
         coordinator.handleWindowWillClose()
         let restored = await coordinator.persistence.restoreFromDisk()
 
-        #expect(gridCoordinator.pendingColumnLayoutPersistence == nil)
         #expect(restored.tabs.first?.columnLayout.columnWidths == ["name": 180])
         #expect(restored.tabs.first?.columnLayout.columnContentWidths == ["name": 180])
 
         coordinator.persistence.clearForUserClosedAllTabs()
     }
 
-    @Test("Disconnect persistence flushes pending query widths from every coordinator")
-    func disconnectPersistenceFlushesEveryPendingQueryColumnLayout() async throws {
+    @Test("Disconnect persistence saves query widths from every coordinator")
+    func disconnectPersistenceSavesEveryQueryColumnLayout() async throws {
         let connection = TestFixtures.makeConnection()
         let (firstCoordinator, firstTabManager) = makeCoordinator(connection: connection)
         let (secondCoordinator, secondTabManager) = makeCoordinator(connection: connection)
         let firstTabId = addQueryTab(to: firstTabManager, title: "First")
         let secondTabId = addQueryTab(to: secondTabManager, title: "Second")
-        let (firstGrid, firstDelegate) = try attachPendingQueryGrid(
-            to: firstCoordinator,
-            tabId: firstTabId,
-            width: 180
-        )
-        let (secondGrid, secondDelegate) = try attachPendingQueryGrid(
-            to: secondCoordinator,
-            tabId: secondTabId,
-            width: 220
-        )
-        _ = (firstDelegate, secondDelegate)
+        resizeQueryColumn(firstCoordinator, tabId: firstTabId, width: 180)
+        resizeQueryColumn(secondCoordinator, tabId: secondTabId, width: 220)
 
         firstCoordinator.registerEagerly()
         secondCoordinator.registerEagerly()
@@ -242,8 +157,6 @@ struct MainContentCoordinatorTabSwitchTests {
         let firstTab = try #require(restored.tabs.first(where: { $0.id == firstTabId }))
         let secondTab = try #require(restored.tabs.first(where: { $0.id == secondTabId }))
 
-        #expect(firstGrid.pendingColumnLayoutPersistence == nil)
-        #expect(secondGrid.pendingColumnLayoutPersistence == nil)
         #expect(firstTab.columnLayout.columnWidths == ["name": 180])
         #expect(secondTab.columnLayout.columnWidths == ["name": 220])
     }
@@ -252,12 +165,7 @@ struct MainContentCoordinatorTabSwitchTests {
     func connectionClosePersistencePrecedesCoordinatorTeardown() async throws {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager)
-        let (gridCoordinator, gridDelegate) = try attachPendingQueryGrid(
-            to: coordinator,
-            tabId: tabId,
-            width: 180
-        )
-        _ = gridDelegate
+        resizeQueryColumn(coordinator, tabId: tabId, width: 180)
         coordinator.registerEagerly()
         coordinator.persistence.markObservedTabs()
         TabDiskActor.clearSync(connectionId: coordinator.connectionId)
@@ -267,22 +175,17 @@ struct MainContentCoordinatorTabSwitchTests {
         coordinator.teardown()
         let restored = await coordinator.persistence.restoreFromDisk()
 
-        #expect(gridCoordinator.pendingColumnLayoutPersistence == nil)
         #expect(tabManager.tabs.isEmpty)
+        #expect(coordinator.existingGridModel(forTab: tabId) == nil)
         #expect(restored.tabs.first?.columnLayout.columnWidths == ["name": 180])
         #expect(restored.tabs.first?.columnLayout.columnContentWidths == ["name": 180])
     }
 
-    @Test("Closing a query tab flushes its pending width into recently closed state")
-    func closingQueryTabFlushesPendingColumnLayout() throws {
+    @Test("Closing a query tab keeps its widths in recently closed state and releases its model")
+    func closingQueryTabKeepsColumnLayout() throws {
         let (coordinator, tabManager) = makeCoordinator()
         let tabId = addQueryTab(to: tabManager)
-        let (gridCoordinator, gridDelegate) = try attachPendingQueryGrid(
-            to: coordinator,
-            tabId: tabId,
-            width: 180
-        )
-        _ = gridDelegate
+        resizeQueryColumn(coordinator, tabId: tabId, width: 180)
         defer {
             RecentlyClosedTabStore.shared.removeEntries(for: coordinator.connectionId)
             coordinator.teardown()
@@ -293,8 +196,8 @@ struct MainContentCoordinatorTabSwitchTests {
         let closedTab = RecentlyClosedTabStore.shared.entries.first {
             $0.connectionId == coordinator.connectionId && $0.tab.id == tabId
         }
-        #expect(gridCoordinator.pendingColumnLayoutPersistence == nil)
         #expect(tabManager.tabs.isEmpty)
+        #expect(coordinator.existingGridModel(forTab: tabId) == nil)
         #expect(closedTab?.tab.columnWidths == ["name": 180])
         #expect(closedTab?.tab.columnContentWidths == ["name": 180])
     }
@@ -367,9 +270,7 @@ struct MainContentCoordinatorTabSwitchTests {
         #expect(tabManager.tabs[oldIndex].pendingChanges.hasChanges == true)
     }
 
-    /// The write used to be gated on `changeManager.hasChanges`, so an undo left the snapshot a
-    /// previous switch had saved sitting on the tab. Switching back restored the edit the reader had
-    /// just taken back, and the tab went on reporting unsaved work until it was closed.
+    // Gated on `hasChanges`, an undo left an older snapshot on the tab, and switching back restored the undone edit.
     @Test("Switching clears a snapshot the reader has undone")
     func undoneChangesClearTheOutgoingSnapshot() throws {
         let (coordinator, tabManager) = makeCoordinator()
@@ -480,25 +381,22 @@ struct MainContentCoordinatorTabSwitchTests {
         #expect(coordinator.selectedTabHiddenColumns == ["email", "phone"])
     }
 
-    @Test("Switching restores selected row indices for the incoming tab")
+    @Test("Switching makes the incoming tab's own model the selection source")
     func restoresIncomingSelectedRows() {
         let (coordinator, tabManager) = makeCoordinator()
         let oldId = addQueryTab(to: tabManager, title: "Old")
         let newId = addQueryTab(to: tabManager, title: "New")
-        seedRows(coordinator, for: oldId)
-        seedRows(coordinator, for: newId)
-
-        guard let newIndex = tabManager.tabs.firstIndex(where: { $0.id == newId }) else {
-            Issue.record("Expected new tab to exist before switch")
-            return
-        }
-        tabManager.tabs[newIndex].selectedRowIndices = [3, 5, 7]
-
-        coordinator.selectionState.indices = [99]
+        seedRows(coordinator, for: oldId, rowCount: 8)
+        seedRows(coordinator, for: newId, rowCount: 8)
+        let oldModel = coordinator.gridModel(forTab: oldId)
+        oldModel.selectRows([.existing(0)])
+        coordinator.gridModel(forTab: newId).selectRows([.existing(3), .existing(5), .existing(7)])
 
+        tabManager.selectedTabId = newId
         coordinator.handleTabChange(from: oldId, to: newId, tabs: tabManager.tabs)
 
-        #expect(coordinator.selectionState.indices == [3, 5, 7])
+        #expect(coordinator.activeGridModel?.selectedRowIDs == [.existing(3), .existing(5), .existing(7)])
+        #expect(oldModel.selectedRowIDs == [.existing(0)])
     }
 
     @Test("Switching to a table tab marks toolbar as table tab")
@@ -1107,10 +1005,7 @@ struct MainContentCoordinatorTabSwitchTests {
 
     // MARK: - The caret of the tab being left
 
-    /// One editor serves every query tab, so the live caret describes the outgoing tab only until
-    /// the switch completes. Persistence writes it for the selected tab alone, and the tab's own
-    /// restored value was already cleared when its editor consumed it, so a caret not captured on
-    /// the way out is simply gone.
+    // One editor serves every query tab, so a caret not captured on the way out is gone.
     @Test("Switching away from a query tab keeps its caret on the tab")
     func switchingAwayCapturesTheCaret() {
         let (coordinator, tabManager) = makeCoordinator()
diff --git a/apple/TableProTests/Views/Main/MaterializedViewRowWriteTests.swift b/apple/TableProTests/Views/Main/MaterializedViewRowWriteTests.swift
index 4fa522ec04..6b5f3a8701 100644
--- a/apple/TableProTests/Views/Main/MaterializedViewRowWriteTests.swift
+++ b/apple/TableProTests/Views/Main/MaterializedViewRowWriteTests.swift
@@ -173,11 +173,11 @@ extension GlobalStateSuites {
             defer { coordinator.teardown() }
 
             coordinator.addNewRow()
-            coordinator.duplicateSelectedRow(index: 0)
+            coordinator.duplicateRow(.existing(0))
             coordinator.pasteRows()
             #expect(try rowCount(coordinator) == 2)
 
-            coordinator.deleteSelectedRows(indices: [0])
+            coordinator.deleteRows([.existing(0)])
             #expect(!coordinator.changeManager.hasChanges)
         }
 
@@ -186,7 +186,7 @@ extension GlobalStateSuites {
             let coordinator = try restoredTab(objectType: .view, isView: true)
             defer { coordinator.teardown() }
 
-            coordinator.deleteSelectedRows(indices: [0])
+            coordinator.deleteRows([.existing(0)])
             #expect(!coordinator.changeManager.hasChanges)
         }
 
@@ -200,7 +200,7 @@ extension GlobalStateSuites {
 
             coordinator.addNewRow()
             #expect(try rowCount(coordinator) == 3)
-            coordinator.duplicateSelectedRow(index: 0)
+            coordinator.duplicateRow(.existing(0))
             #expect(try rowCount(coordinator) == 4)
             coordinator.pasteRows()
             #expect(try rowCount(coordinator) == 5)
@@ -211,12 +211,18 @@ extension GlobalStateSuites {
             let coordinator = try restoredTab(objectType: .table, isView: false)
             defer { coordinator.teardown() }
 
-            coordinator.deleteSelectedRows(indices: [0])
+            coordinator.deleteRows([.existing(0)])
             #expect(coordinator.changeManager.hasChanges)
         }
 
         // MARK: - The grid's empty-space menu
 
+        private func adapter(of coordinator: MainContentCoordinator) throws -> DataTabGridAdapter {
+            let tabId = try #require(coordinator.tabManager.selectedTabId)
+            _ = coordinator.gridModel(forTab: tabId)
+            return try #require(coordinator.dataGridEntries[tabId]?.adapter)
+        }
+
         @Test("The grid's empty space offers Add Row on a table and not on a materialized view")
         func emptySpaceMenuFollowsTheGate() throws {
             let matview = try restoredTab(objectType: .materializedView, isView: false)
@@ -224,15 +230,8 @@ extension GlobalStateSuites {
             let table = try restoredTab(objectType: .table, isView: false)
             defer { table.teardown() }
 
-            let matviewDelegate = DataTabGridDelegate()
-            matviewDelegate.coordinator = matview
-            matviewDelegate.onAddRow = { matview.addNewRow() }
-            let tableDelegate = DataTabGridDelegate()
-            tableDelegate.coordinator = table
-            tableDelegate.onAddRow = { table.addNewRow() }
-
-            #expect(matviewDelegate.dataGridEmptySpaceMenu() == nil)
-            #expect(tableDelegate.dataGridEmptySpaceMenu() != nil)
+            #expect(try adapter(of: matview).gridEmptySpaceMenu() == nil)
+            #expect(try adapter(of: table).gridEmptySpaceMenu() != nil)
         }
     }
 }
diff --git a/apple/TableProTests/Views/Main/QueryTabGridLayoutScopeTests.swift b/apple/TableProTests/Views/Main/QueryTabGridLayoutScopeTests.swift
new file mode 100644
index 0000000000..e0754dfbd3
--- /dev/null
+++ b/apple/TableProTests/Views/Main/QueryTabGridLayoutScopeTests.swift
@@ -0,0 +1,87 @@
+//
+//  QueryTabGridLayoutScopeTests.swift
+//  TableProTests
+//
+//  D3: a temporary table's grid saved its widths under the permanent table of the same name.
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct QueryTabGridLayoutScopeTests {
+    private let fixture = CoordinatorFixture()
+    private let directory = FileManager.default.temporaryDirectory
+        .appendingPathComponent("QueryTabGridLayoutScopeTests-\(UUID().uuidString)", isDirectory: true)
+
+    private var tableKey: ColumnLayoutTableKey {
+        ColumnLayoutTableKey(connectionId: fixture.connection.id, databaseName: "shop", schemaName: nil, tableName: "orders")
+    }
+
+    private func openTable(isTemporary: Bool) throws -> UUID {
+        try fixture.tabManager.addTableTab(
+            tableName: "orders",
+            databaseName: "shop",
+            isTemporary: isTemporary,
+            allowsDuplicate: true
+        )
+        return try #require(fixture.tabManager.selectedTabId)
+    }
+
+    private func widen(_ store: QueryTabGridStateStore, column: String, to width: CGFloat) {
+        var layout = store.columnLayout
+        layout.columnWidths[column] = width
+        store.columnLayout = layout
+        store.flushPendingLayout()
+    }
+
+    @Test("A temporary table's grid is ephemeral and never writes the permanent table's saved layout")
+    func temporaryTableIsEphemeral() throws {
+        defer { try? FileManager.default.removeItem(at: directory) }
+        let persister = FileColumnLayoutPersister(storageDirectory: directory)
+        let temporary = try openTable(isTemporary: true)
+        let store = QueryTabGridStateStore(tabId: temporary, coordinator: fixture.coordinator, persister: persister)
+
+        widen(store, column: "id", to: 240)
+
+        #expect(store.layoutScope == .ephemeral)
+        #expect(persister.load(for: tableKey) == nil)
+        #expect(fixture.tabManager.tabs.first { $0.id == temporary }?.columnLayout.columnWidths["id"] == 240)
+    }
+
+    @Test("The permanent table of the same name keeps its own saved layout")
+    func permanentTableSavesUnderItsKey() throws {
+        defer { try? FileManager.default.removeItem(at: directory) }
+        let persister = FileColumnLayoutPersister(storageDirectory: directory)
+        let permanent = try openTable(isTemporary: false)
+        let temporary = try openTable(isTemporary: true)
+        let permanentStore = QueryTabGridStateStore(tabId: permanent, coordinator: fixture.coordinator, persister: persister)
+        let temporaryStore = QueryTabGridStateStore(tabId: temporary, coordinator: fixture.coordinator, persister: persister)
+
+        widen(permanentStore, column: "id", to: 120)
+        widen(temporaryStore, column: "id", to: 300)
+
+        #expect(permanentStore.layoutScope == .table(tableKey))
+        #expect(persister.load(for: tableKey)?.columnWidths["id"] == 120)
+        #expect(permanentStore.columnLayout.columnWidths["id"] == 120)
+    }
+
+    @Test("The model a temporary table's tab gets is ephemeral")
+    func temporaryTabModelIsEphemeral() throws {
+        let temporary = try openTable(isTemporary: true)
+        let permanent = try openTable(isTemporary: false)
+
+        #expect(fixture.coordinator.gridModel(forTab: temporary).store.layoutScope == .ephemeral)
+        #expect(fixture.coordinator.gridModel(forTab: permanent).store.layoutScope == .table(tableKey))
+    }
+
+    @Test("A query tab's grid is ephemeral")
+    func queryTabIsEphemeral() throws {
+        fixture.tabManager.addTab(initialQuery: "SELECT * FROM orders")
+        let query = try #require(fixture.tabManager.selectedTabId)
+
+        #expect(fixture.coordinator.gridModel(forTab: query).store.layoutScope == .ephemeral)
+    }
+}
diff --git a/apple/TableProTests/Views/Main/SaveCompletionTests.swift b/apple/TableProTests/Views/Main/SaveCompletionTests.swift
index 4834a90aec..c984992ae9 100644
--- a/apple/TableProTests/Views/Main/SaveCompletionTests.swift
+++ b/apple/TableProTests/Views/Main/SaveCompletionTests.swift
@@ -12,9 +12,8 @@ import Foundation
 import TableProPluginKit
 import Testing
 
-/// Enough of a driver for `assemblePendingStatements` to produce SQL. Without one the builder has
-/// no adapter, emits nothing, and `saveChanges` bails at "Could not generate SQL for changes."
-/// before it reaches the inout parameters the cases below are about.
+// Enough of a driver for `assemblePendingStatements` to produce SQL; without one `saveChanges` bails before the
+// inout parameters these cases are about.
 private final class StubSaveDriver: PluginDriverStub, @unchecked Sendable {
     var supportsSchemas: Bool { false }
     var supportsTransactions: Bool { false }
@@ -39,7 +38,7 @@ struct SaveCompletionTests {
         var conn = TestFixtures.makeConnection(type: type)
         conn.safeModeLevel = safeModeLevel
         let state = SessionStateFactory.create(connection: conn, payload: nil)
-        /// A session with a driver, so the statement builder has an adapter to route through.
+        // A session with a driver, so the statement builder has an adapter to route through.
         DatabaseManager.shared.injectSession(
             ConnectionSession(
                 connection: conn,
@@ -267,16 +266,34 @@ struct SaveCompletionTests {
             tabManager.tabs[index].tableContext.tableName = "users"
         }
 
-        coordinator.addNewRow()
-        #expect(coordinator.selectionState.indices.isEmpty)
-
-        coordinator.selectionState.indices = [0]
-        coordinator.deleteSelectedRows(indices: Set([0]))
-        #expect(coordinator.selectionState.indices == [0])
+        guard let tabId = tabManager.selectedTabId else {
+            Issue.record("expected a selected tab")
+            return
+        }
+        coordinator.setActiveTableRows(
+            TableRows.from(
+                queryRows: [[.text("1"), .text("Alice")]],
+                columns: ["id", "name"],
+                columnTypes: [.text(rawType: nil), .text(rawType: nil)],
+                hasAuthoritativeSchema: true
+            ),
+            for: tabId
+        )
+        let model = coordinator.gridModel(forTab: tabId)
 
-        coordinator.selectionState.indices = []
-        coordinator.duplicateSelectedRow(index: 0)
-        #expect(coordinator.selectionState.indices.isEmpty)
+        coordinator.addNewRow()
+        #expect(model.selection.isEmpty)
+        #expect(coordinator.tabSessionRegistry.tableRows(for: tabId).count == 1)
+
+        model.selectRows([.existing(0)])
+        coordinator.deleteRows([.existing(0)])
+        #expect(model.selectedRowIDs == [.existing(0)])
+        #expect(!coordinator.changeManager.isRowDeleted(.existing(0)))
+
+        model.clearSelection()
+        coordinator.duplicateRow(.existing(0))
+        #expect(model.selection.isEmpty)
+        #expect(coordinator.tabSessionRegistry.tableRows(for: tabId).count == 1)
     }
 
     @Test("row operations allowed by alert level")
diff --git a/apple/TableProTests/Views/Main/SeedBufferFromErrorResultTests.swift b/apple/TableProTests/Views/Main/SeedBufferFromErrorResultTests.swift
index 4461ca02bc..4003c7f62d 100644
--- a/apple/TableProTests/Views/Main/SeedBufferFromErrorResultTests.swift
+++ b/apple/TableProTests/Views/Main/SeedBufferFromErrorResultTests.swift
@@ -1,33 +1,17 @@
-// A failed Run All makes an empty error result active and seeds the row buffer from it. The grid
-// skips its whole update while a cell editor or viewer is open, and only a full replace closes
-// them, so a seed that did not take that path left the previous result's headings, row and
-// selection under the error for as long as the viewer stayed up.
-//
-// The grid is a real `DataGridView` in an `NSHostingView`, fed from the coordinator's buffer the
-// way the editor feeds it, because the early return lived in `updateNSView`.
+// A failed Run All makes an empty error result active and seeds the row buffer from it. The old grid
+// skipped its whole update while a cell editor or viewer was open, so the previous result's headings,
+// row and selection stayed under the error. The model forwards every change whatever the view is doing.
 
-import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class NoopSeedLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 @MainActor
 private final class SeedFixture {
     let coordinator: MainContentCoordinator
     let tabManager: QueryTabManager
     let tabId: UUID
-    private let delegate = DataTabGridDelegate()
-    private var window: NSWindow?
-    private var host: NSHostingView<DataGridView>?
 
     init(previous: TableRows) {
         tabManager = QueryTabManager()
@@ -41,7 +25,6 @@ private final class SeedFixture {
         tabManager.tabs.append(tab)
         tabManager.selectedTabId = tab.id
         tabId = tab.id
-        coordinator.dataTabDelegate = delegate
 
         let result = ResultSet(label: "Result 1", tableRows: previous)
         tabManager.mutate(tabId: tabId) { tab in
@@ -51,58 +34,15 @@ private final class SeedFixture {
         coordinator.setActiveTableRows(previous, for: tabId)
     }
 
-    var grid: TableViewCoordinator? {
-        delegate.tableViewCoordinator
-    }
-
-    var tableView: NSTableView? {
-        grid?.tableView
-    }
-
-    var presentedHeadings: [String] {
-        guard let tableView else { return [] }
-        return tableView.tableColumns
-            .filter { !$0.isHidden && $0.identifier != ColumnIdentitySchema.rowNumberIdentifier }
-            .map(\.headerCell.stringValue)
+    var model: DataGridModel {
+        coordinator.gridModel(forTab: tabId)
     }
 
     var tab: QueryTab? {
         tabManager.tabs.first { $0.id == tabId }
     }
 
-    func mountGrid() async {
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        let host = NSHostingView(rootView: makeGrid())
-        window.contentView = host
-        self.window = window
-        self.host = host
-        await settle()
-    }
-
-    /// A new root value, the way the editor hands the grid one on every render of the tab.
-    func render() async {
-        host?.rootView = makeGrid()
-        await settle()
-    }
-
-    func openViewer(row: Int) -> Bool {
-        guard let grid, let tableView,
-              let column = tableView.tableColumns.firstIndex(where: {
-                  !$0.isHidden && $0.identifier != ColumnIdentitySchema.rowNumberIdentifier
-              })
-        else { return false }
-        grid.showOverlayViewer(tableView: tableView, row: row, column: column, columnIndex: 0, value: "3")
-        return grid.overlayViewer?.isActive == true
-    }
-
-    /// What a failed Run All does to the tab once its statements have run: the results it produced plus
-    /// an error result, the error result active, and the buffer seeded from it.
+    // What a failed Run All does once its statements ran: the results plus an error result, the error active.
     func failRun() {
         let errorResult = ResultSet(label: "Result 2")
         errorResult.errorMessage = "Statement 2/2 failed: no such table: missing_table"
@@ -115,38 +55,8 @@ private final class SeedFixture {
     }
 
     func close() {
-        grid?.overlayViewer?.dismiss()
-        window?.orderOut(nil)
         coordinator.teardown()
     }
-
-    private func makeGrid() -> DataGridView {
-        let tabId = tabId
-        return DataGridView(
-            tableRowsProvider: { [coordinator] in
-                coordinator.tabSessionRegistry.existingTableRows(for: tabId) ?? TableRows()
-            },
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: false,
-            configuration: DataGridConfiguration(tabType: .query),
-            delegate: delegate,
-            layoutPersister: NoopSeedLayoutPersister(),
-            selectedRowIndices: .constant([]),
-            sortState: .constant(SortState()),
-            columnLayout: .constant(ColumnLayoutState())
-        )
-    }
-
-    /// Each pass lays out, then waits for one main-queue turn: SwiftUI applies a new root on a later
-    /// run-loop turn, and a main-actor task started by the update runs before the turn comes back.
-    private func settle() async {
-        for _ in 0 ..< 10 {
-            host?.layoutSubtreeIfNeeded()
-            await withCheckedContinuation { continuation in
-                DispatchQueue.main.async { continuation.resume() }
-            }
-        }
-    }
 }
 
 @MainActor
@@ -157,34 +67,37 @@ struct SeedBufferFromErrorResultTests {
         columnTypes: [.text(rawType: nil)]
     )
 
-    @Test("a failed run over an open cell viewer closes it and takes down the previous headings")
-    func failureOverAnOpenViewerReconcilesTheGrid() async throws {
+    @Test("a failed run under an open cell editor still takes down the previous columns and rows")
+    func failureUnderAnOpenEditorReconcilesTheGrid() throws {
         let fixture = SeedFixture(previous: Self.previous)
         defer { fixture.close() }
-        await fixture.mountGrid()
-        try #require(fixture.presentedHeadings == ["third_col"])
-        try #require(fixture.openViewer(row: 0))
+        let model = fixture.model
+        let mount = DataTabGridMountStub()
+        model.attach(mount)
+        mount.isEditing = true
+        try #require(model.columns.orderedNames == ["third_col"])
 
         fixture.failRun()
-        await fixture.render()
 
-        #expect(fixture.grid?.overlayViewer?.isActive != true)
-        #expect(fixture.presentedHeadings.isEmpty, "got \(fixture.presentedHeadings)")
-        #expect(fixture.tableView?.numberOfRows == 0)
+        #expect(model.columns.isEmpty)
+        #expect(model.rowCount == 0)
+        #expect(mount.changes.contains(.columnsChanged))
+        #expect(mount.changes.last == .reload)
+        withExtendedLifetime(mount) {}
     }
 
     @Test("a failed run drops the row selection the previous result's rows made")
     func failureClearsThePreviousSelection() throws {
         let fixture = SeedFixture(previous: Self.previous)
         defer { fixture.close() }
-        fixture.tabManager.mutate(tabId: fixture.tabId) { tab in
-            tab.selectedRowIndices = [0]
-        }
-        try #require(fixture.tab?.selectedRowIndices == [0])
+        let model = fixture.model
+        model.selectRows([.existing(0)])
+        try #require(model.selectedRowIDs == [.existing(0)])
 
         fixture.failRun()
 
-        #expect(fixture.tab?.selectedRowIndices.isEmpty == true)
+        #expect(model.selection.isEmpty)
+        #expect(fixture.tab?.selectionSnapshot.isEmpty == true)
         #expect(fixture.coordinator.tabSessionRegistry.tableRows(for: fixture.tabId).columns.isEmpty)
     }
 }
diff --git a/apple/TableProTests/Views/Main/SidebarSaveClearedValueTests.swift b/apple/TableProTests/Views/Main/SidebarSaveClearedValueTests.swift
index ddef0a2b09..a722270248 100644
--- a/apple/TableProTests/Views/Main/SidebarSaveClearedValueTests.swift
+++ b/apple/TableProTests/Views/Main/SidebarSaveClearedValueTests.swift
@@ -38,7 +38,7 @@ struct SidebarSaveClearedValueTests {
             databaseType: .mysql,
             generatedColumns: []
         )
-        coordinator.selectionState.indices = [0]
+        coordinator.gridModel(forTab: tab.id).selectRows([.existing(0)])
         return coordinator
     }
 
diff --git a/apple/TableProTests/Views/Main/SidebarSaveCoverageTests.swift b/apple/TableProTests/Views/Main/SidebarSaveCoverageTests.swift
index b4ac0dbfec..b9d64c46f0 100644
--- a/apple/TableProTests/Views/Main/SidebarSaveCoverageTests.swift
+++ b/apple/TableProTests/Views/Main/SidebarSaveCoverageTests.swift
@@ -41,13 +41,18 @@ struct SidebarSaveCoverageTests {
         return coordinator
     }
 
+    private func selectBothRows(in coordinator: MainContentCoordinator) throws {
+        let tabId = try #require(coordinator.tabManager.selectedTabId)
+        coordinator.gridModel(forTab: tabId).selectRows([.existing(0), .existing(1)])
+    }
+
     @Test("An inspector save across rows the driver cannot all write throws instead of writing some")
-    func inspectorSaveRefusesAPartialWrite() {
+    func inspectorSaveRefusesAPartialWrite() throws {
         let firstRowOnly = RowWriteStubDriver { changes, _, _, _ in
             changes.prefix(1).map { PluginRowWrite(statement: "updateOne(\($0.rowIndex))", rowIndices: [$0.rowIndex]) }
         }
         let coordinator = makeCoordinator(driver: firstRowOnly)
-        coordinator.selectionState.indices = [0, 1]
+        try selectBothRows(in: coordinator)
 
         #expect(throws: DataWriteError.changesNotWritable(table: "items", unwritten: UnwrittenRowCounts(updates: 1))) {
             _ = try coordinator.sidebarEditStatements(
@@ -62,7 +67,7 @@ struct SidebarSaveCoverageTests {
             changes.map { PluginRowWrite(statement: "updateOne(\($0.rowIndex))", rowIndices: [$0.rowIndex]) }
         }
         let coordinator = makeCoordinator(driver: everyRow)
-        coordinator.selectionState.indices = [0, 1]
+        try selectBothRows(in: coordinator)
 
         let statements = try coordinator.sidebarEditStatements(
             editedFields: [InspectorFieldEdit(columnIndex: 1, columnName: "name", newValue: "z")]
diff --git a/apple/TableProTests/Views/Main/SourceFileDiskChangeHandlingTests.swift b/apple/TableProTests/Views/Main/SourceFileDiskChangeHandlingTests.swift
index db5af9fce7..38e063510a 100644
--- a/apple/TableProTests/Views/Main/SourceFileDiskChangeHandlingTests.swift
+++ b/apple/TableProTests/Views/Main/SourceFileDiskChangeHandlingTests.swift
@@ -29,7 +29,6 @@ struct SourceFileDiskChangeHandlingTests {
         let actions = MainContentCommandActions(
             coordinator: coordinator,
             connection: connection,
-            selectionState: coordinator.selectionState,
             selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
             pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
             pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
diff --git a/apple/TableProTests/Views/Main/SourceFileEncodingSaveTests.swift b/apple/TableProTests/Views/Main/SourceFileEncodingSaveTests.swift
index 2f5ecc52ec..9eca6237ef 100644
--- a/apple/TableProTests/Views/Main/SourceFileEncodingSaveTests.swift
+++ b/apple/TableProTests/Views/Main/SourceFileEncodingSaveTests.swift
@@ -36,7 +36,6 @@ struct SourceFileEncodingSaveTests {
         let actions = MainContentCommandActions(
             coordinator: coordinator,
             connection: connection,
-            selectionState: coordinator.selectionState,
             selectedTables: Binding(get: { selectedTables }, set: { selectedTables = $0 }),
             pendingTruncates: Binding(get: { pendingTruncates }, set: { pendingTruncates = $0 }),
             pendingDeletes: Binding(get: { pendingDeletes }, set: { pendingDeletes = $0 }),
diff --git a/apple/TableProTests/Views/Main/TableInfoTaskKeyTests.swift b/apple/TableProTests/Views/Main/TableInfoTaskKeyTests.swift
index a28b08b98f..696e4d4205 100644
--- a/apple/TableProTests/Views/Main/TableInfoTaskKeyTests.swift
+++ b/apple/TableProTests/Views/Main/TableInfoTaskKeyTests.swift
@@ -8,9 +8,7 @@ import Testing
 
 @testable import TablePro
 
-/// The Table Info load runs again only when this key changes, and it waits for the tab's rows. A key
-/// that did not move when the rows arrived left a table tab that had just opened with no numbers
-/// until the inspector left the screen and came back.
+// The Table Info load runs again only when this key changes, and it waits for the tab's rows.
 @MainActor
 struct TableInfoTaskKeyTests {
     private let table = TableTabIdentity(table: "orders", database: "shop", schema: nil)
@@ -35,8 +33,7 @@ struct TableInfoTaskKeyTests {
         #expect(key(tab) != opened)
     }
 
-    /// A page, a sort or a filter runs the query again and changes none of the numbers. A read per
-    /// run would count up to 100,001 rows on SQLite and run `collStats` on MongoDB on every page.
+    // A read per run would count up to 100,001 rows on SQLite and run `collStats` on MongoDB on every page.
     @Test("A page, a sort or a filter does not read the statistics again")
     func rerunKeepsTheKey() {
         var tab = tableTab(executedAt: Date(timeIntervalSince1970: 1))
@@ -59,7 +56,7 @@ struct TableInfoTaskKeyTests {
         var tab = tableTab(executedAt: Date())
         let before = key(tab)
 
-        tab.selectedRowIndices = [3]
+        tab.selectionSnapshot = GridSelectionSnapshot(rowIDs: [.existing(3)], rectangles: [], activeCell: nil, anchor: nil)
         tab.schemaVersion += 1
 
         #expect(key(tab) == before)
diff --git a/apple/TableProTests/Views/Main/ValueFilterEditedRowTests.swift b/apple/TableProTests/Views/Main/ValueFilterEditedRowTests.swift
index 009647d0ee..c47bc60459 100644
--- a/apple/TableProTests/Views/Main/ValueFilterEditedRowTests.swift
+++ b/apple/TableProTests/Views/Main/ValueFilterEditedRowTests.swift
@@ -3,26 +3,27 @@
 //  TableProTests
 //
 
-import AppKit
 import Foundation
-import SwiftUI
 import TableProPluginKit
 import Testing
 
 @testable import TablePro
 
-@MainActor
-private final class EditedRowLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 @MainActor
 struct ValueFilterEditedRowTests {
+    @MainActor
     private struct Fixture {
         let coordinator: MainContentCoordinator
         let tabId: UUID
+
+        var model: DataGridModel {
+            coordinator.gridModel(forTab: tabId)
+        }
+
+        // The primary key of the row the grid shows at a position, which is what a write names.
+        func shownKey(at displayRow: Int) -> String? {
+            model.row(at: displayRow)?.values[0].asText
+        }
     }
 
     private func makeFixture() -> Fixture {
@@ -58,8 +59,9 @@ struct ValueFilterEditedRowTests {
             databaseType: .mysql,
             generatedColumns: []
         )
-        coordinator.setValueFilter(nameFilter(["Bob", "Carol"]), forTab: tab.id)
-        return Fixture(coordinator: coordinator, tabId: tab.id)
+        let fixture = Fixture(coordinator: coordinator, tabId: tab.id)
+        fixture.model.setValueFilter(nameFilter(["Bob", "Carol"]))
+        return fixture
     }
 
     private func nameFilter(_ names: Set<String>) -> GridValueFilterState {
@@ -72,56 +74,37 @@ struct ValueFilterEditedRowTests {
         return state
     }
 
-    private func mountGrid(on fixture: Fixture) -> TableViewCoordinator {
-        let coordinator = fixture.coordinator
-        let tabId = fixture.tabId
-        let delegate = DataTabGridDelegate()
-        let grid = TableViewCoordinator(
-            changeManager: AnyChangeManager(coordinator.changeManager),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: delegate,
-            layoutPersister: EditedRowLayoutPersister()
-        )
-        delegate.dataGridAttach(tableViewCoordinator: grid)
-        coordinator.dataTabDelegate = delegate
-        grid.tableRowsProvider = { [weak coordinator] in
-            coordinator?.tabSessionRegistry.existingTableRows(for: tabId) ?? TableRows()
-        }
-        grid.tableRowsMutator = { [weak coordinator] mutate in
-            coordinator?.mutateActiveTableRows(for: tabId) { rows in mutate(&rows) } ?? .none
-        }
-        grid.valueFilterBinding = Binding(
-            get: { coordinator.tabManager.tabs.first { $0.id == tabId }?.valueFilter ?? GridValueFilterState() },
-            set: { coordinator.setValueFilter($0, forTab: tabId) }
-        )
-        grid.displayOrderProvider = { [weak coordinator] in
-            coordinator?.displayIDs(forTab: tabId)
-        }
-        grid.adoptValueFilter(coordinator.tabManager.tabs.first { $0.id == tabId }?.valueFilter ?? GridValueFilterState())
-        grid.recomputeValueFilteredIDs()
-        grid.updateCache()
-        return grid
-    }
-
     private func renameBobInStorage(_ fixture: Fixture, to name: String) {
         fixture.coordinator.mutateActiveTableRows(for: fixture.tabId) { rows in
             rows.edit(row: 1, column: 1, value: .text(name))
         }
     }
 
+    // An inline edit the way the grid commits one: through the model, by row and column identity.
+    private func editBobInTheGrid(_ fixture: Fixture, to name: String) throws {
+        let model = fixture.model
+        model.configuration.isEditable = true
+        let position = try #require(model.columns.displayPosition(ofDataIndex: 1))
+        let column = try #require(model.columns.column(at: position))
+        let committed = model.commit(
+            [DataGridCellEdit(rowID: .existing(1), columnID: column.id, value: .value(.text(name), isExpression: false))],
+            actionName: "Edit"
+        )
+        try #require(committed)
+    }
+
     private func stringParameters(_ statement: ParameterizedStatement) -> [String] {
         statement.parameters.compactMap { $0 as? String }
     }
 
-    @Test("an edit that takes a row out of the filter leaves it at its display position")
+    @Test("an edit that takes a row out of the filter keeps it in the display order")
     func editKeepsTheRowInTheDisplayOrder() {
         let fixture = makeFixture()
-        #expect(fixture.coordinator.activeGridDisplayIDs == [.existing(1), .existing(2)])
+        #expect(fixture.model.displayedRowIDs == [.existing(1), .existing(2)])
 
         renameBobInStorage(fixture, to: "Zed")
 
-        #expect(fixture.coordinator.activeGridDisplayIDs == [.existing(1), .existing(2)])
+        #expect(fixture.model.displayedRowIDs == [.existing(1), .existing(2)])
     }
 
     @Test("the order is resolved when the filter is set, not when a reader first asks for it")
@@ -129,54 +112,44 @@ struct ValueFilterEditedRowTests {
         let fixture = makeFixture()
         renameBobInStorage(fixture, to: "Zed")
 
-        #expect(fixture.coordinator.activeGridDisplayIDs == [.existing(1), .existing(2)])
-    }
-
-    @Test("the mounted grid and the owner agree on the display order after an inline edit")
-    func gridAndOwnerAgreeAfterAnInlineEdit() {
-        let fixture = makeFixture()
-        let grid = mountGrid(on: fixture)
-
-        grid.recordCellEdit(row: 0, columnIndex: 1, newValue: .text("Zed"))
-        grid.recomputeValueFilteredIDs()
-
-        #expect(grid.displayIDs == [.existing(1), .existing(2)])
-        #expect(grid.displayIDs == fixture.coordinator.activeGridDisplayIDs)
-        #expect(grid.displayRow(at: 0)?.values[1] == .text("Zed"))
+        #expect(fixture.model.displayedRowIDs == [.existing(1), .existing(2)])
     }
 
-    @Test("a grid with an owner shows the owner's order rather than resolving its own")
-    func gridTakesTheOwnersOrder() {
+    @Test("the grid and the window read one display order after an inline edit")
+    func gridAndOwnerAgreeAfterAnInlineEdit() throws {
         let fixture = makeFixture()
-        let grid = mountGrid(on: fixture)
-        grid.displayOrderProvider = { [.existing(2)] }
 
-        grid.recomputeValueFilteredIDs()
+        try editBobInTheGrid(fixture, to: "Zed")
 
-        #expect(grid.displayIDs == [.existing(2)])
+        #expect(fixture.coordinator.changeManager.isCellModified(rowID: .existing(1), columnIndex: 1))
+        #expect(fixture.coordinator.tabSessionRegistry.tableRows(for: fixture.tabId).rows[1].values[1] == .text("Zed"))
+        #expect(fixture.coordinator.displayIDs(forTab: fixture.tabId) == fixture.model.displayedRowIDs)
     }
 
     @Test("deleting the row the grid shows after an edit deletes that row and no other")
     func deleteAfterAnEditTargetsTheShownRow() throws {
         let fixture = makeFixture()
-        let grid = mountGrid(on: fixture)
-        grid.recordCellEdit(row: 0, columnIndex: 1, newValue: .text("Zed"))
+        try editBobInTheGrid(fixture, to: "Zed")
+        let shown = try #require(fixture.model.rowID(at: 0))
+        let shownKey = try #require(fixture.shownKey(at: 0))
 
-        fixture.coordinator.deleteSelectedRows(indices: [0])
+        fixture.coordinator.deleteRows([shown])
 
         let deletes = try fixture.coordinator.changeManager.generateSQL()
             .filter { $0.sql.hasPrefix("DELETE") }
         #expect(deletes.count == 1)
         let parameters = deletes.first.map(stringParameters) ?? []
-        #expect(parameters.contains("2"))
-        #expect(!parameters.contains("3"))
+        let otherKeys = Set(["1", "2", "3"]).subtracting([shownKey])
+        #expect(parameters.contains(shownKey))
+        #expect(otherKeys.isDisjoint(with: parameters))
     }
 
     @Test("a row inspector save after an edit updates the row the grid shows")
     func sidebarSaveAfterAnEditTargetsTheShownRow() throws {
         let fixture = makeFixture()
         renameBobInStorage(fixture, to: "Zed")
-        fixture.coordinator.selectionState.indices = [0]
+        fixture.model.setSelection(GridSelectionReducer.single(GridCoord(row: 0, displayColumn: 0)))
+        let shownKey = try #require(fixture.shownKey(at: 0))
 
         let statements = try fixture.coordinator.sidebarEditStatements(
             editedFields: [InspectorFieldEdit(columnIndex: 1, columnName: "name", newValue: "Yan")]
@@ -185,11 +158,12 @@ struct ValueFilterEditedRowTests {
         #expect(statements.count == 1)
         let parameters = statements.first.map(stringParameters) ?? []
         #expect(parameters.contains("Yan"))
-        #expect(parameters.contains("2"))
-        #expect(!parameters.contains("3"))
+        let otherKeys = Set(["1", "2", "3"]).subtracting([shownKey])
+        #expect(parameters.contains(shownKey))
+        #expect(otherKeys.isDisjoint(with: parameters))
     }
 
-    @Test("adding a row re-resolves the order, so the edited row leaves with the next row-set change")
+    @Test("adding a row re-resolves the order over the edited values")
     func addingARowReResolvesTheOrder() {
         let fixture = makeFixture()
         renameBobInStorage(fixture, to: "Zed")
@@ -203,7 +177,7 @@ struct ValueFilterEditedRowTests {
             return
         }
         #expect(insertedID.isInserted)
-        #expect(fixture.coordinator.activeGridDisplayIDs == [RowID.existing(2), insertedID])
+        #expect(fixture.model.displayedRowIDs == [RowID.existing(2), insertedID])
     }
 
     @Test("changing the filter re-resolves the order over the edited values")
@@ -211,8 +185,8 @@ struct ValueFilterEditedRowTests {
         let fixture = makeFixture()
         renameBobInStorage(fixture, to: "Zed")
 
-        fixture.coordinator.setValueFilter(nameFilter(["Zed"]), forTab: fixture.tabId)
+        fixture.model.setValueFilter(nameFilter(["Zed"]))
 
-        #expect(fixture.coordinator.activeGridDisplayIDs == [.existing(1)])
+        #expect(fixture.model.displayedRowIDs == [.existing(1)])
     }
 }
diff --git a/apple/TableProTests/Views/Main/ValueFilterReloadTests.swift b/apple/TableProTests/Views/Main/ValueFilterReloadTests.swift
index 20f70f6d88..a94f41c9c5 100644
--- a/apple/TableProTests/Views/Main/ValueFilterReloadTests.swift
+++ b/apple/TableProTests/Views/Main/ValueFilterReloadTests.swift
@@ -3,21 +3,12 @@
 //  TableProTests
 //
 
-import AppKit
 import Foundation
-import SwiftUI
 import TableProPluginKit
 import Testing
 
 @testable import TablePro
 
-@MainActor
-private final class ReloadLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 @MainActor
 struct ValueFilterReloadTests {
     private static func rows(_ values: [[String]], columns: [String] = ["id", "name"]) -> TableRows {
@@ -46,7 +37,7 @@ struct ValueFilterReloadTests {
     private func filterName(_ names: Set<String>, at column: Int = 1, in coordinator: MainContentCoordinator, tabId: UUID) {
         var state = GridValueFilterState()
         state.set(ColumnValueFilter(selectedValues: names, includesNull: false), columnName: "name", forColumn: column)
-        coordinator.setValueFilter(state, forTab: tabId)
+        coordinator.gridModel(forTab: tabId).setValueFilter(state)
     }
 
     private func valueFilter(_ coordinator: MainContentCoordinator, _ tabId: UUID) -> GridValueFilterState? {
@@ -99,29 +90,12 @@ struct ValueFilterReloadTests {
         #expect(coordinator.displayIDs(forTab: tabId) == [.existing(1)])
     }
 
-    @Test("A mounted grid takes the moved filter, so its own prune cannot write the old copy back")
-    func mountedGridAdoptsTheCarriedFilter() {
+    @Test("The grid model reads the moved filter, so nothing writes the old copy back")
+    func modelAdoptsTheCarriedFilter() {
         let (coordinator, tabId) = makeCoordinator()
         defer { coordinator.teardown() }
-        let delegate = DataTabGridDelegate()
-        let grid = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: delegate,
-            layoutPersister: ReloadLayoutPersister()
-        )
-        delegate.dataGridAttach(tableViewCoordinator: grid)
-        coordinator.dataTabDelegate = delegate
-        grid.tableRowsProvider = { [weak coordinator] in
-            coordinator?.tabSessionRegistry.tableRows(for: tabId) ?? TableRows()
-        }
-        grid.valueFilterBinding = Binding(
-            get: { coordinator.tabManager.tabs.first { $0.id == tabId }?.valueFilter ?? GridValueFilterState() },
-            set: { coordinator.setValueFilter($0, forTab: tabId) }
-        )
         filterName(["Bob"], in: coordinator, tabId: tabId)
-        grid.adoptValueFilter(valueFilter(coordinator, tabId) ?? GridValueFilterState())
+        let model = coordinator.gridModel(forTab: tabId)
 
         coordinator.setActiveTableRows(
             Self.rows([["1", "a@x", "Alice"], ["2", "b@x", "Bob"]], columns: ["id", "email", "name"]),
@@ -130,8 +104,9 @@ struct ValueFilterReloadTests {
         )
 
         #expect(valueFilter(coordinator, tabId)?.isActive(column: 2) == true)
-        #expect(grid.valueFilterState == valueFilter(coordinator, tabId))
-        withExtendedLifetime((delegate, grid)) {}
+        #expect(valueFilter(coordinator, tabId)?.isActive(column: 1) == false)
+        #expect(model.store.valueFilter == valueFilter(coordinator, tabId))
+        #expect(model.displayedRowIDs == [.existing(1)])
     }
 
     @Test("A new source still clears the value filter")
diff --git a/apple/TableProTests/Views/QueryPlan/QueryPlanThemeTests.swift b/apple/TableProTests/Views/QueryPlan/QueryPlanThemeTests.swift
index bdb03909d7..0c28384502 100644
--- a/apple/TableProTests/Views/QueryPlan/QueryPlanThemeTests.swift
+++ b/apple/TableProTests/Views/QueryPlan/QueryPlanThemeTests.swift
@@ -1,7 +1,3 @@
-// The plan outline is a records table whose rows stay AppKit's own until a theme draws them, its
-// detail pane and the diagram's steps sit on the grid's slots, and an export renders the scheme and
-// the backdrop the canvas shows.
-
 import AppKit
 import SwiftUI
 @testable import TablePro
@@ -56,8 +52,7 @@ struct QueryPlanThemeTests {
         let coordinator: QueryPlanOutlineCoordinator
     }
 
-    /// Never ordered front and never closed: `close()` on a test window over-releases it. Mounted
-    /// without spinning the run loop, so no other main-actor work runs under a theme a case adopted.
+    // Mounted without spinning the run loop, so no other main-actor work runs under a theme a case adopted.
     private func mountOutline() throws -> MountedOutline {
         let window = NSWindow(
             contentRect: NSRect(x: 0, y: 0, width: 480, height: 240),
@@ -102,7 +97,7 @@ struct QueryPlanThemeTests {
         }
     }
 
-    @Test("A theme's selection swaps in themed rows, tells the selected row's cells, and a default theme swaps back")
+    @Test("A theme's background swaps in themed rows that keep AppKit's selection, and a default theme swaps back")
     func outlineRowClassFollowsTheTheme() throws {
         try Fixture.preservingEngine {
             try Fixture.adopt([:], appearance: .light)
@@ -114,14 +109,12 @@ struct QueryPlanThemeTests {
             var selections: [UUID?] = []
             mounted.coordinator.onSelect = { selections.append($0) }
 
-            try Fixture.adopt([.gridSelection: "#2A6F4E", .gridSelectionText: "#FFFFFF"], appearance: .light)
+            try Fixture.adopt([.gridBackground: "#2A6F4E"], appearance: .light)
             let themed = try #require(mounted.outline.rowView(atRow: 0, makeIfNecessary: true) as? ThemeTableRowView)
             #expect(themed.chrome === chrome)
+            #expect(chrome.selectionColor(emphasized: true) == nil)
             #expect(mounted.outline.selectedRowIndexes == IndexSet(integer: 0))
             #expect(mounted.outline.isItemExpanded(try #require(mounted.coordinator.root)))
-            themed.isEmphasized = true
-            let cell = try #require(mounted.outline.view(atColumn: 0, row: 0, makeIfNecessary: true) as? ThemeTableChrome.HostingCell)
-            #expect(cell.isOnThemedSelection)
 
             try Fixture.adopt([:], appearance: .light)
             let native = try #require(mounted.outline.rowView(atRow: 0, makeIfNecessary: true))
diff --git a/apple/TableProTests/Views/Results/CellEditorMovementTargetTests.swift b/apple/TableProTests/Views/Results/CellEditorMovementTargetTests.swift
deleted file mode 100644
index fc50c5e8da..0000000000
--- a/apple/TableProTests/Views/Results/CellEditorMovementTargetTests.swift
+++ /dev/null
@@ -1,205 +0,0 @@
-//
-//  CellEditorMovementTargetTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class StubLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// Where the inline editor goes when it is left with Tab, Shift+Tab, Up or Down, and what moving
-/// the cell cursor there costs. Tab wraps across rows because that is what Tab means; Up and Down
-/// hold the column and stop at the ends (#2569).
-@MainActor
-struct CellEditorMovementTargetTests {
-    private struct Grid {
-        let coordinator: TableViewCoordinator
-        let tableView: KeyHandlingTableView
-        let dataColumns: [Int]
-    }
-
-    private func makeGrid(rowCount: Int, columnNames: [String]) -> Grid {
-        let tableView = KeyHandlingTableView()
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.style = .plain
-        let rowNumberColumn = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        rowNumberColumn.width = 40
-        tableView.addTableColumn(rowNumberColumn)
-
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: (0..<rowCount).map { row in
-                columnNames.indices.map { PluginCellValue.text("r\(row)c\($0)") }
-            },
-            columns: columnNames,
-            columnTypes: columnNames.map { _ in ColumnType.text(rawType: "TEXT") }
-        )
-
-        coordinator.tableView = tableView
-        tableView.coordinator = coordinator
-        coordinator.tableRowsProvider = { rows }
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: rows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        tableView.dataSource = coordinator
-        coordinator.updateCache()
-        tableView.reloadData()
-
-        let dataColumns = tableView.tableColumns.indices.filter {
-            coordinator.presentsColumn(atTableColumnIndex: $0)
-        }
-        return Grid(coordinator: coordinator, tableView: tableView, dataColumns: dataColumns)
-    }
-
-    private func target(
-        _ grid: Grid,
-        row: Int,
-        column: Int,
-        movement: CellEditorMovement
-    ) -> (row: Int, column: Int)? {
-        grid.coordinator.movementTarget(
-            from: (row: row, column: column),
-            movement: movement,
-            in: grid.tableView
-        )
-    }
-
-    @Test("The grid harness presents every data column")
-    func harnessPresentsEveryDataColumn() {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-
-        #expect(grid.dataColumns.count == 2)
-        #expect(grid.tableView.numberOfRows == 3)
-    }
-
-    @Test("Down steps one row and holds the column")
-    func downStepsOneRowAndHoldsTheColumn() throws {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-        let column = try #require(grid.dataColumns.last)
-
-        let moved = try #require(target(grid, row: 0, column: column, movement: .down))
-
-        #expect(moved.row == 1)
-        #expect(moved.column == column)
-    }
-
-    @Test("Up steps one row and holds the column")
-    func upStepsOneRowAndHoldsTheColumn() throws {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-        let column = try #require(grid.dataColumns.first)
-
-        let moved = try #require(target(grid, row: 2, column: column, movement: .up))
-
-        #expect(moved.row == 1)
-        #expect(moved.column == column)
-    }
-
-    @Test("Down on the last row does not wrap")
-    func downOnTheLastRowDoesNotWrap() throws {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-        let column = try #require(grid.dataColumns.first)
-
-        let past = target(grid, row: 2, column: column, movement: .down)
-        #expect(past == nil)
-    }
-
-    @Test("Up on the first row does not wrap")
-    func upOnTheFirstRowDoesNotWrap() throws {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-        let column = try #require(grid.dataColumns.first)
-
-        let past = target(grid, row: 0, column: column, movement: .up)
-        #expect(past == nil)
-    }
-
-    @Test("Tab walks the row and wraps onto the next row's first column")
-    func tabWalksTheRowAndWraps() throws {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-        let first = try #require(grid.dataColumns.first)
-        let last = try #require(grid.dataColumns.last)
-
-        let within = try #require(target(grid, row: 0, column: first, movement: .tab))
-        #expect(within.row == 0)
-        #expect(within.column == last)
-
-        let wrapped = try #require(target(grid, row: 0, column: last, movement: .tab))
-        #expect(wrapped.row == 1)
-        #expect(wrapped.column == first)
-
-        let past = target(grid, row: 2, column: last, movement: .tab)
-        #expect(past == nil)
-    }
-
-    @Test("Shift+Tab walks back and wraps onto the previous row's last column")
-    func backtabWalksBackAndWraps() throws {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-        let first = try #require(grid.dataColumns.first)
-        let last = try #require(grid.dataColumns.last)
-
-        let within = try #require(target(grid, row: 1, column: last, movement: .backtab))
-        #expect(within.row == 1)
-        #expect(within.column == first)
-
-        let wrapped = try #require(target(grid, row: 1, column: first, movement: .backtab))
-        #expect(wrapped.row == 0)
-        #expect(wrapped.column == last)
-
-        let past = target(grid, row: 0, column: first, movement: .backtab)
-        #expect(past == nil)
-    }
-
-    /// A vertical step keeps whatever position it was given, so the row-number column and the
-    /// pool's spacers never come into it the way they do for Tab.
-    @Test("A vertical step never resolves a column of its own")
-    func verticalStepNeverResolvesAColumn() throws {
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name", "email"])
-        let middle = grid.dataColumns[1]
-
-        let moved = try #require(target(grid, row: 1, column: middle, movement: .down))
-
-        #expect(moved.column == middle)
-    }
-
-    /// Reaching for a cell's accessibility element is what marks the grid active, and an active
-    /// grid mounts a view per visible cell. Moving the cursor asked for one every time, so a single
-    /// Tab press bought every grid in the session the cost `#2381` removed.
-    @Test("Moving the cell cursor leaves the accessibility layout alone")
-    func movingTheCursorLeavesAccessibilityAlone() throws {
-        let wasActive = DataGridAccessibility.isActive
-        DataGridAccessibility.isActive = false
-        defer { DataGridAccessibility.isActive = wasActive }
-        let grid = makeGrid(rowCount: 3, columnNames: ["id", "name"])
-        let column = try #require(grid.dataColumns.first)
-
-        grid.tableView.focusCell(row: 1, column: column)
-
-        #expect(!DataGridAccessibility.isActive)
-        #expect(grid.tableView.focusedRow == 1)
-        #expect(grid.tableView.focusedColumn == column)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/CellInteractionResolverTests.swift b/apple/TableProTests/Views/Results/CellInteractionResolverTests.swift
index b3f7e7395b..2629294ba0 100644
--- a/apple/TableProTests/Views/Results/CellInteractionResolverTests.swift
+++ b/apple/TableProTests/Views/Results/CellInteractionResolverTests.swift
@@ -22,22 +22,22 @@ struct CellInteractionResolverReadOnlyTests {
         #expect(resolver.resolve(context) == .blocked)
     }
 
-    @Test("read-only plain text returns viewInline with value")
+    @Test("read-only plain text opens the text viewer with its value")
     func readOnlyPlainTextReturnsViewInline() {
         let context = ContextFactory.make(value: "hello", isTableEditable: false)
-        #expect(resolver.resolve(context) == .viewInline(value: "hello"))
+        #expect(resolver.resolve(context) == .viewText(value: "hello"))
     }
 
-    @Test("read-only nil value returns viewInline with NULL placeholder")
+    @Test("read-only nil value opens the text viewer on the NULL placeholder")
     func readOnlyNilValueReturnsViewInlineWithNull() {
         let context = ContextFactory.make(value: nil, isTableEditable: false)
-        #expect(resolver.resolve(context) == .viewInline(value: "NULL"))
+        #expect(resolver.resolve(context) == .viewText(value: "NULL"))
     }
 
-    @Test("read-only multiline text returns viewInline")
+    @Test("read-only multiline text opens the text viewer")
     func readOnlyMultilineReturnsViewInline() {
         let context = ContextFactory.make(value: "line1\nline2", isTableEditable: false)
-        #expect(resolver.resolve(context) == .viewInline(value: "line1\nline2"))
+        #expect(resolver.resolve(context) == .viewText(value: "line1\nline2"))
     }
 
     @Test("read-only BLOB column returns viewBlob")
@@ -49,19 +49,19 @@ struct CellInteractionResolverReadOnlyTests {
     @Test("read-only JSON column shows its value inline; the chevron opens the JSON viewer")
     func readOnlyJsonColumnShowsInline() {
         let context = ContextFactory.make(value: #"{"k":1}"#, columnType: .json(rawType: "JSON"), isTableEditable: false)
-        #expect(resolver.resolve(context) == .viewInline(value: #"{"k":1}"#))
+        #expect(resolver.resolve(context) == .viewText(value: #"{"k":1}"#))
     }
 
     @Test("immutable column on editable table follows the read-only inline path")
     func immutableColumnFollowsReadOnlyPath() {
         let context = ContextFactory.make(value: "id-123", isTableEditable: true, isImmutableColumn: true)
-        #expect(resolver.resolve(context) == .viewInline(value: "id-123"))
+        #expect(resolver.resolve(context) == .viewText(value: "id-123"))
     }
 
     @Test("JSON-looking text is not content-routed; it shows inline")
     func jsonLikeTextShowsInline() {
         let context = ContextFactory.make(value: #"{"k":1}"#, columnType: nil, isTableEditable: false)
-        #expect(resolver.resolve(context) == .viewInline(value: #"{"k":1}"#))
+        #expect(resolver.resolve(context) == .viewText(value: #"{"k":1}"#))
     }
 
     @Test("read-only override .json shows the JSON viewer")
@@ -96,10 +96,20 @@ struct CellInteractionResolverEditableTests {
         #expect(resolver.resolve(context) == .editInline(value: "hello"))
     }
 
-    @Test("editable plain multiline returns editOverlay")
-    func editablePlainMultilineReturnsEditOverlay() {
+    @Test("a single-line value past the inline limit edits in the text popover, one at the limit in the cell")
+    func longValueEditsInPopover() {
+        let limit = CellInteractionResolver.inlineLengthLimit
+        let atLimit = String(repeating: "a", count: limit)
+        let pastLimit = atLimit + "a"
+
+        #expect(resolver.resolve(ContextFactory.make(value: atLimit, isTableEditable: true)) == .editInline(value: atLimit))
+        #expect(resolver.resolve(ContextFactory.make(value: pastLimit, isTableEditable: true)) == .editText(value: pastLimit))
+    }
+
+    @Test("editable plain multiline edits in the text popover")
+    func editablePlainMultilineEditsInPopover() {
         let context = ContextFactory.make(value: "line1\nline2", isTableEditable: true)
-        #expect(resolver.resolve(context) == .editOverlay(value: "line1\nline2"))
+        #expect(resolver.resolve(context) == .editText(value: "line1\nline2"))
     }
 
     @Test("editable JSON column edits inline; the chevron opens the JSON editor")
@@ -108,11 +118,11 @@ struct CellInteractionResolverEditableTests {
         #expect(resolver.resolve(context) == .editInline(value: #"{"k":1}"#))
     }
 
-    @Test("editable multiline JSON column opens the inline overlay editor")
-    func editableMultilineJsonColumnEditsOverlay() {
+    @Test("editable multiline JSON column edits in the text popover")
+    func editableMultilineJsonColumnEditsInPopover() {
         let value = "{\n\"k\": 1\n}"
         let context = ContextFactory.make(value: value, columnType: .json(rawType: "JSON"), isTableEditable: true)
-        #expect(resolver.resolve(context) == .editOverlay(value: value))
+        #expect(resolver.resolve(context) == .editText(value: value))
     }
 
     @Test("editable BLOB column returns editBlob")
@@ -172,10 +182,10 @@ struct CellInteractionResolverEditableTests {
         #expect(resolver.resolve(context) == .editInline(value: "small"))
     }
 
-    @Test("read-only boolean column returns viewInline")
+    @Test("read-only boolean column opens the text viewer")
     func readOnlyBooleanColumnReturnsViewInline() {
         let context = ContextFactory.make(value: "true", columnType: .boolean(rawType: "BOOL"), isTableEditable: false)
-        #expect(resolver.resolve(context) == .viewInline(value: "true"))
+        #expect(resolver.resolve(context) == .viewText(value: "true"))
     }
 }
 
@@ -292,7 +302,7 @@ struct CellInteractionResolverForeignKeyTests {
         let context = ContextFactory.make(
             value: "42", columnType: .integer(rawType: "INTEGER"), isForeignKey: true
         )
-        #expect(resolver.resolve(context) == .viewInline(value: "42"))
+        #expect(resolver.resolve(context) == .viewText(value: "42"))
     }
 
     @Test("an immutable foreign key column keeps its viewer")
@@ -301,7 +311,7 @@ struct CellInteractionResolverForeignKeyTests {
             value: "42", columnType: .integer(rawType: "INTEGER"),
             isTableEditable: true, isImmutableColumn: true, isForeignKey: true
         )
-        #expect(resolver.resolve(context) == .viewInline(value: "42"))
+        #expect(resolver.resolve(context) == .viewText(value: "42"))
     }
 
     @Test("a deleted row stays blocked on a foreign key column")
@@ -312,8 +322,7 @@ struct CellInteractionResolverForeignKeyTests {
         #expect(resolver.resolve(context) == .blocked)
     }
 
-    /// The picker lists keys, so a cell whose content needs a structured editor keeps that editor:
-    /// the reference is still followed from the arrow and the context menu.
+    // The picker lists keys; the reference is still followed from the arrow and the context menu.
     @Test("a foreign key column holding a blob keeps the blob editor")
     func blobForeignKeyKeepsTheBlobEditor() {
         let context = ContextFactory.make(
@@ -404,7 +413,7 @@ struct CellInteractionResolverImageTests {
         #expect(resolver.resolve(context) == .viewSvg)
     }
 
-    /// Raw Value is how a column opts out of every kind of detection, image included.
+    // Raw Value is how a column opts out of every kind of detection, image included.
     @Test("Display As Raw Value suppresses the SVG viewer")
     func rawOverrideSuppressesSvg() {
         let context = ContextFactory.make(
@@ -414,10 +423,10 @@ struct CellInteractionResolverImageTests {
             displayFormatOverride: .raw,
             detectedContent: .image(.svg)
         )
-        #expect(resolver.resolve(context) == .viewInline(value: markup))
+        #expect(resolver.resolve(context) == .viewText(value: markup))
     }
 
-    /// A binary column keeps the hex popover, which grows an Image segment of its own.
+    // A binary column keeps the hex popover, which grows an Image segment of its own.
     @Test("a raster image in a blob column still opens the blob viewer")
     func rasterInBlobColumnKeepsTheBlobViewer() {
         let context = ContextFactory.make(
diff --git a/apple/TableProTests/Views/Results/CellOverlayAccessibilityTests.swift b/apple/TableProTests/Views/Results/CellOverlayAccessibilityTests.swift
deleted file mode 100644
index 01cd99d942..0000000000
--- a/apple/TableProTests/Views/Results/CellOverlayAccessibilityTests.swift
+++ /dev/null
@@ -1,263 +0,0 @@
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class OverlayAccessibilityLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct CellOverlayAccessibilityTests {
-    private struct Grid {
-        let window: NSWindow
-        let coordinator: TableViewCoordinator
-        let tableView: KeyHandlingTableView
-        let scrollView: NSScrollView
-        let dataColumn: Int
-    }
-
-    private func makeGrid(isEditable: Bool) throws -> Grid {
-        let columns = ["third_col"]
-        let columnTypes = [ColumnType.text(rawType: "TEXT")]
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: isEditable,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: OverlayAccessibilityLayoutPersister()
-        )
-        let tableRows = TableRows.from(
-            queryRows: [[PluginCellValue.text("3")]],
-            columns: columns,
-            columnTypes: columnTypes
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: columnTypes,
-            savedLayout: nil,
-            isEditable: isEditable,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 120 }
-        )
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-        scrollView.hasVerticalScroller = true
-        scrollView.hasHorizontalScroller = true
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView = scrollView
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        window.layoutIfNeeded()
-        let dataColumn = try #require(coordinator.firstPresentedColumnIndex())
-        return Grid(
-            window: window,
-            coordinator: coordinator,
-            tableView: tableView,
-            scrollView: scrollView,
-            dataColumn: dataColumn
-        )
-    }
-
-    private func openViewer(in grid: Grid) throws -> CellOverlayViewer {
-        grid.coordinator.showOverlayViewer(
-            tableView: grid.tableView,
-            row: 0,
-            column: grid.dataColumn,
-            columnIndex: 0,
-            value: "3"
-        )
-        return try #require(grid.coordinator.overlayViewer)
-    }
-
-    private func textView(of overlay: CellOverlayBase) throws -> NSTextView {
-        let container = try #require(overlay.containerView)
-        let scrollView = try #require(container.subviews.first as? NSScrollView)
-        return try #require(scrollView.documentView as? NSTextView)
-    }
-
-    private func publishedDescendants(of element: Any, depth: Int = 0) -> [Any] {
-        guard depth < 12,
-              let children = (element as? NSAccessibilityProtocol)?.accessibilityChildren() else { return [] }
-        let published = NSAccessibility.unignoredChildren(from: children)
-        return published + published.flatMap { publishedDescendants(of: $0, depth: depth + 1) }
-    }
-
-    private func isPublished(_ textView: NSTextView, from window: NSWindow) -> Bool {
-        publishedDescendants(of: window).contains { ($0 as AnyObject) === textView }
-    }
-
-    private func isSameElement(_ element: Any?, as expected: AnyObject) -> Bool {
-        guard let element else { return false }
-        return (element as AnyObject) === expected
-    }
-
-    private func withActiveAccessibility(_ body: () throws -> Void) rethrows {
-        let wasActive = DataGridAccessibility.isActive
-        DataGridAccessibility.isActive = true
-        defer { DataGridAccessibility.isActive = wasActive }
-        try body()
-    }
-
-    @Test("An open cell viewer is reachable by walking the window's accessibility tree")
-    func anOpenViewerIsInTheTree() throws {
-        try withActiveAccessibility {
-            let grid = try makeGrid(isEditable: false)
-            let viewer = try openViewer(in: grid)
-            defer { viewer.dismiss() }
-            let text = try textView(of: viewer)
-
-            #expect(isPublished(text, from: grid.window))
-            #expect(text.accessibilityRole() == .textArea)
-            #expect(text.accessibilityValue() as? String == "3")
-        }
-    }
-
-    @Test("An open cell editor is reachable by walking the window's accessibility tree")
-    func anOpenEditorIsInTheTree() throws {
-        try withActiveAccessibility {
-            let grid = try makeGrid(isEditable: true)
-            grid.coordinator.beginCellEdit(row: 0, tableColumnIndex: grid.dataColumn)
-            let editor = try #require(grid.coordinator.overlayEditor)
-            defer { editor.dismiss(commit: false) }
-            let text = try textView(of: editor)
-
-            #expect(isPublished(text, from: grid.window))
-            #expect(text.accessibilityRole() == .textArea)
-            #expect(text.accessibilityValue() as? String == "3")
-        }
-    }
-
-    @Test("The overlay is mounted in the grid's scroll view, outside the table that cannot publish it")
-    func theOverlayIsMountedOutsideTheTable() throws {
-        let grid = try makeGrid(isEditable: false)
-        let viewer = try openViewer(in: grid)
-        defer { viewer.dismiss() }
-        let container = try #require(viewer.containerView)
-        let overlayScrollView = try #require(container.subviews.first as? NSScrollView)
-
-        #expect(container.superview === grid.scrollView)
-        #expect(!container.isDescendant(of: grid.tableView))
-        let parent = overlayScrollView.accessibilityParent()
-        #expect(isSameElement(parent.flatMap { NSAccessibility.unignoredAncestor(of: $0) }, as: grid.scrollView))
-    }
-
-    @Test("The overlay sits over the rows and under the header, the scrollers and the row gutter")
-    func theOverlayStacksDirectlyAboveTheRows() throws {
-        let grid = try makeGrid(isEditable: false)
-        DataGridView.installRowGutter(
-            scrollView: grid.scrollView,
-            tableView: grid.tableView,
-            coordinator: grid.coordinator
-        )
-        let gutter = try #require(grid.coordinator.rowGutter)
-        defer { gutter.detachTableGeometryObserver() }
-        let viewer = try openViewer(in: grid)
-        defer { viewer.dismiss() }
-        let container = try #require(viewer.containerView)
-        let subviews = grid.scrollView.subviews
-        let clipIndex = try #require(subviews.firstIndex { $0 === grid.scrollView.contentView })
-        let overlayIndex = try #require(subviews.firstIndex { $0 === container })
-        let headerClip = try #require(grid.tableView.headerView?.superview)
-        let headerIndex = try #require(subviews.firstIndex { $0 === headerClip })
-        let scroller = try #require(grid.scrollView.verticalScroller)
-        let scrollerIndex = try #require(subviews.firstIndex { $0 === scroller })
-        let gutterIndex = try #require(subviews.firstIndex { gutter.isDescendant(of: $0) })
-
-        #expect(overlayIndex == clipIndex + 1)
-        #expect(overlayIndex < headerIndex)
-        #expect(overlayIndex < scrollerIndex)
-        #expect(overlayIndex < gutterIndex)
-    }
-
-    @Test("The grid's scroll view clips an overlay taller than the rows left below its cell")
-    func theGridClipsTheOverlay() throws {
-        let grid = try makeGrid(isEditable: false)
-        DataGridView.installRowGutter(
-            scrollView: grid.scrollView,
-            tableView: grid.tableView,
-            coordinator: grid.coordinator
-        )
-        let gutter = try #require(grid.coordinator.rowGutter)
-        defer { gutter.detachTableGeometryObserver() }
-        let viewer = try openViewer(in: grid)
-        defer { viewer.dismiss() }
-        let container = try #require(viewer.containerView)
-
-        #expect(container.superview === grid.scrollView)
-        #expect(grid.scrollView.clipsToBounds)
-    }
-
-    @Test("The overlay lies over the cell it opened on")
-    func theOverlayCoversItsCell() throws {
-        let grid = try makeGrid(isEditable: false)
-        let viewer = try openViewer(in: grid)
-        defer { viewer.dismiss() }
-        let container = try #require(viewer.containerView)
-        let cell = grid.tableView.frameOfCell(atColumn: grid.dataColumn, row: 0)
-
-        let overlayInTable = grid.tableView.convert(container.frame, from: grid.scrollView)
-
-        #expect(overlayInTable.origin == cell.origin)
-        #expect(overlayInTable.width == cell.width)
-        #expect(overlayInTable.height >= cell.height)
-    }
-
-    @Test("A dismissed overlay leaves nothing mounted or published")
-    func aDismissedOverlayLeavesNothingBehind() throws {
-        try withActiveAccessibility {
-            let grid = try makeGrid(isEditable: false)
-            let viewer = try openViewer(in: grid)
-            let container = try #require(viewer.containerView)
-            let text = try textView(of: viewer)
-            #expect(isPublished(text, from: grid.window))
-
-            viewer.dismiss()
-
-            #expect(container.superview == nil)
-            #expect(!isPublished(text, from: grid.window))
-        }
-    }
-
-    @Test("The element a hit test over an open overlay returns is one the tree publishes")
-    func theHitTestResultOverTheOverlayIsInTheTree() throws {
-        try withActiveAccessibility {
-            let grid = try makeGrid(isEditable: false)
-            let viewer = try openViewer(in: grid)
-            defer { viewer.dismiss() }
-            let container = try #require(viewer.containerView)
-            let text = try textView(of: viewer)
-            let centre = NSPoint(x: container.bounds.midX, y: container.bounds.midY)
-            let onScreen = grid.window.convertPoint(toScreen: container.convert(centre, to: nil))
-
-            let hit = grid.window.accessibilityHitTest(onScreen)
-
-            #expect(isSameElement(hit, as: text))
-            #expect(isPublished(text, from: grid.window))
-        }
-    }
-}
diff --git a/apple/TableProTests/Views/Results/CellOverlayAppearanceTests.swift b/apple/TableProTests/Views/Results/CellOverlayAppearanceTests.swift
deleted file mode 100644
index 08055ac98b..0000000000
--- a/apple/TableProTests/Views/Results/CellOverlayAppearanceTests.swift
+++ /dev/null
@@ -1,247 +0,0 @@
-//
-//  CellOverlayAppearanceTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import TableProTheme
-import Testing
-
-@MainActor
-private final class OverlayLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// `appAppearanceChangeRepaintsAnOpenOverlay` assigns `NSApp.appearance`, which is global. What keeps
-/// that from reaching a suite running in parallel is that the body is synchronous and `@MainActor`,
-/// so nothing else on the main actor can interleave before the `defer` restores it. `.serialized`
-/// only orders tests inside this suite. Adding an `await` would break it.
-@MainActor
-struct CellOverlayAppearanceTests {
-    private func makeContainer() -> CellOverlayContainerView {
-        CellOverlayBase.makeContainer(frame: NSRect(x: 0, y: 0, width: 120, height: 24), scope: .live)
-    }
-
-    private func components(of color: CGColor?) throws -> (brightness: CGFloat, alpha: CGFloat) {
-        let cgColor = try #require(color)
-        let nsColor = try #require(NSColor(cgColor: cgColor))
-        let srgb = try #require(nsColor.usingColorSpace(.sRGB))
-        let brightness = (srgb.redComponent + srgb.greenComponent + srgb.blueComponent) / 3
-        return (brightness, srgb.alphaComponent)
-    }
-
-    @Test("A container built under each appearance gets that appearance's colours")
-    func containerColoursDifferByAppearance() throws {
-        let light = makeContainer()
-        light.appearance = try #require(NSAppearance(named: .aqua))
-        let dark = makeContainer()
-        dark.appearance = try #require(NSAppearance(named: .darkAqua))
-
-        let lightBackground = try components(of: light.layer?.backgroundColor)
-        let darkBackground = try components(of: dark.layer?.backgroundColor)
-        let lightBorder = try components(of: light.layer?.borderColor)
-        let darkBorder = try components(of: dark.layer?.borderColor)
-
-        #expect(lightBackground.brightness > darkBackground.brightness)
-        #expect(lightBorder.brightness != darkBorder.brightness)
-    }
-
-    /// The real trigger. `ThemeEngine.applyNSAppAppearance` assigns `NSApp.appearance`, and on that
-    /// path a view's `effectiveAppearance` is already the new one while
-    /// `NSAppearance.currentDrawing()` is still the old one, so a bare `.cgColor` resolves to the old
-    /// colour. Setting `container.appearance` directly does not reproduce that and would pass even
-    /// without `performAsCurrentDrawingAppearance`. The container has to be in a real window.
-    ///
-    /// The window has to be held across the flip. AppKit does not retain a window that was never
-    /// ordered front, and this one's last use is the `contentView` read below, so an autorelease pool
-    /// draining between that and the flip deallocates it. Measured: after a pool drain the window is
-    /// gone, `NSApp.windows` is empty, the container's `window` is nil, and the appearance change
-    /// produces zero `viewDidChangeEffectiveAppearance` calls, leaving `effectiveAppearance` at Aqua
-    /// and both reads at the light colour. That is the failure this suite showed once and could not
-    /// explain, and it is intermittent because where the pool drains is not the test's to decide.
-    @Test("An app appearance change repaints an open overlay")
-    func appAppearanceChangeRepaintsAnOpenOverlay() throws {
-        let originalAppearance = NSApp.appearance
-        defer { NSApp.appearance = originalAppearance }
-
-        NSApp.appearance = try #require(NSAppearance(named: .aqua))
-
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 400, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        let tableView = NSTableView(frame: NSRect(x: 0, y: 0, width: 400, height: 200))
-        let contentView = try #require(window.contentView)
-        contentView.addSubview(tableView)
-
-        let container = makeContainer()
-        tableView.addSubview(container)
-
-        try withExtendedLifetime(window) {
-            let lightBackground = try components(of: container.layer?.backgroundColor)
-            let lightBorder = try components(of: container.layer?.borderColor)
-
-            NSApp.appearance = try #require(NSAppearance(named: .darkAqua))
-
-            #expect(container.window === window)
-            #expect(container.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua)
-
-            let darkBackground = try components(of: container.layer?.backgroundColor)
-            let darkBorder = try components(of: container.layer?.borderColor)
-
-            #expect(lightBackground.brightness > darkBackground.brightness)
-            #expect(lightBorder.brightness != darkBorder.brightness)
-        }
-    }
-
-    /// The border is a baked `CGColor`, so a theme change reaches an open editor only by being
-    /// applied again, which the `themeChanged` subscription does.
-    @Test("A theme's focus border reaches an open overlay when its colours are reapplied")
-    func themeFocusBorderIsRebaked() throws {
-        let engine = ThemeEngine.shared
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-        engine.adopt(ThemeSelection(pair: .builtIn, effectiveAppearance: .light))
-
-        let container = makeContainer()
-        container.appearance = try #require(NSAppearance(named: .aqua))
-        let nativeBorder = try #require(container.layer?.borderColor)
-
-        var theme = BuiltInThemes.light
-        theme.id = "test.overlay-border"
-        theme.overrides[.gridFocusBorder] = try ThemeColor(validating: "#FF0000")
-        engine.adopt(ThemeSelection(pair: ThemePair(light: theme, dark: BuiltInThemes.dark), effectiveAppearance: .light))
-        container.applyLayerColors()
-
-        let themed = try #require(container.layer?.borderColor.flatMap { NSColor(cgColor: $0)?.usingColorSpace(.sRGB) })
-        #expect(themed.redComponent > 0.9)
-        #expect(themed.greenComponent < 0.1)
-        #expect(themed.blueComponent < 0.1)
-        #expect(container.layer?.borderColor != nativeBorder)
-    }
-
-    // MARK: - The value inside the overlay
-
-    private struct OverlayGrid {
-        let window: NSWindow
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-    }
-
-    /// A grid with one row, on `scope`, in a window an overlay can take first responder in.
-    private func makeGrid(scope: ThemeScope) -> OverlayGrid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: OverlayLayoutPersister(),
-            themeScope: scope
-        )
-        let tableRows = TableRows.from(
-            queryRows: [[PluginCellValue.text("value")]],
-            columns: ["name"],
-            columnTypes: [ColumnType.text(rawType: "TEXT")]
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 300, height: 120))
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: tableRows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 200 }
-        )
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 300, height: 120))
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 300, height: 120),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.appearance = NSAppearance(named: .aqua)
-        window.contentView = scrollView
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        return OverlayGrid(window: window, tableView: tableView, coordinator: coordinator)
-    }
-
-    private func openEditor(on grid: OverlayGrid) throws -> (CellOverlayEditor, NSTextView) {
-        let column = try #require(grid.coordinator.tableColumnIndex(forDisplayPosition: 0))
-        let editor = CellOverlayEditor()
-        editor.show(in: grid.tableView, row: 0, column: column, columnIndex: 0, value: "value")
-        let container = try #require(editor.containerView)
-        let scrollView = try #require(container.subviews.first as? NSScrollView)
-        let textView = try #require(scrollView.documentView as? NSTextView)
-        return (editor, textView)
-    }
-
-    @Test("Under the default theme the inline editor keeps the system text colors")
-    func overlayEditorDefaultIsNative() throws {
-        let grid = makeGrid(scope: .fixed(BuiltInThemes.light))
-        let (editor, textView) = try openEditor(on: grid)
-        defer { editor.dismiss(commit: false) }
-
-        #expect(textView.backgroundColor === NSColor.textBackgroundColor)
-        #expect(textView.textColor === NSColor.labelColor)
-        let aqua = try #require(NSAppearance(named: .aqua))
-        #expect(ThemeTestFixture.hex(editor.containerView?.layer?.backgroundColor)
-            == ThemeTestFixture.hex(ThemeTestFixture.baked(.textBackgroundColor, in: aqua)))
-        withExtendedLifetime(grid.window) {}
-    }
-
-    /// The box used to be the system's text background with white text inside a theme's border, on
-    /// a themed grid.
-    @Test("Under a theme the inline editor and viewer take the editor's colors, through the grid's scope")
-    func overlayTakesTheEditorColors() throws {
-        var theme = try ThemeTestFixture.theme(.light, [
-            .editorBackground: "#282A36",
-            .editorText: "#F8F8F2",
-            .editorCursor: "#FF79C6",
-            .editorSelection: "#44475A",
-        ])
-        theme.id = "test.overlay-editor"
-        let grid = makeGrid(scope: .fixed(theme))
-        let (editor, textView) = try openEditor(on: grid)
-        defer { editor.dismiss(commit: false) }
-
-        #expect(ThemeTestFixture.hex(textView.backgroundColor) == "#282A36")
-        #expect(ThemeTestFixture.hex(textView.textColor) == "#F8F8F2")
-        #expect(ThemeTestFixture.hex(textView.insertionPointColor) == "#FF79C6")
-        #expect(ThemeTestFixture.hex(textView.selectedTextAttributes[.backgroundColor] as? NSColor) == "#44475A")
-        #expect(ThemeTestFixture.hex(editor.containerView?.layer?.backgroundColor) == "#282A36")
-        #expect(ThemeTestFixture.hex((textView.enclosingScrollView?.backgroundColor)) == "#282A36")
-
-        let viewer = CellOverlayViewer()
-        let column = try #require(grid.coordinator.tableColumnIndex(forDisplayPosition: 0))
-        viewer.show(in: grid.tableView, row: 0, column: column, columnIndex: 0, value: "value")
-        defer { viewer.dismiss() }
-        let viewerText = try #require(
-            (viewer.containerView?.subviews.first as? NSScrollView)?.documentView as? NSTextView
-        )
-        #expect(ThemeTestFixture.hex(viewerText.backgroundColor) == "#282A36")
-        #expect(ThemeTestFixture.hex(viewerText.textColor) == "#F8F8F2")
-        withExtendedLifetime(grid.window) {}
-    }
-}
diff --git a/apple/TableProTests/Views/Results/CellOverlayEditorMovementTests.swift b/apple/TableProTests/Views/Results/CellOverlayEditorMovementTests.swift
deleted file mode 100644
index 56ac7c94fa..0000000000
--- a/apple/TableProTests/Views/Results/CellOverlayEditorMovementTests.swift
+++ /dev/null
@@ -1,159 +0,0 @@
-//
-//  CellOverlayEditorMovementTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import Testing
-
-@testable import TablePro
-
-/// The overlay is a text view rather than a field editor, so the four selectors AppKit would have
-/// turned into an `NSTextMovement` are read here instead (#2569).
-@MainActor
-struct CellOverlayEditorMovementTests {
-    private struct Editing {
-        let editor: CellOverlayEditor
-        let textView: NSTextView
-        let tableView: KeyHandlingTableView
-        let scrollView: NSScrollView
-    }
-
-    private func makeEditing(value: String, selection: NSRange) -> Editing {
-        let tableView = KeyHandlingTableView()
-        let scrollView = NSScrollView()
-        scrollView.documentView = tableView
-        let editor = CellOverlayEditor()
-        editor.install(
-            in: tableView,
-            row: 4,
-            column: 2,
-            columnIndex: 1,
-            container: CellOverlayContainerView(frame: NSRect(x: 0, y: 0, width: 80, height: 24))
-        )
-        let textView = NSTextView(frame: NSRect(x: 0, y: 0, width: 80, height: 24))
-        CellOverlayBase.applyCellTextLayout(to: textView)
-        textView.string = value
-        textView.setSelectedRange(selection)
-        return Editing(editor: editor, textView: textView, tableView: tableView, scrollView: scrollView)
-    }
-
-    private struct Outcome {
-        let handled: Bool
-        let movement: CellEditorMovement?
-        let cell: (row: Int, column: Int)?
-    }
-
-    private func send(_ selector: Selector, to editing: Editing) -> Outcome {
-        var movement: CellEditorMovement?
-        var cell: (row: Int, column: Int)?
-        editing.editor.onMovement = { row, column, reported in
-            movement = reported
-            cell = (row, column)
-        }
-        let handled = editing.editor.textView(editing.textView, doCommandBy: selector)
-        editing.editor.removeOverlay()
-        return Outcome(handled: handled, movement: movement, cell: cell)
-    }
-
-    @Test("Down leaves a single-line value for the row below")
-    func downLeavesSingleLineValue() throws {
-        let editing = makeEditing(value: "alpha", selection: NSRange(location: 0, length: 5))
-
-        let result = send(#selector(NSResponder.moveDown(_:)), to: editing)
-
-        #expect(result.handled)
-        #expect(result.movement == .down)
-        let cell = try #require(result.cell)
-        #expect(cell.row == 4)
-        #expect(cell.column == 2)
-    }
-
-    @Test("Up leaves a single-line value for the row above")
-    func upLeavesSingleLineValue() {
-        let editing = makeEditing(value: "alpha", selection: NSRange(location: 2, length: 0))
-
-        let result = send(#selector(NSResponder.moveUp(_:)), to: editing)
-
-        #expect(result.handled)
-        #expect(result.movement == .up)
-    }
-
-    @Test("Down inside a multi-line value stays in the text view")
-    func downInsideMultiLineValueStays() {
-        let editing = makeEditing(value: "a\nb\nc", selection: NSRange(location: 0, length: 0))
-
-        let result = send(#selector(NSResponder.moveDown(_:)), to: editing)
-
-        #expect(!result.handled)
-        #expect(result.movement == nil)
-    }
-
-    @Test("Down from the last line of a multi-line value leaves the cell")
-    func downFromLastLineLeaves() {
-        let editing = makeEditing(value: "a\nb\nc", selection: NSRange(location: 5, length: 0))
-
-        let result = send(#selector(NSResponder.moveDown(_:)), to: editing)
-
-        #expect(result.handled)
-        #expect(result.movement == .down)
-    }
-
-    /// Shift+Down is `moveDownAndModifySelection:`, so extending a selection keeps its own meaning.
-    @Test("A selection-extending arrow is left to the text view")
-    func selectionExtendingArrowIsLeftAlone() {
-        let editing = makeEditing(value: "alpha", selection: NSRange(location: 0, length: 0))
-
-        let result = send(#selector(NSResponder.moveDownAndModifySelection(_:)), to: editing)
-
-        #expect(!result.handled)
-        #expect(result.movement == nil)
-    }
-
-    /// The text view holds provisional text until the input method commits it, so a movement here
-    /// would save a half-composed value. The arrow goes back to the composition, which is what
-    /// moves the caret through it; Tab is swallowed rather than turned into a literal tab.
-    @Test("An arrow during an IME composition stays with the composition")
-    func arrowDuringCompositionStaysWithTheComposition() {
-        let editing = makeEditing(value: "", selection: NSRange(location: 0, length: 0))
-        editing.textView.setMarkedText(
-            "\u{304B}",
-            selectedRange: NSRange(location: 1, length: 0),
-            replacementRange: NSRange(location: 0, length: 0)
-        )
-
-        let result = send(#selector(NSResponder.moveDown(_:)), to: editing)
-
-        #expect(editing.textView.hasMarkedText())
-        #expect(!result.handled)
-        #expect(result.movement == nil)
-    }
-
-    @Test("Tab during an IME composition is swallowed rather than leaving the cell")
-    func tabDuringCompositionIsSwallowed() {
-        let editing = makeEditing(value: "", selection: NSRange(location: 0, length: 0))
-        editing.textView.setMarkedText(
-            "\u{304B}",
-            selectedRange: NSRange(location: 1, length: 0),
-            replacementRange: NSRange(location: 0, length: 0)
-        )
-
-        let result = send(#selector(NSResponder.insertTab(_:)), to: editing)
-
-        #expect(result.handled)
-        #expect(result.movement == nil)
-    }
-
-    @Test("Tab and Shift+Tab report their own movements")
-    func tabAndBacktabReportTheirMovements() {
-        let caret = NSRange(location: 0, length: 0)
-        let forward = send(#selector(NSResponder.insertTab(_:)), to: makeEditing(value: "alpha", selection: caret))
-        let backward = send(#selector(NSResponder.insertBacktab(_:)), to: makeEditing(value: "alpha", selection: caret))
-
-        #expect(forward.handled)
-        #expect(forward.movement == .tab)
-        #expect(backward.handled)
-        #expect(backward.movement == .backtab)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/CellOverlayTextLayoutTests.swift b/apple/TableProTests/Views/Results/CellOverlayTextLayoutTests.swift
deleted file mode 100644
index 76db0d4b6d..0000000000
--- a/apple/TableProTests/Views/Results/CellOverlayTextLayoutTests.swift
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-//  CellOverlayTextLayoutTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Testing
-
-@testable import TablePro
-
-/// A cell holds one value, so an inline overlay behaves like a field editor and scrolls a long line
-/// rather than wrapping it. Wrapping made TextKit 2 lay the whole paragraph out before the overlay
-/// could appear: 206ms for a 256KB value and 816ms for 1MB, against 7ms unwrapped (#2381).
-@MainActor
-struct CellOverlayTextLayoutTests {
-    private func makeTextView(width: CGFloat = 140) -> NSTextView {
-        let textView = NSTextView(frame: NSRect(x: 0, y: 0, width: width, height: 24))
-        CellOverlayBase.applyCellTextLayout(to: textView)
-        return textView
-    }
-
-    @Test("A long line is not wrapped into the cell's width")
-    func longLineIsNotWrapped() throws {
-        let textView = makeTextView()
-        let container = try #require(textView.textContainer)
-
-        #expect(!container.widthTracksTextView)
-        #expect(container.size.width == CGFloat.greatestFiniteMagnitude)
-    }
-
-    /// A text view grows only as far as `maxSize`, which `init(frame:)` leaves at the frame size, so
-    /// leaving it alone clips the long line at the cell's width instead of scrolling it. Measured:
-    /// a 64,000-character value produced a 140pt document view without this and 344,166pt with it.
-    @Test("A long line makes the editor scrollable rather than clipping it")
-    func longLineScrollsRatherThanClipping() throws {
-        let textView = makeTextView()
-        let layoutManager = try #require(textView.textLayoutManager, "the overlay has to be on TextKit 2")
-        textView.string = String(repeating: "some cell value ", count: 4_000)
-        layoutManager.ensureLayout(for: layoutManager.documentRange)
-        textView.layout()
-
-        #expect(textView.maxSize.width == CGFloat.greatestFiniteMagnitude)
-        #expect(textView.frame.width > 1_000, "the document has to outgrow the cell for scrolling to reach the text")
-    }
-
-    @Test("A short value still lays out inside the cell")
-    func shortValueStillLaysOut() throws {
-        let textView = makeTextView()
-        let layoutManager = try #require(textView.textLayoutManager)
-        textView.string = "42"
-        layoutManager.ensureLayout(for: layoutManager.documentRange)
-
-        #expect(textView.string == "42")
-    }
-
-    /// The viewer shares the editor's layout, so a read-only table cannot reach the same freeze by
-    /// opening a huge value inline.
-    @Test("The overlay layout is one definition, shared by editor and viewer")
-    func editorAndViewerShareTheLayout() throws {
-        let editorTextView = makeTextView()
-        let viewerTextView = makeTextView(width: 300)
-
-        #expect(editorTextView.textContainer?.widthTracksTextView == false)
-        #expect(viewerTextView.textContainer?.widthTracksTextView == false)
-        #expect(editorTextView.maxSize == viewerTextView.maxSize)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/CellSelectionTests.swift b/apple/TableProTests/Views/Results/CellSelectionTests.swift
index b91e4a75fd..d62e49fe3b 100644
--- a/apple/TableProTests/Views/Results/CellSelectionTests.swift
+++ b/apple/TableProTests/Views/Results/CellSelectionTests.swift
@@ -1,8 +1,5 @@
-import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
-import TableProPluginKit
 import Testing
 
 struct GridRectTests {
@@ -142,15 +139,7 @@ struct GridSelectionTests {
     }
 }
 
-@MainActor
-private final class OneRowTableSource: NSObject, NSTableViewDataSource {
-    func numberOfRows(in tableView: NSTableView) -> Int { 1 }
-}
-
 struct GridSelectionColumnMarkerTests {
-    /// A marker whose block no longer reaches the last row is not a whole column any more. Keeping
-    /// it told the heading and the column commands otherwise, while the fill, the copy and the
-    /// affected rows stopped short, and nothing could take the stale block back off.
     @Test("a marker is dropped when the result gained rows")
     func markerDroppedWhenResultGrew() {
         let picked = GridSelection.column(1, totalRows: 4)
@@ -306,764 +295,3 @@ struct GridSelectionCellCountTests {
         #expect(selection.removing(cell: GridCoord(row: 0, displayColumn: 0)) == selection)
     }
 }
-
-struct GridSelectionRowShiftTests {
-    private let block = GridSelection.single(
-        GridRect(rows: 2...4, columns: 1...1),
-        anchor: GridCoord(row: 2, displayColumn: 1),
-        active: GridCoord(row: 4, displayColumn: 1)
-    )
-
-    @Test("a row inserted inside a block grows it")
-    func insertInsideGrows() {
-        let result = block.insertingRows(IndexSet(integer: 3), newRowCount: 11)
-
-        #expect(result.rectangles == [GridRect(rows: 2...5, columns: 1...1)])
-        #expect(result.anchor == GridCoord(row: 2, displayColumn: 1))
-        #expect(result.activeCell == GridCoord(row: 5, displayColumn: 1))
-    }
-
-    @Test("rows inserted at or above a block push it down")
-    func insertAboveShifts() {
-        #expect(block.insertingRows(IndexSet(integer: 2), newRowCount: 11).rectangles == [GridRect(rows: 3...5, columns: 1...1)])
-        #expect(block.insertingRows(IndexSet([0, 1]), newRowCount: 12).rectangles == [GridRect(rows: 4...6, columns: 1...1)])
-    }
-
-    @Test("a row inserted below a block leaves it alone")
-    func insertBelowKeeps() {
-        #expect(block.insertingRows(IndexSet(integer: 5), newRowCount: 11) == block)
-    }
-
-    @Test("a picked column grows over appended rows and keeps its marker")
-    func pickedColumnGrowsOnAppend() {
-        let picked = GridSelection.column(1, totalRows: 4)
-
-        let result = picked.insertingRows(IndexSet(integersIn: 4...6), newRowCount: 7)
-
-        #expect(result.rectangles == [GridRect(rows: 0...6, columns: 1...1)])
-        #expect(result.columns == IndexSet(integer: 1))
-    }
-
-    @Test("a picked column covers a row inserted at the top")
-    func pickedColumnCoversInsertAtTop() {
-        let picked = GridSelection.column(1, totalRows: 4)
-
-        let result = picked.insertingRows(IndexSet(integer: 0), newRowCount: 5)
-
-        #expect(result.rectangles == [GridRect(rows: 0...4, columns: 1...1)])
-        #expect(result.columns == IndexSet(integer: 1))
-    }
-
-    @Test("a swept block that reaches every row does not grow over appended rows")
-    func sweptBlockDoesNotGrow() {
-        let corner = GridCoord(row: 0, displayColumn: 1)
-        let swept = GridSelection.single(GridRect(rows: 0...3, columns: 1...1), anchor: corner, active: corner)
-
-        let result = swept.insertingRows(IndexSet(integersIn: 4...5), newRowCount: 6)
-
-        #expect(result.rectangles == [GridRect(rows: 0...3, columns: 1...1)])
-        #expect(result.columns.isEmpty)
-    }
-
-    @Test("removed rows shift a block up and shrink it")
-    func removeShiftsAndShrinks() {
-        let selection = GridSelection.single(
-            GridRect(rows: 2...6, columns: 0...1),
-            anchor: GridCoord(row: 2, displayColumn: 0),
-            active: GridCoord(row: 6, displayColumn: 1)
-        )
-
-        let result = selection.removingRows(IndexSet([0, 3, 8]), newRowCount: 7)
-
-        #expect(result.rectangles == [GridRect(rows: 1...4, columns: 0...1)])
-        #expect(result.anchor == GridCoord(row: 1, displayColumn: 0))
-        #expect(result.activeCell == GridCoord(row: 4, displayColumn: 1))
-    }
-
-    @Test("a block whose rows are all removed is dropped and the cursor moves to what is left")
-    func removeDropsEmptiedRectangle() {
-        let selection = GridSelection(
-            rectangles: [GridRect(rows: 0...1, columns: 0...0), GridRect(rows: 5...6, columns: 0...0)],
-            activeCell: GridCoord(row: 6, displayColumn: 0),
-            anchor: GridCoord(row: 5, displayColumn: 0)
-        )
-
-        let result = selection.removingRows(IndexSet([5, 6]), newRowCount: 8)
-
-        #expect(result.rectangles == [GridRect(rows: 0...1, columns: 0...0)])
-        #expect(result.activeCell == GridCoord(row: 0, displayColumn: 0))
-        #expect(result.anchor == GridCoord(row: 0, displayColumn: 0))
-    }
-
-    @Test("removing every selected row empties the selection")
-    func removeEverythingEmpties() {
-        #expect(block.removingRows(IndexSet(integersIn: 2...4), newRowCount: 8) == .empty)
-        #expect(block.removingRows(IndexSet(integersIn: 0...10), newRowCount: 0) == .empty)
-    }
-
-    @Test("a picked column keeps its marker after a removal")
-    func pickedColumnSurvivesRemoval() {
-        let picked = GridSelection.column(0, totalRows: 5)
-
-        let result = picked.removingRows(IndexSet(integer: 1), newRowCount: 4)
-
-        #expect(result.rectangles == [GridRect(rows: 0...3, columns: 0...0)])
-        #expect(result.columns == IndexSet(integer: 0))
-    }
-}
-
-@MainActor
-struct GridSelectionControllerTests {
-    @Test("plain click without drag leaves the selection empty")
-    func plainClickWithoutDragHasNoSelection() {
-        let controller = GridSelectionController()
-        let coord = GridCoord(row: 2, displayColumn: 3)
-        _ = controller.beginDrag(at: coord, modifiers: [])
-        controller.endDrag(dragged: false, originalCoord: coord)
-        #expect(controller.selection.isEmpty)
-    }
-
-    @Test("plain click on an existing selection clears it without creating a new rect")
-    func plainClickClearsPreviousSelection() {
-        let controller = GridSelectionController()
-        let first = GridCoord(row: 0, displayColumn: 0)
-        let second = GridCoord(row: 3, displayColumn: 4)
-        _ = controller.beginDrag(at: first, modifiers: [])
-        controller.continueDrag(to: GridCoord(row: 1, displayColumn: 2))
-        controller.endDrag(dragged: true, originalCoord: first)
-        #expect(!controller.selection.isEmpty)
-
-        _ = controller.beginDrag(at: second, modifiers: [])
-        controller.endDrag(dragged: false, originalCoord: second)
-        #expect(controller.selection.isEmpty)
-    }
-
-    @Test("drag extends to a rectangle anchored at the mousedown coord")
-    func dragBuildsRectangle() {
-        let controller = GridSelectionController()
-        let origin = GridCoord(row: 1, displayColumn: 1)
-        let target = GridCoord(row: 4, displayColumn: 3)
-        _ = controller.beginDrag(at: origin, modifiers: [])
-        controller.continueDrag(to: target)
-        controller.endDrag(dragged: true, originalCoord: origin)
-        #expect(controller.selection.rectangles == [GridRect(rows: 1...4, columns: 1...3)])
-        #expect(controller.selection.anchor == origin)
-        #expect(controller.selection.activeCell == target)
-    }
-
-    @Test("shift extends the existing selection from the anchor across columns")
-    func shiftExtendsAcrossColumns() {
-        let controller = GridSelectionController()
-        let origin = GridCoord(row: 2, displayColumn: 2)
-        let dragTo = GridCoord(row: 2, displayColumn: 2)
-        _ = controller.beginDrag(at: origin, modifiers: [])
-        controller.continueDrag(to: dragTo)
-        controller.endDrag(dragged: true, originalCoord: origin)
-
-        let shiftTarget = GridCoord(row: 5, displayColumn: 6)
-        _ = controller.beginDrag(at: shiftTarget, modifiers: .shift)
-        #expect(controller.selection.rectangles == [GridRect(rows: 2...5, columns: 2...6)])
-        #expect(controller.selection.anchor == origin)
-        #expect(controller.selection.activeCell == shiftTarget)
-    }
-
-    @Test("cmd+click without drag toggles a single cell")
-    func cmdClickTogglesCell() {
-        let controller = GridSelectionController()
-        let first = GridCoord(row: 0, displayColumn: 0)
-        let second = GridCoord(row: 3, displayColumn: 4)
-
-        _ = controller.beginDrag(at: first, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: first)
-        #expect(controller.selection.rectangles == [GridRect(cell: first)])
-
-        _ = controller.beginDrag(at: second, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: second)
-        #expect(controller.selection.rectangles == [GridRect(cell: first), GridRect(cell: second)])
-
-        _ = controller.beginDrag(at: second, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: second)
-        #expect(controller.selection.rectangles == [GridRect(cell: first)])
-    }
-
-    @Test("cmd+drag appends a fresh rectangle without clobbering the base selection")
-    func cmdDragAppendsRectangle() {
-        let controller = GridSelectionController()
-        let baseOrigin = GridCoord(row: 0, displayColumn: 0)
-        let baseTarget = GridCoord(row: 1, displayColumn: 1)
-        _ = controller.beginDrag(at: baseOrigin, modifiers: [])
-        controller.continueDrag(to: baseTarget)
-        controller.endDrag(dragged: true, originalCoord: baseOrigin)
-
-        let cmdOrigin = GridCoord(row: 5, displayColumn: 5)
-        let cmdTarget = GridCoord(row: 7, displayColumn: 7)
-        _ = controller.beginDrag(at: cmdOrigin, modifiers: .command)
-        controller.continueDrag(to: cmdTarget)
-        controller.endDrag(dragged: true, originalCoord: cmdOrigin)
-
-        #expect(controller.selection.rectangles == [
-            GridRect(rows: 0...1, columns: 0...1),
-            GridRect(rows: 5...7, columns: 5...7)
-        ])
-        #expect(controller.selection.activeCell == cmdTarget)
-    }
-
-    /// A block that happens to reach both ends of the page is not a column selection. Reading the
-    /// intent back out of the geometry tinted the heading of any column a drag swept end to end,
-    /// and in a one-row result of every column a single cell was clicked in.
-    @Test("only a heading click marks a column as picked")
-    func onlyHeadingClicksPickColumns() {
-        let controller = GridSelectionController()
-        let whole = GridCoord(row: 0, displayColumn: 1)
-
-        controller.update(.single(GridRect(rows: 0...3, columns: 1...1), anchor: whole, active: whole))
-        #expect(controller.selectedFullColumns().isEmpty)
-
-        controller.selectEntireColumn(1, totalRows: 4)
-        #expect(controller.selectedFullColumns() == IndexSet(integer: 1))
-    }
-
-    /// A one-row result is the sharpest case: every rectangle in it spans every row, so the old
-    /// predicate read one clicked cell as a picked column. The table view is real here because that
-    /// predicate consulted `numberOfRows`, and without one the check passes for the wrong reason.
-    @Test("a single cell in a one-row result picks no column")
-    func singleCellInOneRowResultPicksNoColumn() {
-        let controller = GridSelectionController()
-        let source = OneRowTableSource()
-        let tableView = NSTableView()
-        tableView.addTableColumn(NSTableColumn(identifier: .init("c")))
-        tableView.dataSource = source
-        tableView.reloadData()
-        controller.tableView = tableView
-        #expect(tableView.numberOfRows == 1)
-        let cell = GridCoord(row: 0, displayColumn: 0)
-
-        controller.update(.single(GridRect(cell: cell), anchor: cell, active: cell))
-
-        #expect(controller.selectedFullColumns().isEmpty)
-    }
-
-    @Test("Cmd+clicking a picked heading gives the column back")
-    func headingCmdClickToggles() {
-        let controller = GridSelectionController()
-        controller.selectEntireColumn(0, totalRows: 4)
-
-        controller.addEntireColumn(2, totalRows: 4)
-        #expect(controller.selectedFullColumns() == IndexSet([0, 2]))
-
-        controller.addEntireColumn(2, totalRows: 4)
-        #expect(controller.selectedFullColumns() == IndexSet(integer: 0))
-        #expect(controller.selection.rectangles == [GridRect(rows: 0...3, columns: 0...0)])
-    }
-
-    /// An additive body gesture rebuilds the selection from the drag's base rectangles, and used to
-    /// rebuild it without the picked columns, so a Cmd+click in the body unpainted a heading the
-    /// user had picked and took its column out of the column commands.
-    @Test("a Cmd+click in the body keeps a picked heading")
-    func additiveCellGestureKeepsPickedColumns() {
-        let controller = GridSelectionController()
-        controller.selectEntireColumn(1, totalRows: 4)
-
-        let elsewhere = GridCoord(row: 2, displayColumn: 3)
-        _ = controller.beginDrag(at: elsewhere, modifiers: [.command])
-        controller.endDrag(dragged: false, originalCoord: elsewhere)
-
-        #expect(controller.selectedFullColumns() == IndexSet(integer: 1))
-        #expect(controller.selection.contains(elsewhere))
-    }
-
-    @Test("a Cmd+drag in the body keeps a picked heading")
-    func additiveCellDragKeepsPickedColumns() {
-        let controller = GridSelectionController()
-        controller.selectEntireColumn(1, totalRows: 4)
-
-        let start = GridCoord(row: 1, displayColumn: 3)
-        _ = controller.beginDrag(at: start, modifiers: [.command])
-        controller.continueDrag(to: GridCoord(row: 3, displayColumn: 4))
-        controller.endDrag(dragged: true, originalCoord: start)
-
-        #expect(controller.selectedFullColumns() == IndexSet(integer: 1))
-    }
-
-    /// `union` concatenates, so re-adding one heading used to leave a second identical rectangle
-    /// behind, and the overlay and the row fill walk every rectangle for every visible row.
-    @Test("re-picking a heading never duplicates its rectangle")
-    func headingPickNeverDuplicates() {
-        let controller = GridSelectionController()
-        controller.selectEntireColumn(1, totalRows: 4)
-
-        controller.addEntireColumn(1, totalRows: 4)
-        controller.addEntireColumn(1, totalRows: 4)
-
-        #expect(controller.selection.rectangles.count <= 1)
-    }
-
-    @Test("selectEntireColumn covers all rows in that column")
-    func selectColumnSpansAllRows() {
-        let controller = GridSelectionController()
-        controller.selectEntireColumn(2, totalRows: 5)
-        #expect(controller.selection.rectangles == [GridRect(rows: 0...4, columns: 2...2)])
-        #expect(controller.selection.activeCell == GridCoord(row: 0, displayColumn: 2))
-        #expect(controller.selection.anchor == GridCoord(row: 0, displayColumn: 2))
-    }
-
-    @Test("selectEntireRow covers all columns in that row")
-    func selectRowSpansAllColumns() {
-        let controller = GridSelectionController()
-        controller.selectEntireRow(3, totalColumns: 6)
-        #expect(controller.selection.rectangles == [GridRect(rows: 3...3, columns: 0...5)])
-        #expect(controller.selection.activeCell == GridCoord(row: 3, displayColumn: 0))
-    }
-
-    @Test("extendActiveCell moves the active cell and grows the rectangle from the anchor")
-    func extendActiveCellGrowsRectangle() {
-        let controller = GridSelectionController()
-        let origin = GridCoord(row: 2, displayColumn: 2)
-        _ = controller.beginDrag(at: origin, modifiers: [])
-        controller.continueDrag(to: GridCoord(row: 3, displayColumn: 3))
-        controller.endDrag(dragged: true, originalCoord: origin)
-
-        controller.extendActiveCell(direction: .down, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-        #expect(controller.selection.rectangles == [GridRect(rows: 2...4, columns: 2...3)])
-        #expect(controller.selection.activeCell == GridCoord(row: 4, displayColumn: 3))
-        #expect(controller.selection.anchor == origin)
-    }
-
-    @Test("extendActiveCell with jumpToEdge jumps to the grid edge")
-    func extendActiveCellJumpsToEdge() {
-        let controller = GridSelectionController()
-        let origin = GridCoord(row: 2, displayColumn: 2)
-        _ = controller.beginDrag(at: origin, modifiers: [])
-        controller.continueDrag(to: origin)
-        controller.endDrag(dragged: true, originalCoord: origin)
-
-        controller.extendActiveCell(direction: .right, jumpToEdge: true, totalRows: 10, totalColumns: 10)
-        #expect(controller.selection.activeCell == GridCoord(row: 2, displayColumn: 9))
-        #expect(controller.selection.rectangles == [GridRect(rows: 2...2, columns: 2...9)])
-    }
-
-    @Test("extendActiveCell without a seed is a no-op when the selection is empty")
-    func extendActiveCellNoOpEmpty() {
-        let controller = GridSelectionController()
-        controller.extendActiveCell(direction: .down, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-        #expect(controller.selection.isEmpty)
-    }
-
-    @Test("extendActiveCell with a seed begins a range anchored at the focused cell")
-    func extendActiveCellSeedsFromFocusedCell() {
-        let controller = GridSelectionController()
-        let focused = GridCoord(row: 3, displayColumn: 4)
-
-        controller.extendActiveCell(from: focused, direction: .down, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-
-        #expect(controller.selection.rectangles == [GridRect(rows: 3...4, columns: 4...4)])
-        #expect(controller.selection.anchor == focused)
-        #expect(controller.selection.activeCell == GridCoord(row: 4, displayColumn: 4))
-    }
-
-    @Test("a seeded extend grows by one cell in each direction from the focused cell")
-    func extendActiveCellSeedsInEveryDirection() {
-        let focused = GridCoord(row: 3, displayColumn: 3)
-        let cases: [(GridSelectionController.Direction, GridRect, GridCoord)] = [
-            (.up, GridRect(rows: 2...3, columns: 3...3), GridCoord(row: 2, displayColumn: 3)),
-            (.down, GridRect(rows: 3...4, columns: 3...3), GridCoord(row: 4, displayColumn: 3)),
-            (.left, GridRect(rows: 3...3, columns: 2...3), GridCoord(row: 3, displayColumn: 2)),
-            (.right, GridRect(rows: 3...3, columns: 3...4), GridCoord(row: 3, displayColumn: 4))
-        ]
-        for (direction, expectedRect, expectedActive) in cases {
-            let controller = GridSelectionController()
-            controller.extendActiveCell(from: focused, direction: direction, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-            #expect(controller.selection.rectangles == [expectedRect])
-            #expect(controller.selection.anchor == focused)
-            #expect(controller.selection.activeCell == expectedActive)
-        }
-    }
-
-    @Test("repeated seeded extend keeps the anchor fixed and reverses by shrinking")
-    func extendActiveCellAnchorStaysFixedOnReverse() {
-        let controller = GridSelectionController()
-        let focused = GridCoord(row: 2, displayColumn: 2)
-
-        controller.extendActiveCell(from: focused, direction: .down, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-        controller.extendActiveCell(direction: .down, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-        #expect(controller.selection.rectangles == [GridRect(rows: 2...4, columns: 2...2)])
-
-        controller.extendActiveCell(direction: .up, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-        #expect(controller.selection.rectangles == [GridRect(rows: 2...3, columns: 2...2)])
-        #expect(controller.selection.anchor == focused)
-        #expect(controller.selection.activeCell == GridCoord(row: 3, displayColumn: 2))
-    }
-
-    @Test("a seeded extend with jumpToEdge runs from the focused cell to the grid edge")
-    func extendActiveCellSeedsToEdge() {
-        let controller = GridSelectionController()
-        let focused = GridCoord(row: 2, displayColumn: 2)
-
-        controller.extendActiveCell(from: focused, direction: .right, jumpToEdge: true, totalRows: 10, totalColumns: 10)
-
-        #expect(controller.selection.rectangles == [GridRect(rows: 2...2, columns: 2...9)])
-        #expect(controller.selection.anchor == focused)
-        #expect(controller.selection.activeCell == GridCoord(row: 2, displayColumn: 9))
-    }
-
-    @Test("the seed is ignored when a selection already exists")
-    func extendActiveCellIgnoresSeedWhenSelectionExists() {
-        let controller = GridSelectionController()
-        let origin = GridCoord(row: 2, displayColumn: 2)
-        _ = controller.beginDrag(at: origin, modifiers: [])
-        controller.continueDrag(to: origin)
-        controller.endDrag(dragged: true, originalCoord: origin)
-
-        controller.extendActiveCell(from: GridCoord(row: 9, displayColumn: 9), direction: .down, jumpToEdge: false, totalRows: 10, totalColumns: 10)
-
-        #expect(controller.selection.rectangles == [GridRect(rows: 2...3, columns: 2...2)])
-        #expect(controller.selection.anchor == origin)
-    }
-
-    @Test("clear empties the selection")
-    func clearEmpties() {
-        let controller = GridSelectionController()
-        let coord = GridCoord(row: 0, displayColumn: 0)
-        _ = controller.beginDrag(at: coord, modifiers: [])
-        controller.endDrag(dragged: false, originalCoord: coord)
-        controller.clear()
-        #expect(controller.selection.isEmpty)
-    }
-
-    /// A plain click leaves no cell selection behind, only a focused cell, so Shift+click used to
-    /// select the target alone.
-    @Test("Shift+click after a plain click ranges from the clicked cell")
-    func shiftClickAfterPlainClickAnchorsAtFocus() {
-        let controller = GridSelectionController()
-        let first = GridCoord(row: 0, displayColumn: 1)
-        let target = GridCoord(row: 4, displayColumn: 1)
-        _ = controller.beginDrag(at: first, modifiers: [])
-        controller.endDrag(dragged: false, originalCoord: first)
-        #expect(controller.selection.isEmpty)
-
-        _ = controller.beginDrag(at: target, modifiers: .shift, focus: first)
-        controller.endDrag(dragged: false, originalCoord: target)
-
-        #expect(controller.selection.rectangles == [GridRect(rows: 0...4, columns: 1...1)])
-        #expect(controller.selection.anchor == first)
-        #expect(controller.selection.activeCell == target)
-    }
-
-    @Test("Cmd+click after a plain click keeps the clicked cell")
-    func cmdClickAfterPlainClickKeepsFocus() {
-        let controller = GridSelectionController()
-        let first = GridCoord(row: 0, displayColumn: 0)
-        let second = GridCoord(row: 2, displayColumn: 0)
-        let third = GridCoord(row: 4, displayColumn: 0)
-        _ = controller.beginDrag(at: first, modifiers: [])
-        controller.endDrag(dragged: false, originalCoord: first)
-
-        _ = controller.beginDrag(at: second, modifiers: .command, focus: first)
-        controller.endDrag(dragged: false, originalCoord: second)
-        _ = controller.beginDrag(at: third, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: third)
-
-        #expect(controller.selection.rectangles == [GridRect(cell: first), GridRect(cell: second), GridRect(cell: third)])
-        #expect(controller.selection.uniqueCellCount == 3)
-        #expect(controller.selection.activeCell == third)
-    }
-
-    @Test("Cmd+drag after a plain click keeps the clicked cell")
-    func cmdDragAfterPlainClickKeepsFocus() {
-        let controller = GridSelectionController()
-        let first = GridCoord(row: 0, displayColumn: 0)
-        let start = GridCoord(row: 3, displayColumn: 2)
-        _ = controller.beginDrag(at: first, modifiers: [])
-        controller.endDrag(dragged: false, originalCoord: first)
-
-        _ = controller.beginDrag(at: start, modifiers: .command, focus: first)
-        controller.continueDrag(to: GridCoord(row: 4, displayColumn: 2))
-        controller.endDrag(dragged: true, originalCoord: start)
-
-        #expect(controller.selection.rectangles == [GridRect(cell: first), GridRect(rows: 3...4, columns: 2...2)])
-    }
-
-    @Test("the focus is ignored once a cell selection exists")
-    func focusIgnoredWithSelection() {
-        let controller = GridSelectionController()
-        let origin = GridCoord(row: 1, displayColumn: 1)
-        let stale = GridCoord(row: 9, displayColumn: 9)
-        _ = controller.beginDrag(at: origin, modifiers: [])
-        controller.continueDrag(to: GridCoord(row: 2, displayColumn: 1))
-        controller.endDrag(dragged: true, originalCoord: origin)
-
-        let target = GridCoord(row: 5, displayColumn: 1)
-        _ = controller.beginDrag(at: target, modifiers: .shift, focus: stale)
-        controller.endDrag(dragged: false, originalCoord: target)
-        #expect(controller.selection.rectangles == [GridRect(rows: 1...5, columns: 1...1)])
-
-        let added = GridCoord(row: 7, displayColumn: 3)
-        _ = controller.beginDrag(at: added, modifiers: .command, focus: stale)
-        controller.endDrag(dragged: false, originalCoord: added)
-        #expect(!controller.selection.contains(stale))
-        #expect(controller.selection.contains(added))
-    }
-
-    @Test("Cmd+click on the only selected cell clears the selection")
-    func cmdClickOnOnlyCellClears() {
-        let controller = GridSelectionController()
-        let cell = GridCoord(row: 3, displayColumn: 2)
-        _ = controller.beginDrag(at: cell, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: cell)
-        #expect(controller.selection.rectangles == [GridRect(cell: cell)])
-
-        _ = controller.beginDrag(at: cell, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: cell)
-        #expect(controller.selection.isEmpty)
-
-        _ = controller.beginDrag(at: cell, modifiers: .command, focus: cell)
-        controller.endDrag(dragged: false, originalCoord: cell)
-        #expect(controller.selection.isEmpty)
-    }
-
-    /// The toggle used to remove only a rectangle equal to the clicked cell and otherwise append
-    /// one, so the cell stayed selected and was counted twice.
-    @Test("Cmd+click inside a dragged block removes only that cell")
-    func cmdClickInsideBlockRemovesCell() {
-        let controller = GridSelectionController()
-        let top = GridCoord(row: 0, displayColumn: 0)
-        let bottom = GridCoord(row: 4, displayColumn: 0)
-        let middle = GridCoord(row: 2, displayColumn: 0)
-        _ = controller.beginDrag(at: top, modifiers: [])
-        controller.continueDrag(to: bottom)
-        controller.endDrag(dragged: true, originalCoord: top)
-
-        _ = controller.beginDrag(at: middle, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: middle)
-
-        #expect(!controller.selection.contains(middle))
-        #expect(controller.selection.uniqueCellCount == 4)
-        for row in [0, 1, 3, 4] {
-            #expect(controller.selection.contains(row: row, displayColumn: 0))
-        }
-        #expect(controller.selection.activeCell == bottom)
-    }
-
-    @Test("Cmd+click inside a picked column gives the heading back")
-    func cmdClickInsidePickedColumnDropsMarker() {
-        let controller = GridSelectionController()
-        controller.selectEntireColumn(1, totalRows: 4)
-        let cell = GridCoord(row: 2, displayColumn: 1)
-
-        _ = controller.beginDrag(at: cell, modifiers: .command)
-        controller.endDrag(dragged: false, originalCoord: cell)
-
-        #expect(controller.selectedFullColumns().isEmpty)
-        #expect(!controller.selection.contains(cell))
-        #expect(controller.selection.uniqueCellCount == 3)
-    }
-
-    @Test("the announcement counts overlapping cells once")
-    func announcementCountsUniqueCells() {
-        let controller = GridSelectionController()
-        let top = GridCoord(row: 0, displayColumn: 0)
-        let overlapStart = GridCoord(row: 2, displayColumn: 0)
-        _ = controller.beginDrag(at: top, modifiers: [])
-        controller.continueDrag(to: GridCoord(row: 4, displayColumn: 0))
-        controller.endDrag(dragged: true, originalCoord: top)
-        _ = controller.beginDrag(at: overlapStart, modifiers: .command)
-        controller.continueDrag(to: GridCoord(row: 6, displayColumn: 0))
-        controller.endDrag(dragged: true, originalCoord: overlapStart)
-
-        #expect(controller.selection.rectangles.count == 2)
-        #expect(controller.selection.uniqueCellCount == 7)
-        let expected = String(
-            format: String(localized: "%d cells selected, rows %d to %d, columns %d to %d"),
-            7, 1, 7, 1, 1
-        )
-        #expect(GridSelectionController.accessibilityAnnouncement(for: controller.selection) == expected)
-        #expect(GridSelectionController.accessibilityAnnouncement(for: .empty) == String(localized: "Cell selection cleared"))
-    }
-
-    @Test("inserted rows go through update and grow a picked column")
-    func applyInsertedRowsPublishes() {
-        let controller = GridSelectionController()
-        controller.selectEntireColumn(1, totalRows: 4)
-        var published: [GridSelection] = []
-        controller.onSelectionChange = { published.append($0) }
-
-        controller.applyInsertedRows(IndexSet(integersIn: 4...9), newRowCount: 10)
-
-        #expect(controller.selection.rectangles == [GridRect(rows: 0...9, columns: 1...1)])
-        #expect(controller.selectedFullColumns() == IndexSet(integer: 1))
-        #expect(published == [controller.selection])
-    }
-
-    @Test("removed rows go through update and can empty the selection")
-    func applyRemovedRowsPublishes() {
-        let controller = GridSelectionController()
-        let top = GridCoord(row: 2, displayColumn: 0)
-        _ = controller.beginDrag(at: top, modifiers: [])
-        controller.continueDrag(to: GridCoord(row: 3, displayColumn: 1))
-        controller.endDrag(dragged: true, originalCoord: top)
-        var published: [GridSelection] = []
-        controller.onSelectionChange = { published.append($0) }
-
-        controller.applyRemovedRows(IndexSet(integer: 0), newRowCount: 9)
-        #expect(controller.selection.rectangles == [GridRect(rows: 1...2, columns: 0...1)])
-
-        controller.applyRemovedRows(IndexSet(integersIn: 1...2), newRowCount: 7)
-        #expect(controller.selection.isEmpty)
-        #expect(published.count == 2)
-    }
-}
-
-@MainActor
-private final class PointerSeedLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private struct PointerSeedGrid {
-    let coordinator: TableViewCoordinator
-    let tableView: KeyHandlingTableView
-    let gutter: DataGridRowGutterView
-
-    init(rowCount: Int = 10) {
-        let columns = ["id", "name", "age", "city"]
-        let columnTypes = Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        let tableRows = TableRows.from(
-            queryRows: (0..<rowCount).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } },
-            columns: columns,
-            columnTypes: columnTypes
-        )
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: PointerSeedLayoutPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-
-        tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.allowsMultipleSelection = true
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.updateCache()
-        tableView.reloadData()
-
-        gutter = DataGridRowGutterView(frame: .zero)
-        gutter.coordinator = coordinator
-    }
-
-    /// A gutter click as the grid sees it: the row selection, then the cursor the selection change
-    /// seeds. Delivered by hand as well, so the seed does not depend on how the notification arrives.
-    func clickGutter(row: Int) {
-        gutter.selectRows(clickedRow: row, modifiers: [])
-        coordinator.tableViewSelectionDidChange(
-            Notification(name: NSTableView.selectionDidChangeNotification, object: tableView)
-        )
-    }
-
-    func press(_ key: KeyCode, modifiers: NSEvent.ModifierFlags = []) throws {
-        let event = try #require(NSEvent.keyEvent(
-            with: .keyDown,
-            location: .zero,
-            modifierFlags: modifiers,
-            timestamp: 0,
-            windowNumber: 0,
-            context: nil,
-            characters: "",
-            charactersIgnoringModifiers: "",
-            isARepeat: false,
-            keyCode: key.rawValue
-        ))
-        tableView.keyDown(with: event)
-    }
-}
-
-@MainActor
-struct GridPointerSeedTests {
-    /// The gutter clears the cursor, and the selection change it makes seeds one again on the first
-    /// column. Seeding a click from that cursor made it a selected cell the user never picked.
-    @Test("Cmd+click after a gutter row selection selects only the clicked cell")
-    func cmdClickAfterGutterSelectsOnlyClickedCell() {
-        let grid = PointerSeedGrid()
-        grid.clickGutter(row: 6)
-        #expect(grid.tableView.focusedRow == 6)
-        #expect(grid.tableView.presentsDataColumn(at: grid.tableView.focusedColumn))
-
-        #expect(grid.tableView.pointerSelectionSeed() == nil)
-
-        let controller = grid.coordinator.selectionController
-        let target = GridCoord(row: 8, displayColumn: 3)
-        _ = controller.beginDrag(at: target, modifiers: .command, focus: grid.tableView.pointerSelectionSeed())
-        controller.endDrag(dragged: false, originalCoord: target)
-        #expect(controller.selection.rectangles == [GridRect(cell: target)])
-    }
-
-    @Test("Shift+click after a gutter row selection does not range from the seeded cursor")
-    func shiftClickAfterGutterIgnoresSeededCursor() {
-        let grid = PointerSeedGrid()
-        grid.clickGutter(row: 6)
-
-        let controller = grid.coordinator.selectionController
-        let target = GridCoord(row: 8, displayColumn: 3)
-        _ = controller.beginDrag(at: target, modifiers: .shift, focus: grid.tableView.pointerSelectionSeed())
-        controller.endDrag(dragged: false, originalCoord: target)
-        #expect(controller.selection.rectangles == [GridRect(cell: target)])
-    }
-
-    @Test("Shift+Arrow after a gutter row selection still starts a range at the cursor")
-    func shiftArrowAfterGutterStillExtends() throws {
-        let grid = PointerSeedGrid()
-        grid.clickGutter(row: 6)
-
-        try grid.press(.downArrow, modifiers: .shift)
-
-        #expect(grid.coordinator.selectionController.selection.rectangles == [GridRect(rows: 6...7, columns: 0...0)])
-    }
-
-    @Test("moving the cursor with an arrow key after a gutter row selection makes it the user's")
-    func arrowAfterGutterMakesCursorSeedable() throws {
-        let grid = PointerSeedGrid()
-        grid.clickGutter(row: 6)
-
-        try grid.press(.rightArrow)
-
-        #expect(grid.tableView.pointerSelectionSeed() == GridCoord(row: 6, displayColumn: 1))
-    }
-
-    @Test("a cursor moved by Tab seeds a click")
-    func keyboardCursorSeeds() throws {
-        let grid = PointerSeedGrid()
-        let column = try #require(grid.coordinator.tableColumnIndex(for: 2))
-
-        grid.tableView.focusCell(row: 3, column: column)
-
-        #expect(grid.tableView.pointerSelectionSeed() == GridCoord(row: 3, displayColumn: 2))
-    }
-
-    @Test("Select All leaves no cursor to seed a click from")
-    func selectAllLeavesNoSeed() {
-        let grid = PointerSeedGrid()
-        grid.tableView.focusCell(row: 3, column: grid.coordinator.tableColumnIndex(for: 1) ?? -1)
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.tableView.pointerSelectionSeed() == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/ComparisonGridCopyTests.swift b/apple/TableProTests/Views/Results/ComparisonGridCopyTests.swift
index b8a07b9d94..01a93e1aa4 100644
--- a/apple/TableProTests/Views/Results/ComparisonGridCopyTests.swift
+++ b/apple/TableProTests/Views/Results/ComparisonGridCopyTests.swift
@@ -4,7 +4,6 @@
 //
 
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
@@ -13,20 +12,15 @@ extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
     struct ComparisonGridCopyTests {
-        private func copyFirstRow(through delegate: any DataGridViewDelegate, rows: TableRows) {
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: false,
-                selectedRowIndices: .constant([0]),
-                delegate: delegate,
-                layoutPersister: InMemoryColumnLayoutStore()
-            )
-            coordinator.tableRowsProvider = { rows }
-            coordinator.rebuildColumnMetadataCache(from: rows)
-            coordinator.updateCache()
-            delegate.dataGridAttach(tableViewCoordinator: coordinator)
-
-            coordinator.copyRows(at: [0], as: .rows)
+        // Copy Rows over the first line, the way Command-C copies a selected row of either comparison.
+        private func copyFirstRow(of model: DataGridModel) {
+            let lastColumn = model.columns.count - 1
+            model.setSelection(GridSelection(
+                rectangles: [GridRect(rows: 0...0, columns: 0...lastColumn)],
+                activeCell: GridCoord(row: 0, displayColumn: 0),
+                anchor: GridCoord(row: 0, displayColumn: 0)
+            ))
+            DataGridCommands(model: model).copy(.current(model.selection))
         }
 
         @Test("Copying a result comparison row puts the line on the clipboard")
@@ -40,9 +34,10 @@ extension GlobalStateSuites {
             )
             let pairing = ResultColumnPairing(left: side.columns, right: side.columns)
             let lines = ResultComparisonGridModel.lines(for: [ResultComparisonEntry(kind: .onlyLeft, leftRow: 0, rightRow: nil)])
-            let rows = ResultComparisonGridModel.tableRows(for: lines, left: side, right: side, pairing: pairing)
+            let comparison = ResultComparisonGridModel()
+            comparison.grid.setRows(ResultComparisonGridModel.tableRows(for: lines, left: side, right: side, pairing: pairing))
 
-            copyFirstRow(through: ResultComparisonGridModel(), rows: rows)
+            copyFirstRow(of: comparison.model)
 
             #expect(clipboard.text == "Only Left\tLeft\t7")
         }
@@ -50,13 +45,14 @@ extension GlobalStateSuites {
         @Test("Copying a Compare & Sync row puts the line on the clipboard")
         func compareSyncCopiesRows() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let rows = TableRows.from(
+            let compare = CompareRowGridModel()
+            compare.grid.setRows(TableRows.from(
                 queryRows: [[.text("Insert"), .text("Source"), .text("7")]],
                 columns: ["Change", "Side", "id"],
                 columnTypes: [.text(rawType: nil), .text(rawType: nil), .integer(rawType: nil)]
-            )
+            ))
 
-            copyFirstRow(through: CompareRowGridModel(), rows: rows)
+            copyFirstRow(of: compare.model)
 
             #expect(clipboard.text == "Insert\tSource\t7")
         }
diff --git a/apple/TableProTests/Views/Results/DataGridBodyChromeTests.swift b/apple/TableProTests/Views/Results/DataGridBodyChromeTests.swift
deleted file mode 100644
index 78f2c18cff..0000000000
--- a/apple/TableProTests/Views/Results/DataGridBodyChromeTests.swift
+++ /dev/null
@@ -1,325 +0,0 @@
-//
-//  DataGridBodyChromeTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import TableProTheme
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class BodyChromeLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// The grid draws its own column separators because `NSTableView` draws vertical grid lines with one
-/// separator view per column and re-sorts its whole subview list on every layout pass: 518ms for a
-/// single pass on a 500-column result, against 0.03ms with the mask cleared (#2381).
-///
-/// These measure through `rect(ofColumn:)` and through the rendered pixels, never through the chrome
-/// type's own arithmetic, so they cannot pass by agreeing with themselves.
-@MainActor
-struct DataGridBodyChromeTests {
-    private struct Grid {
-        let window: NSWindow
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-    }
-
-    private func makeGrid(columns: [String], rows: Int = 3, width: CGFloat = 600) -> Grid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: BodyChromeLayoutPersister()
-        )
-        let queryRows = (0 ..< rows).map { row in
-            columns.map { PluginCellValue.text("\($0)-\(row)") }
-        }
-        let tableRows = TableRows.from(
-            queryRows: queryRows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: width, height: 200))
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 120 }
-        )
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: width, height: 200))
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: width, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView = scrollView
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        window.layoutIfNeeded()
-        return Grid(window: window, tableView: tableView, coordinator: coordinator)
-    }
-
-    /// A partial repaint invalidates one cell's rect, and `rect(ofColumn:)` includes the intercell
-    /// spacing, so the next column's separator lives inside the rect being repainted. It has to be
-    /// redrawn there or every visited cell loses its right-hand rule until a full-row repaint.
-    @Test("Repainting one cell redraws the separator standing inside its rect")
-    func partialRepaintRedrawsTheSeparatorInsideIt() throws {
-        let grid = makeGrid(columns: ["id", "name", "total"])
-        let view = NSView(frame: grid.tableView.bounds)
-        let first = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let next = try #require(grid.coordinator.nextPresentedColumnIndex(after: first))
-        let cellRect = grid.tableView.rect(ofColumn: first)
-        let neighbourSeparator = grid.tableView.rect(ofColumn: next).minX - DataGridBodyChrome.separatorThickness
-
-        #expect(
-            neighbourSeparator >= cellRect.minX && neighbourSeparator < cellRect.maxX,
-            "the neighbour's separator sits inside the repainted cell's rect, so the repaint erases it"
-        )
-
-        let separators = DataGridBodyChrome.separatorRects(
-            in: cellRect,
-            of: view,
-            tableView: grid.tableView,
-            presentsColumn: { grid.coordinator.presentsColumn(atTableColumnIndex: $0) }
-        )
-
-        #expect(separators.map(\.minX).contains(neighbourSeparator))
-    }
-
-    /// AppKit put its separator at the leading edge of every column, which is the boundary the
-    /// reader sees between two columns and the one that keeps the row-number column's edge.
-    @Test("A separator stands at the leading edge of every presented column")
-    func separatorsSitAtPresentedColumnLeadingEdges() {
-        let grid = makeGrid(columns: ["id", "name", "total"])
-        let view = NSView(frame: grid.tableView.bounds)
-
-        let separators = DataGridBodyChrome.separatorRects(
-            in: view.bounds,
-            of: view,
-            tableView: grid.tableView,
-            presentsColumn: { grid.coordinator.presentsColumn(atTableColumnIndex: $0) }
-        )
-
-        let expected = grid.tableView.tableColumns.indices
-            .filter { grid.coordinator.presentsColumn(atTableColumnIndex: $0) }
-            .map { grid.tableView.rect(ofColumn: $0).minX - DataGridBodyChrome.separatorThickness }
-        #expect(!expected.isEmpty)
-        #expect(separators.map(\.minX) == expected)
-        #expect(separators.allSatisfy { $0.width == DataGridBodyChrome.separatorThickness })
-    }
-
-    /// The row-number column is an attached column that the result does not present, so it gets no
-    /// separator of its own; the boundary the reader sees there is the first data column's edge.
-    @Test("The row-number column is not given a separator of its own")
-    func rowNumberColumnHasNoSeparator() {
-        let grid = makeGrid(columns: ["id", "name"])
-        let rowNumber = grid.tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-
-        #expect(rowNumber >= 0)
-        #expect(!grid.coordinator.presentsColumn(atTableColumnIndex: rowNumber))
-    }
-
-    /// `NSTableView`'s own grid colour is `separatorColor`, not `NSColor.gridColor`, which in dark
-    /// mode is darker than the rows it separates. A theme that declares no grid line has to leave the
-    /// table on that default, and a table a previous theme recoloured has to go back to it.
-    @Test("Without a theme override the table keeps AppKit's own grid and background colours")
-    func defaultThemeKeepsTheTableDefaults() {
-        let engine = ThemeEngine.shared
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-        engine.adopt(ThemeSelection(pair: .builtIn, effectiveAppearance: .light))
-
-        let tableView = NSTableView()
-        let stock = NSTableView()
-        tableView.gridColor = .systemRed
-        tableView.backgroundColor = .systemRed
-        DataGridBodyChrome.applyThemeColors(to: tableView, scope: .live)
-
-        #expect(tableView.gridColor == .separatorColor)
-        #expect(tableView.gridColor == stock.gridColor)
-        #expect(tableView.backgroundColor == .controlBackgroundColor)
-        #expect(tableView.backgroundColor == stock.backgroundColor)
-    }
-
-    @Test("A theme's grid line and background become the table's colours")
-    func themeOverridesBecomeTheTableColors() throws {
-        let engine = ThemeEngine.shared
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-        var theme = BuiltInThemes.light
-        theme.id = "test.body-chrome"
-        theme.overrides[.gridLine] = try ThemeColor(validating: "#FF0000")
-        theme.overrides[.gridBackground] = try ThemeColor(validating: "#102030")
-        engine.adopt(ThemeSelection(pair: ThemePair(light: theme, dark: BuiltInThemes.dark), effectiveAppearance: .light))
-
-        let tableView = NSTableView()
-        DataGridBodyChrome.applyThemeColors(to: tableView, scope: .live)
-
-        #expect(tableView.gridColor == engine.resolved[.gridLine])
-        #expect(tableView.backgroundColor == engine.resolved[.gridBackground])
-        #expect(tableView.gridColor != .separatorColor)
-    }
-
-    /// The colour has to come from `tableView.gridColor`, which is the dynamic catalog colour AppKit
-    /// fills with, so an appearance change carries the separator with it and there is no second
-    /// spelling to keep in sync. A hardcoded colour would pass a geometry test and be wrong in dark
-    /// mode.
-    @Test("The separator is drawn in the table view's own grid colour")
-    func separatorUsesTheTableViewGridColor() throws {
-        let grid = makeGrid(columns: ["id", "name"])
-        grid.tableView.gridColor = .systemRed
-        let rowView = try #require(grid.tableView.rowView(atRow: 0, makeIfNecessary: true) as? DataGridRowView)
-        rowView.layoutSubtreeIfNeeded()
-
-        let rep = try #require(rowView.bitmapImageRepForCachingDisplay(in: rowView.bounds))
-        rowView.cacheDisplay(in: rowView.bounds, to: rep)
-
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let boundary = grid.tableView.rect(ofColumn: firstData).minX
-        let scale = CGFloat(rep.pixelsWide) / rowView.bounds.width
-        let sampled = rep.colorAt(
-            x: Int((boundary - 0.5) * scale),
-            y: Int(rowView.bounds.height * scale / 2)
-        )?.usingColorSpace(.deviceRGB)
-        let expected = NSColor.systemRed.usingColorSpace(.deviceRGB)
-
-        let sampledRed = try #require(sampled?.redComponent)
-        let sampledGreen = try #require(sampled?.greenComponent)
-        let expectedRed = try #require(expected?.redComponent)
-        #expect(abs(sampledRed - expectedRed) < 0.15)
-        #expect(sampledRed > sampledGreen + 0.3, "the separator has to carry the grid colour, not a fixed grey")
-    }
-
-    /// `NSTableView` continues the alternation past the last row one row height at a time, numbered
-    /// on from it, and the grid now paints those bands itself.
-    @Test("Past the last row, bands continue one row apart, numbered on from the last row")
-    func bandsContinuePastTheLastRow() throws {
-        let grid = makeGrid(columns: ["id", "name"], rows: 3)
-        let bounds = grid.tableView.bounds
-        let bands = DataGridBodyChrome.rowBands(in: bounds, of: grid.tableView, tableView: grid.tableView)
-
-        let rows = Array(bands.prefix(3))
-        let past = Array(bands.dropFirst(3))
-        let rowIndexes = rows.map { $0.row }
-        let rowsAreTableRows = rows.allSatisfy { $0.isTableRow }
-        let pastIndexes = past.map { $0.row }
-        let pastAreTableRows = past.contains { $0.isTableRow }
-
-        #expect(rowIndexes == [0, 1, 2])
-        #expect(rowsAreTableRows)
-        #expect(!past.isEmpty)
-        #expect(pastIndexes == Array(3..<(3 + past.count)))
-        #expect(!pastAreTableRows)
-        let lastRowBottom = grid.tableView.rect(ofRow: 2).maxY
-        for (offset, band) in past.enumerated() {
-            #expect(band.rect.minY == lastRowBottom + CGFloat(offset) * grid.tableView.rowHeight)
-            #expect(band.rect.height == grid.tableView.rowHeight)
-        }
-        let lastBand = try #require(past.last)
-        #expect(lastBand.rect.maxY >= bounds.maxY)
-    }
-
-    /// `NSTableView` blends the dark alternate stripe in twice past the last row (52 against a row's
-    /// 40, measured on screen), so its empty rows read brighter than the rows above them. The grid
-    /// paints that area itself, the stripe blended once over the table's colour, which is what a row
-    /// shows.
-    ///
-    /// Measured through the drawing itself rather than a cached drawing of the table: offscreen,
-    /// `cacheDisplay` runs a second alternating pass of `NSTableView`'s own that the table never shows
-    /// on screen (54 against 41), so a cached table cannot tell the two paintings apart.
-    @Test("Past the last row the table blends each stripe once, as a row does")
-    func stripesPastTheLastRowAreBlendedOnce() throws {
-        let grid = makeGrid(columns: ["id", "name"], rows: 1)
-        grid.tableView.usesAlternatingRowBackgroundColors = true
-        let dark = try #require(NSAppearance(named: .darkAqua))
-        let bounds = grid.tableView.bounds
-        let bands = DataGridBodyChrome.rowBands(in: bounds, of: grid.tableView, tableView: grid.tableView)
-        let oddBand = try #require(bands.first { !$0.isTableRow && !$0.row.isMultiple(of: 2) })
-
-        let rep = try #require(NSBitmapImageRep(
-            bitmapDataPlanes: nil,
-            pixelsWide: Int(bounds.width),
-            pixelsHigh: Int(bounds.height),
-            bitsPerSample: 8,
-            samplesPerPixel: 4,
-            hasAlpha: true,
-            isPlanar: false,
-            colorSpaceName: .deviceRGB,
-            bytesPerRow: 0,
-            bitsPerPixel: 0
-        ))
-        let context = try #require(NSGraphicsContext(bitmapImageRep: rep))
-        NSGraphicsContext.saveGraphicsState()
-        NSGraphicsContext.current = context
-        context.cgContext.translateBy(x: 0, y: bounds.height)
-        context.cgContext.scaleBy(x: 1, y: -1)
-        dark.performAsCurrentDrawingAppearance {
-            DataGridBodyChrome.drawTableBackground(in: bounds, of: grid.tableView, scope: .live)
-        }
-        NSGraphicsContext.restoreGraphicsState()
-
-        let sampled = try #require(rep.colorAt(x: 300, y: Int(oddBand.rect.midY))?.usingColorSpace(.sRGB))
-        let expected = try #require(singleBlend(over: .controlBackgroundColor, of: oddBand.row, appearance: dark))
-
-        #expect(abs(sampled.redComponent - expected.redComponent) < 0.02, "sampled \(sampled), expected \(expected)")
-        #expect(abs(sampled.greenComponent - expected.greenComponent) < 0.02)
-        #expect(abs(sampled.blueComponent - expected.blueComponent) < 0.02)
-    }
-
-    /// The colour of one alternate stripe blended once over `background`, drawn into a single pixel.
-    private func singleBlend(over background: NSColor, of row: Int, appearance: NSAppearance) -> NSColor? {
-        guard let rep = NSBitmapImageRep(
-            bitmapDataPlanes: nil,
-            pixelsWide: 1,
-            pixelsHigh: 1,
-            bitsPerSample: 8,
-            samplesPerPixel: 4,
-            hasAlpha: true,
-            isPlanar: false,
-            colorSpaceName: .deviceRGB,
-            bytesPerRow: 0,
-            bitsPerPixel: 0
-        ), let context = NSGraphicsContext(bitmapImageRep: rep) else { return nil }
-        NSGraphicsContext.saveGraphicsState()
-        NSGraphicsContext.current = context
-        appearance.performAsCurrentDrawingAppearance {
-            let pixel = NSRect(x: 0, y: 0, width: 1, height: 1)
-            background.setFill()
-            pixel.fill()
-            let stripes = NSColor.alternatingContentBackgroundColors
-            stripes[row % stripes.count].setFill()
-            pixel.fill(using: .sourceOver)
-        }
-        NSGraphicsContext.restoreGraphicsState()
-        return rep.colorAt(x: 0, y: 0)?.usingColorSpace(.sRGB)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridCellAccessoryAppearanceTests.swift b/apple/TableProTests/Views/Results/DataGridCellAccessoryAppearanceTests.swift
deleted file mode 100644
index a6fbe8b99a..0000000000
--- a/apple/TableProTests/Views/Results/DataGridCellAccessoryAppearanceTests.swift
+++ /dev/null
@@ -1,158 +0,0 @@
-//
-//  DataGridCellAccessoryAppearanceTests.swift
-//  TableProTests
-//
-
-import AppKit
-@testable import TablePro
-import Testing
-
-@MainActor
-struct DataGridCellAccessoryAppearanceTests {
-    private struct InkMetrics {
-        let coverage: Double
-        let brightness: Double
-        let width: Double
-        let height: Double
-    }
-
-    /// A cell is drawn rather than mounted, so this renders one through the renderer the grid uses
-    /// and reads the accessory rect back off the bitmap. The text stays empty so only the accessory
-    /// contributes ink.
-    private final class RenderedCellView: NSView {
-        var appearanceToDraw: DataGridCellAppearance?
-        private let renderer = DataGridCellRenderer()
-        override var isFlipped: Bool { true }
-        override func draw(_ dirtyRect: NSRect) {
-            guard let appearanceToDraw else { return }
-            renderer.draw(appearanceToDraw, in: bounds)
-        }
-    }
-
-    private func makeCell(kind: DataGridCellKind, appearance: NSAppearance) -> NSView {
-        let cell = RenderedCellView(frame: NSRect(x: 0, y: 0, width: 120, height: 24))
-        cell.appearance = appearance
-        cell.appearanceToDraw = DataGridCellAppearance.resolve(
-            kind: kind,
-            content: DataGridCellContent(displayText: "", rawValue: "42", placeholder: nil),
-            state: DataGridCellState(
-                visualState: .empty,
-                isFocused: false,
-                isEditable: true,
-                isLargeDataset: false,
-                row: 0,
-                columnIndex: 0
-            ),
-            palette: .placeholder,
-            nullDisplayString: "NULL",
-            onEmphasizedSelection: false,
-            hasOverlay: false
-        )
-        return cell
-    }
-
-    private func accessoryInk(
-        kind: DataGridCellKind,
-        accessory: DataGridCellAccessory,
-        appearanceName: NSAppearance.Name
-    ) throws -> InkMetrics {
-        let appearance = try #require(NSAppearance(named: appearanceName))
-        let cell = makeCell(kind: kind, appearance: appearance)
-        let rep = try #require(cell.bitmapImageRepForCachingDisplay(in: cell.bounds))
-        cell.cacheDisplay(in: cell.bounds, to: rep)
-        #expect(rep.hasAlpha)
-
-        let scale = max(1, rep.pixelsWide / Int(cell.bounds.width))
-        let frame = accessory.frame(in: cell.bounds)
-
-        var minX = Int.max
-        var maxX = Int.min
-        var minY = Int.max
-        var maxY = Int.min
-        var ink = 0
-        var total = 0
-        var brightnessSum = 0.0
-        for y in Int(frame.minY) * scale ..< Int(frame.maxY) * scale {
-            for x in Int(frame.minX) * scale ..< Int(frame.maxX) * scale {
-                total += 1
-                guard let color = rep.colorAt(x: x, y: y), color.alphaComponent > 0.1 else { continue }
-                ink += 1
-                minX = min(minX, x)
-                maxX = max(maxX, x)
-                minY = min(minY, y)
-                maxY = max(maxY, y)
-                if let srgb = color.usingColorSpace(.sRGB) {
-                    brightnessSum += (srgb.redComponent + srgb.greenComponent + srgb.blueComponent) / 3
-                }
-            }
-        }
-        guard ink > 0, total > 0 else {
-            return InkMetrics(coverage: 0, brightness: 0, width: 0, height: 0)
-        }
-        return InkMetrics(
-            coverage: Double(ink) / Double(total),
-            brightness: brightnessSum / Double(ink),
-            width: Double(maxX - minX + 1) / Double(scale),
-            height: Double(maxY - minY + 1) / Double(scale)
-        )
-    }
-
-    /// Asserting the direction of the change, not just that it changed. Inequality alone still
-    /// passes if the two appearances are ever served each other's bitmap.
-    private func expectFollowsAppearance(
-        kind: DataGridCellKind,
-        accessory: DataGridCellAccessory
-    ) throws {
-        let light = try accessoryInk(kind: kind, accessory: accessory, appearanceName: .aqua)
-        let dark = try accessoryInk(kind: kind, accessory: accessory, appearanceName: .darkAqua)
-
-        #expect(light.coverage > 0.05)
-        #expect(dark.coverage > 0.05)
-        #expect(light.brightness < 0.5)
-        #expect(dark.brightness > 0.5)
-    }
-
-    @Test("The foreign key arrow takes its colour from the light appearance")
-    func foreignKeyArrowFollowsAppearance() throws {
-        try expectFollowsAppearance(kind: .foreignKey, accessory: .foreignKey)
-    }
-
-    @Test("The chevron takes its colour from the appearance too")
-    func chevronFollowsAppearance() throws {
-        try expectFollowsAppearance(kind: .json, accessory: .chevron)
-    }
-
-    /// The glyph cache is process-wide, and nothing orders this against the tests above or against
-    /// any other suite that renders a cell, so this cannot observe a genuine first draw. What it
-    /// does check is that reading dark before light gives the same answer as the reverse.
-    @Test("Rendering order does not change what either appearance gets")
-    func renderingIsOrderIndependent() throws {
-        let darkFirst = try accessoryInk(kind: .foreignKey, accessory: .foreignKey, appearanceName: .darkAqua)
-        let lightSecond = try accessoryInk(kind: .foreignKey, accessory: .foreignKey, appearanceName: .aqua)
-
-        #expect(darkFirst.brightness > 0.5)
-        #expect(lightSecond.brightness < 0.5)
-    }
-
-    /// Stretching the chevron to fill its 12 x 14 rect measures 9.0pt wide, drawing it at its own
-    /// 9 x 12 point size measures 6.5pt.
-    @Test("The chevron draws at its own size instead of stretching to fill its rect")
-    func chevronKeepsItsNaturalWidth() throws {
-        let ink = try accessoryInk(kind: .json, accessory: .chevron, appearanceName: .darkAqua)
-
-        #expect(ink.width > 4)
-        #expect(ink.width <= 8)
-    }
-
-    /// The bare arrow covers 0.097 of the accessory rect and measures 11 x 9. Any enclosing shape
-    /// takes it back to the circled variant's square 14 x 14 at 0.255, and a filled badge to 0.594.
-    @Test("The foreign key accessory is a bare arrow with nothing drawn around it")
-    func foreignKeyArrowHasNoEnclosingShape() throws {
-        let ink = try accessoryInk(kind: .foreignKey, accessory: .foreignKey, appearanceName: .darkAqua)
-
-        #expect(ink.coverage > 0.05)
-        #expect(ink.coverage < 0.18)
-        #expect(ink.width > ink.height)
-        #expect(ink.width <= 12)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridCellFactoryPerfTests.swift b/apple/TableProTests/Views/Results/DataGridCellFactoryPerfTests.swift
deleted file mode 100644
index de62cfe21d..0000000000
--- a/apple/TableProTests/Views/Results/DataGridCellFactoryPerfTests.swift
+++ /dev/null
@@ -1,422 +0,0 @@
-//
-//  DataGridCellFactoryPerfTests.swift
-//  TableProTests
-//
-
-import Foundation
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct ColumnWidthOptimizationTests {
-    private func tableRows(
-        value: String,
-        columnType: ColumnType,
-        foreignKey: ForeignKeyInfo? = nil
-    ) -> TableRows {
-        TableRows.from(
-            queryRows: [[.text(value)]],
-            columns: ["x"],
-            columnTypes: [columnType],
-            columnForeignKeys: foreignKey.map { ["x": $0] } ?? [:],
-            foreignKeysFetched: foreignKey != nil
-        )
-    }
-
-    private func optimalWidth(
-        for tableRows: TableRows,
-        accessory: DataGridCellAccessory = .none
-    ) -> CGFloat {
-        DataGridCellFactory().calculateOptimalColumnWidth(
-            for: "x",
-            columnIndex: 0,
-            tableRows: tableRows,
-            accessory: accessory
-        )
-    }
-
-    @Test("Column width is within min/max bounds")
-    func columnWidthWithinBounds() {
-        let factory = DataGridCellFactory()
-        let tableRows = TestFixtures.makeTableRows(rowCount: 10)
-
-        for (index, column) in tableRows.columns.enumerated() {
-            let width = factory.calculateOptimalColumnWidth(
-                for: column,
-                columnIndex: index,
-                tableRows: tableRows
-            )
-            #expect(width >= 60, "Width should be at least 60 (min)")
-            #expect(width <= 800, "Width should be at most 800 (max)")
-        }
-    }
-
-    @Test("Header-only column returns reasonable width")
-    func headerOnlyColumnWidth() {
-        let factory = DataGridCellFactory()
-        let tableRows = TableRows.from(
-            queryRows: [],
-            columns: ["username"],
-            columnTypes: [.text(rawType: nil)]
-        )
-
-        let width = factory.calculateOptimalColumnWidth(
-            for: "username",
-            columnIndex: 0,
-            tableRows: tableRows
-        )
-        #expect(width >= 60)
-        #expect(width <= 800)
-    }
-
-    @Test("Empty header with no rows returns minimum width")
-    func emptyHeaderNoRowsReturnsMinWidth() {
-        let factory = DataGridCellFactory()
-        let tableRows = TableRows.from(
-            queryRows: [],
-            columns: [""],
-            columnTypes: [.text(rawType: nil)]
-        )
-
-        let width = factory.calculateOptimalColumnWidth(
-            for: "",
-            columnIndex: 0,
-            tableRows: tableRows
-        )
-        #expect(width >= 60, "Should return at least minimum width")
-    }
-
-    @Test("Very long cell content caps width at maximum")
-    func longContentCapsAtMax() {
-        let factory = DataGridCellFactory()
-        let longValue = String(repeating: "X", count: 5_000)
-        let rawRows: [[String?]] = [[longValue]]
-        let tableRows = TableRows.from(
-            queryRows: rawRows.map { row in row.map(PluginCellValue.fromOptional) },
-            columns: ["data"],
-            columnTypes: [.text(rawType: nil)]
-        )
-
-        let width = factory.calculateOptimalColumnWidth(
-            for: "data",
-            columnIndex: 0,
-            tableRows: tableRows
-        )
-        #expect(width <= 800, "Width should be capped at max (800)")
-    }
-
-    @Test("Many columns still produce valid widths")
-    func manyColumnsProduceValidWidths() {
-        let factory = DataGridCellFactory()
-        let columnCount = 60
-        let columns = (0..<columnCount).map { "col_\($0)" }
-        let columnTypes = Array(repeating: ColumnType.text(rawType: nil), count: columnCount)
-        let rawRows: [[String?]] = (0..<100).map { rowIdx in
-            columns.map { "\($0)_val_\(rowIdx)" }
-        }
-        let tableRows = TableRows.from(queryRows: rawRows.map { row in row.map(PluginCellValue.fromOptional) }, columns: columns, columnTypes: columnTypes)
-
-        for (index, column) in columns.enumerated() {
-            let width = factory.calculateOptimalColumnWidth(
-                for: column,
-                columnIndex: index,
-                tableRows: tableRows
-            )
-            #expect(width >= 60)
-            #expect(width <= 800)
-        }
-    }
-
-    @Test("Nil cell values do not crash width calculation")
-    func nilCellValuesSafe() {
-        let factory = DataGridCellFactory()
-        let rawRows: [[String?]] = [
-            [nil],
-            ["hello"],
-            [nil],
-        ]
-        let tableRows = TableRows.from(
-            queryRows: rawRows.map { row in row.map(PluginCellValue.fromOptional) },
-            columns: ["name"],
-            columnTypes: [.text(rawType: nil)]
-        )
-
-        let width = factory.calculateOptimalColumnWidth(
-            for: "name",
-            columnIndex: 0,
-            tableRows: tableRows
-        )
-        #expect(width >= 60)
-        #expect(width <= 800)
-    }
-
-    @Test("Automatic width includes the exact trailing action footprint")
-    func automaticWidthIncludesTrailingAction() {
-        let value = String(repeating: "M", count: 20)
-        let plainWidth = optimalWidth(for: tableRows(value: value, columnType: .text(rawType: "TEXT")))
-        let dateWidth = optimalWidth(
-            for: tableRows(value: value, columnType: .date(rawType: "DATE")),
-            accessory: .chevron
-        )
-        let foreignKeyWidth = optimalWidth(for: tableRows(
-            value: value,
-            columnType: .text(rawType: "TEXT"),
-            foreignKey: TestFixtures.makeForeignKeyInfo(column: "x")
-        ), accessory: .foreignKey)
-
-        #expect(dateWidth == plainWidth + 16)
-        #expect(foreignKeyWidth == plainWidth + 20)
-    }
-
-    @Test("Automatic width measures the displayed empty placeholder beside an action")
-    func automaticWidthMeasuresEmptyPlaceholder() {
-        let rows = tableRows(value: "", columnType: .date(rawType: "DATE"))
-        let width = optimalWidth(for: rows, accessory: .chevron)
-        let displayedWidth = CGFloat((String(localized: "Empty") as NSString).length)
-            * ThemeEngine.shared.dataGridFonts.monoCharWidth
-
-        #expect(width - DataGridCellAccessory.chevron.measurementPadding >= displayedWidth)
-    }
-
-    @Test("An enum column reserves its dropdown before the allowed values arrive")
-    func enumColumnReservesDropdownBeforeValuesArrive() {
-        let presentation = DataGridColumnPresentation.resolve(
-            columnType: .enumType(rawType: "ENUM", values: nil),
-            isForeignKey: false,
-            isDropdown: false,
-            isTypePicker: false,
-            isEnumOrSet: false,
-            isEditable: true
-        )
-
-        #expect(presentation.kind == .dropdown)
-        #expect(presentation.accessory == .chevron)
-    }
-
-    @Test("A SET column reserves its dropdown before the allowed values arrive")
-    func setColumnReservesDropdownBeforeValuesArrive() {
-        let presentation = DataGridColumnPresentation.resolve(
-            columnType: .set(rawType: "SET", values: nil),
-            isForeignKey: false,
-            isDropdown: false,
-            isTypePicker: false,
-            isEnumOrSet: false,
-            isEditable: true
-        )
-
-        #expect(presentation.kind == .dropdown)
-        #expect(presentation.accessory == .chevron)
-    }
-
-    @Test("A read-only enum column reserves nothing")
-    func readOnlyEnumColumnReservesNothing() {
-        let presentation = DataGridColumnPresentation.resolve(
-            columnType: .enumType(rawType: "ENUM", values: nil),
-            isForeignKey: false,
-            isDropdown: false,
-            isTypePicker: false,
-            isEnumOrSet: false,
-            isEditable: false
-        )
-
-        #expect(presentation.accessory == .none)
-    }
-
-    @Test("An explicit fit measures a value the automatic sample steps over")
-    func explicitFitMeasuresValueTheSampleSkips() {
-        let short = String(repeating: "M", count: 10)
-        let long = String(repeating: "M", count: 60)
-        var values = Array(repeating: short, count: 1_000)
-        values[5] = long
-        let rows = TableRows.from(
-            queryRows: values.map { [PluginCellValue.text($0)] },
-            columns: ["title"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let factory = DataGridCellFactory()
-        let charWidth = ThemeEngine.shared.dataGridFonts.monoCharWidth
-
-        let automatic = factory.calculateOptimalColumnWidth(for: "title", columnIndex: 0, tableRows: rows)
-        let fitted = factory.calculateFitToContentWidth(
-            for: "title",
-            columnIndex: 0,
-            tableRows: rows,
-            availableWidth: 4_000
-        )
-
-        #expect(automatic < CGFloat(long.count) * charWidth)
-        #expect(fitted >= CGFloat(long.count) * charWidth + DataGridCellAccessory.none.measurementPadding)
-    }
-}
-
-@MainActor
-struct FitToContentWidthTests {
-    private func makeTableRows(values: [String], column: String = "data") -> TableRows {
-        TableRows.from(
-            queryRows: values.map { [PluginCellValue.fromOptional($0)] },
-            columns: [column],
-            columnTypes: [.text(rawType: nil)]
-        )
-    }
-
-    private func fitWidth(values: [String], availableWidth: CGFloat, column: String = "data") -> CGFloat {
-        DataGridCellFactory().calculateFitToContentWidth(
-            for: column,
-            columnIndex: 0,
-            tableRows: makeTableRows(values: values, column: column),
-            availableWidth: availableWidth
-        )
-    }
-
-    @Test("A very long value is capped instead of stretching the column")
-    func longValueIsCapped() {
-        let width = fitWidth(values: [String(repeating: "X", count: 5_000)], availableWidth: 1_600)
-
-        #expect(width == 800, "A 5,000 character value must not widen the column past the 800pt ceiling")
-    }
-
-    @Test("No column takes more than half the visible grid")
-    func capIsHalfTheVisibleGrid() {
-        let width = fitWidth(values: [String(repeating: "X", count: 5_000)], availableWidth: 1_000)
-
-        #expect(width == 500)
-    }
-
-    @Test("Cap holds at 300pt in a narrow window")
-    func capFloorsInNarrowWindow() {
-        #expect(fitWidth(values: [String(repeating: "X", count: 5_000)], availableWidth: 200) == 300)
-        #expect(fitWidth(values: [String(repeating: "X", count: 5_000)], availableWidth: 0) == 300)
-    }
-
-    @Test("Short values still size to their content, not to the cap")
-    func shortValuesSizeToContent() {
-        let width = fitWidth(values: ["ok", "fine"], availableWidth: 1_600, column: "status")
-
-        #expect(width >= 60)
-        #expect(width < 300, "The cap is a ceiling, not a target width")
-    }
-
-    @Test("Fitted width never exceeds the data column ceiling")
-    func fittedWidthStaysUnderColumnCeiling() {
-        for availableWidth in [CGFloat](stride(from: 0, through: 4_000, by: 250)) {
-            let width = fitWidth(values: [String(repeating: "X", count: 20_000)], availableWidth: availableWidth)
-            #expect(width <= DataGridMetrics.dataColumnMaxWidth)
-        }
-    }
-
-    @Test("Long header alone does not stretch the column")
-    func longHeaderIsCapped() {
-        let column = String(repeating: "column_name_", count: 200)
-        let width = fitWidth(values: [], availableWidth: 1_600, column: column)
-
-        #expect(width == 800)
-    }
-
-    @Test("Fit to content includes the exact trailing action footprint")
-    func fitToContentIncludesTrailingAction() {
-        let value = String(repeating: "M", count: 20)
-        let plainRows = TableRows.from(
-            queryRows: [[.text(value)]],
-            columns: ["x"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let dateRows = TableRows.from(
-            queryRows: [[.text(value)]],
-            columns: ["x"],
-            columnTypes: [.date(rawType: "DATE")]
-        )
-        let foreignKeyRows = TableRows.from(
-            queryRows: [[.text(value)]],
-            columns: ["x"],
-            columnTypes: [.text(rawType: "TEXT")],
-            columnForeignKeys: ["x": TestFixtures.makeForeignKeyInfo(column: "x")],
-            foreignKeysFetched: true
-        )
-        let factory = DataGridCellFactory()
-
-        func width(
-            for rows: TableRows,
-            accessory: DataGridCellAccessory = .none
-        ) -> CGFloat {
-            factory.calculateFitToContentWidth(
-                for: "x",
-                columnIndex: 0,
-                tableRows: rows,
-                availableWidth: 1_600,
-                accessory: accessory
-            )
-        }
-
-        #expect(width(for: dateRows, accessory: .chevron) == width(for: plainRows) + 16)
-        #expect(width(for: foreignKeyRows, accessory: .foreignKey) == width(for: plainRows) + 20)
-    }
-}
-
-struct ChangeReapplyVersionTests {
-    @Test("Version tracking skips redundant work")
-    func versionTrackingSkipsRedundantWork() {
-        var lastVersion = 0
-        var applyCount = 0
-        let currentVersion = 3
-
-        func reapplyIfNeeded(version: Int) {
-            guard lastVersion != version else { return }
-            lastVersion = version
-            applyCount += 1
-        }
-
-        reapplyIfNeeded(version: currentVersion)
-        #expect(applyCount == 1)
-        #expect(lastVersion == 3)
-
-        reapplyIfNeeded(version: currentVersion)
-        #expect(applyCount == 1, "Should skip when version unchanged")
-
-        reapplyIfNeeded(version: 4)
-        #expect(applyCount == 2, "Should apply when version changes")
-        #expect(lastVersion == 4)
-    }
-
-    @Test("Version starts at zero and tracks increments")
-    func versionStartsAtZeroAndIncrements() {
-        var lastVersion = 0
-        var versions: [Int] = []
-
-        for v in [0, 1, 1, 2, 2, 2, 3] {
-            if lastVersion != v {
-                lastVersion = v
-                versions.append(v)
-            }
-        }
-
-        #expect(versions == [1, 2, 3], "Only version changes should be recorded")
-    }
-
-    @Test("DataChangeManager reloadVersion increments on cell change")
-    @MainActor
-    /// `reloadVersion` is the signal that tells the grid to throw away what it is showing and fetch
-    /// again. It increments on `clearChanges`, `discardChanges` and `configureForTable`, and
-    /// deliberately not on recording an edit: a reload there would discard the very edit the user
-    /// just made. These asserted the opposite, which is why they sat in the quarantine file, so
-    /// each now pins the real contract from both sides.
-    func recordingAnEditDoesNotAskTheGridToReload() {
-        let manager = DataChangeManager()
-        let initialVersion = manager.reloadVersion
-
-        manager.recordCellChange(
-            rowID: .existing(0),
-            columnIndex: 0,
-            columnName: "name",
-            oldValue: "old",
-            newValue: "new"
-        )
-
-        #expect(manager.reloadVersion == initialVersion)
-
-        manager.discardChanges()
-
-        #expect(manager.reloadVersion == initialVersion + 1)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridColumnGeometryRepaintTests.swift b/apple/TableProTests/Views/Results/DataGridColumnGeometryRepaintTests.swift
deleted file mode 100644
index fd0faadc1f..0000000000
--- a/apple/TableProTests/Views/Results/DataGridColumnGeometryRepaintTests.swift
+++ /dev/null
@@ -1,737 +0,0 @@
-//
-//  DataGridColumnGeometryRepaintTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class NoopColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// Serves row views that count their own draws. A dirty flag cannot show a drag step: the display
-/// pass runs inside the header's tracking loop, so a row dirtied by one step is drawn and clean
-/// again before anything outside the loop can read it.
-@MainActor
-private final class DrawCountingRowViewSource: DataGridViewDelegate {
-    var rowDraws = 0
-
-    func dataGridRowView(for tableView: NSTableView, row: Int, coordinator: TableViewCoordinator) -> NSTableRowView? {
-        let rowView = DrawCountingRowView()
-        rowView.coordinator = coordinator
-        rowView.rowIndex = row
-        rowView.source = self
-        return rowView
-    }
-}
-
-@MainActor
-private final class DrawCountingRowView: DataGridRowView {
-    weak var source: DrawCountingRowViewSource?
-
-    override func drawBackground(in dirtyRect: NSRect) {
-        source?.rowDraws += 1
-        super.drawBackground(in: dirtyRect)
-    }
-}
-
-/// Drags a header divider or heading through AppKit's own tracking loop. `NSTableHeaderView.mouseDown` runs a
-/// modal loop in `.eventTracking` that dequeues every event itself, so a timer in that mode is how
-/// code runs between two steps, and the events it posts are the ones the loop reads.
-@MainActor
-private final class HeaderDividerDrag {
-    struct Sample {
-        let resizedColumn: Int
-        let draggedColumn: Int
-        let width: CGFloat
-        let tableWidth: CGFloat
-        let resizeNotifications: Int
-        let moveNotifications: Int
-        let rowDraws: Int
-        let cacheAgrees: Bool
-    }
-
-    private static let defaultSteps = 6
-    /// Long enough for the loop to take one step and draw it before the next tick. Posted faster,
-    /// the drags queue up and AppKit takes several of them as one step.
-    private static let tickInterval: TimeInterval = 0.08
-    /// A loop that never read the release would never return, so the release is posted again on
-    /// later ticks, a bounded number of times.
-    private static let releaseRetries = 10
-
-    private let window: NSWindow
-    private let header: NSTableHeaderView
-    private let tableView: NSTableView
-    private let column: NSTableColumn
-    private let rowViews: DrawCountingRowViewSource
-    private let startX: CGFloat
-    private let offsets: [CGFloat]
-    private let cacheAgrees: () -> Bool
-    private var ticks = 0
-    private(set) var samples: [Sample] = []
-    private(set) var resizeNotifications = 0
-    private(set) var moveNotifications = 0
-
-    /// - Parameters:
-    ///   - startX: where the press lands, the column's divider unless given.
-    ///   - offsets: the pointer's distance from `startX` at each drag step; even steps of
-    ///     `stepDistance` unless given. The release lands at the last one.
-    init(
-        window: NSWindow,
-        header: NSTableHeaderView,
-        tableView: NSTableView,
-        columnIndex: Int,
-        rowViews: DrawCountingRowViewSource,
-        startX: CGFloat? = nil,
-        stepDistance: CGFloat = 25,
-        offsets: [CGFloat]? = nil,
-        cacheAgrees: @escaping () -> Bool = { true }
-    ) {
-        self.window = window
-        self.header = header
-        self.tableView = tableView
-        self.column = tableView.tableColumns[columnIndex]
-        self.rowViews = rowViews
-        self.startX = startX ?? header.headerRect(ofColumn: columnIndex).maxX
-        self.offsets = offsets ?? (1...Self.defaultSteps).map { CGFloat($0) * stepDistance }
-        self.cacheAgrees = cacheAgrees
-    }
-
-    func run() throws {
-        let observer = NotificationCenter.default.addObserver(
-            forName: NSTableView.columnDidResizeNotification,
-            object: tableView,
-            queue: nil
-        ) { [weak self] _ in
-            MainActor.assumeIsolated { self?.resizeNotifications += 1 }
-        }
-        defer { NotificationCenter.default.removeObserver(observer) }
-        let moveObserver = NotificationCenter.default.addObserver(
-            forName: NSTableView.columnDidMoveNotification,
-            object: tableView,
-            queue: nil
-        ) { [weak self] _ in
-            MainActor.assumeIsolated { self?.moveNotifications += 1 }
-        }
-        defer { NotificationCenter.default.removeObserver(moveObserver) }
-
-        let timer = Timer(timeInterval: Self.tickInterval, repeats: true) { [weak self] timer in
-            let isFinished = MainActor.assumeIsolated { self?.tick() ?? true }
-            if isFinished { timer.invalidate() }
-        }
-        RunLoop.current.add(timer, forMode: .eventTracking)
-        defer { timer.invalidate() }
-
-        let press = try #require(mouseEvent(.leftMouseDown, x: startX))
-        header.mouseDown(with: press)
-        /// The spare releases the timer posts after the loop ends would otherwise reach whichever
-        /// suite runs next.
-        while NSApp.nextEvent(
-            matching: [.leftMouseDragged, .leftMouseUp],
-            until: .distantPast,
-            inMode: .default,
-            dequeue: true
-        ) != nil {}
-    }
-
-    /// - Returns: whether the timer has nothing left to post.
-    private func tick() -> Bool {
-        ticks += 1
-        if ticks <= offsets.count + 1 {
-            samples.append(Sample(
-                resizedColumn: header.resizedColumn,
-                draggedColumn: header.draggedColumn,
-                width: column.width,
-                tableWidth: tableView.frame.width,
-                resizeNotifications: resizeNotifications,
-                moveNotifications: moveNotifications,
-                rowDraws: rowViews.rowDraws,
-                cacheAgrees: cacheAgrees()
-            ))
-        }
-        if ticks <= offsets.count {
-            post(.leftMouseDragged, x: startX + offsets[ticks - 1])
-            return false
-        }
-        post(.leftMouseUp, x: startX + (offsets.last ?? 0))
-        return ticks > offsets.count + Self.releaseRetries
-    }
-
-    private func post(_ type: NSEvent.EventType, x: CGFloat) {
-        guard let event = mouseEvent(type, x: x) else { return }
-        NSApp.postEvent(event, atStart: false)
-    }
-
-    private func mouseEvent(_ type: NSEvent.EventType, x: CGFloat) -> NSEvent? {
-        NSEvent.mouseEvent(
-            with: type,
-            location: header.convert(NSPoint(x: x, y: header.bounds.midY), to: nil),
-            modifierFlags: [],
-            timestamp: ProcessInfo.processInfo.systemUptime,
-            windowNumber: window.windowNumber,
-            context: nil,
-            eventNumber: 0,
-            clickCount: 1,
-            pressure: type == .leftMouseUp ? 0 : 1
-        )
-    }
-}
-
-/// A data cell has no view, so `NSTableView` never relays one out and never invalidates the row that
-/// drew it. AppKit resizes a row view only when the table's total width moves, which it does not
-/// while the columns still fit inside the viewport, so every column geometry change on a grid
-/// narrower than its scroll view used to leave the body painting the layout it last drew (#2449).
-@MainActor
-struct DataGridColumnGeometryRepaintTests {
-    private struct Grid {
-        let window: NSWindow
-        let scrollView: NSScrollView
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-        let overlay: GridSelectionOverlay
-        let dataColumns: [NSTableColumn]
-        let rowNumberColumn: NSTableColumn
-
-        var rowViews: [DataGridRowView] {
-            (0 ..< tableView.numberOfRows).compactMap {
-                tableView.rowView(atRow: $0, makeIfNecessary: false) as? DataGridRowView
-            }
-        }
-    }
-
-    private static let rows = TableRows.from(
-        queryRows: [
-            [.text("edge-01"), .text("running"), .text("2026-08-20 11:03:39")],
-            [.text("edge-02"), .text("stopped"), .text("2026-08-21 09:14:02")],
-        ],
-        columns: ["machine_id", "state", "last_seen_at"],
-        columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT"), .text(rawType: "TEXT")]
-    )
-
-    /// - Parameters:
-    ///   - viewportWidth: the scroll view's width. Wider than the columns is the configuration the
-    ///     bug lives in, because the table view's frame never moves and AppKit therefore never
-    ///     resizes a row view. Narrower is the configuration that hides it, where the frame grows
-    ///     and the incidental resize redraw covers for the missing invalidation.
-    private func makeGrid(viewportWidth: CGFloat, columnWidth: CGFloat) -> Grid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopColumnLayoutPersister()
-        )
-        coordinator.tabType = .table
-        coordinator.connectionId = UUID()
-        coordinator.tableName = "machines"
-        coordinator.tableRowsProvider = { Self.rows }
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.style = .plain
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = 24
-        tableView.usesAutomaticRowHeights = false
-        coordinator.tableView = tableView
-
-        let rowNumberColumn = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        rowNumberColumn.width = 40
-        tableView.addTableColumn(rowNumberColumn)
-
-        coordinator.rebuildColumnMetadataCache(from: Self.rows)
-        var dataColumns: [NSTableColumn] = []
-        for index in Self.rows.columns.indices {
-            let identifier = coordinator.columnIdentifier(for: index) ?? ColumnIdentitySchema.slotIdentifier(index)
-            let column = NSTableColumn(identifier: identifier)
-            column.title = Self.rows.columns[index]
-            column.minWidth = 20
-            column.maxWidth = 2_000
-            column.width = columnWidth
-            tableView.addTableColumn(column)
-            dataColumns.append(column)
-        }
-        coordinator.updateColumnPresentations(from: Self.rows)
-        coordinator.updateCache()
-
-        let overlay = GridSelectionOverlay(frame: tableView.bounds)
-        overlay.tableView = tableView
-        overlay.coordinator = coordinator
-        coordinator.selectionController.overlay = overlay
-        tableView.selectionOverlay = overlay
-        tableView.addSubview(overlay)
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: viewportWidth, height: 200))
-        scrollView.hasHorizontalScroller = true
-        scrollView.documentView = tableView
-
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: viewportWidth, height: 220),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.contentView = scrollView
-
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.reloadData()
-        scrollView.tile()
-        window.layoutIfNeeded()
-        for row in 0 ..< tableView.numberOfRows {
-            _ = tableView.rowView(atRow: row, makeIfNecessary: true)
-        }
-
-        return Grid(
-            window: window,
-            scrollView: scrollView,
-            tableView: tableView,
-            coordinator: coordinator,
-            overlay: overlay,
-            dataColumns: dataColumns,
-            rowNumberColumn: rowNumberColumn
-        )
-    }
-
-    private struct DraggableGrid {
-        let window: NSWindow
-        let tableView: KeyHandlingTableView
-        let header: SortableHeaderView
-        let coordinator: TableViewCoordinator
-    }
-
-    /// The grid as `DataGridView` builds it: pool columns, the sortable header and a layer-backed
-    /// table. The header hands a press to AppKit's resize tracking only on a presented column.
-    private func makeDraggableGrid(rowViews: DrawCountingRowViewSource) -> DraggableGrid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: rowViews,
-            layoutPersister: NoopColumnLayoutPersister()
-        )
-        coordinator.tabType = .table
-        coordinator.connectionId = UUID()
-        coordinator.tableName = "machines"
-        coordinator.tableRowsProvider = { Self.rows }
-        coordinator.rebuildColumnMetadataCache(from: Self.rows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.style = .plain
-        tableView.wantsLayer = true
-        tableView.layerContentsRedrawPolicy = .onSetNeedsDisplay
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = 24
-        tableView.usesAutomaticRowHeights = false
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-
-        let header = SortableHeaderView(frame: tableView.headerView?.frame ?? .zero)
-        header.coordinator = coordinator
-        tableView.headerView = header
-
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Self.rows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.updateColumnPresentations(from: Self.rows)
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 900, height: 200))
-        scrollView.hasHorizontalScroller = true
-        scrollView.contentView.wantsLayer = true
-        scrollView.contentView.layerContentsRedrawPolicy = .onSetNeedsDisplay
-        scrollView.documentView = tableView
-
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 900, height: 220),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.contentView = scrollView
-
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.reloadData()
-        scrollView.tile()
-        window.layoutIfNeeded()
-        for row in 0 ..< tableView.numberOfRows {
-            _ = tableView.rowView(atRow: row, makeIfNecessary: true)
-        }
-
-        return DraggableGrid(window: window, tableView: tableView, header: header, coordinator: coordinator)
-    }
-
-    private func settle(_ grid: Grid) {
-        grid.window.displayIfNeeded()
-        grid.tableView.needsDisplay = false
-        grid.overlay.needsDisplay = false
-        for rowView in grid.rowViews {
-            rowView.needsDisplay = false
-            rowView.cellsNeedDisplay = false
-        }
-    }
-
-    @Test("A width change repaints the drawn cells when the columns fit inside the viewport")
-    func widthChangeRepaintsInsideViewport() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        let widthBefore = grid.tableView.frame.width
-        settle(grid)
-
-        grid.dataColumns[0].width = 260
-
-        #expect(grid.tableView.frame.width == widthBefore)
-        #expect(rowViews.filter(\.cellsNeedDisplay).count == rowViews.count)
-        #expect(grid.tableView.needsDisplay)
-        #expect(grid.overlay.needsDisplay)
-    }
-
-    @Test("A width change repaints the drawn cells when the columns overflow the viewport")
-    func widthChangeRepaintsOutsideViewport() throws {
-        let grid = makeGrid(viewportWidth: 300, columnWidth: 200)
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        settle(grid)
-
-        grid.dataColumns[0].width = 380
-
-        #expect(rowViews.filter(\.cellsNeedDisplay).count == rowViews.count)
-    }
-
-    @Test("Reordering a column repaints the drawn cells")
-    func reorderRepaints() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        settle(grid)
-
-        let from = grid.tableView.column(withIdentifier: grid.dataColumns[0].identifier)
-        let to = grid.tableView.column(withIdentifier: grid.dataColumns[2].identifier)
-        grid.tableView.moveColumn(from, toColumn: to)
-
-        #expect(rowViews.filter(\.cellsNeedDisplay).count == rowViews.count)
-    }
-
-    /// AppKit moves the width on every step of a divider drag but posts `columnDidResizeNotification`
-    /// only at mouse-up, so a case that sets the width directly, which posts it at once, cannot see a
-    /// body that stays frozen for the whole drag. The columns fit the viewport, so the table's frame
-    /// holds still and no incidental row resize repaints the rows instead.
-    @Test("A divider drag repaints the drawn cells before the mouse comes up")
-    func dividerDragRepaintsBeforeMouseUp() throws {
-        let rowViews = DrawCountingRowViewSource()
-        let grid = makeDraggableGrid(rowViews: rowViews)
-        let columnIndex = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let widthBefore = grid.tableView.tableColumns[columnIndex].width
-        let tableWidthBefore = grid.tableView.frame.width
-        let drag = HeaderDividerDrag(
-            window: grid.window,
-            header: grid.header,
-            tableView: grid.tableView,
-            columnIndex: columnIndex,
-            rowViews: rowViews
-        )
-
-        try drag.run()
-
-        let samples = drag.samples
-        try #require(
-            samples.contains { $0.rowDraws > 0 },
-            "The rows never drew, so this host cannot show whether a drag step repaints them"
-        )
-        let midDrag = samples.filter { $0.resizedColumn == columnIndex && $0.width > widthBefore }
-        try #require(midDrag.count >= 2, "The tracking loop ended before a second drag step: \(samples)")
-        #expect(midDrag.allSatisfy { $0.resizeNotifications == 0 })
-        #expect(midDrag.allSatisfy { $0.tableWidth == tableWidthBefore })
-        let repaintedSteps = zip(midDrag, midDrag.dropFirst()).filter { previous, current in
-            current.width > previous.width && current.rowDraws > previous.rowDraws
-        }
-        #expect(!repaintedSteps.isEmpty, "Row draws during the drag: \(midDrag.map { $0.rowDraws })")
-        #expect(drag.resizeNotifications == 1)
-    }
-
-    /// A reorder drag posts `columnDidMoveNotification` only at mouse-up, and AppKit neither tiles nor
-    /// redraws the table while it lasts, so nothing but the header's own redraws can move the body.
-    /// The column-index caches are primed first: a body that follows the drag through caches still
-    /// holding the order it started from draws the selection on the wrong columns.
-    @Test("A column reorder drag repaints the drawn cells before the mouse comes up")
-    func reorderDragRepaintsBeforeMouseUp() throws {
-        let rowViews = DrawCountingRowViewSource()
-        let grid = makeDraggableGrid(rowViews: rowViews)
-        let columnIndex = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let dataIndices = Array(0 ..< Self.rows.columns.count)
-        for dataIndex in dataIndices {
-            _ = grid.coordinator.tableColumnIndex(for: dataIndex)
-        }
-        let coordinator = grid.coordinator
-        let tableView = grid.tableView
-        let drag = HeaderDividerDrag(
-            window: grid.window,
-            header: grid.header,
-            tableView: grid.tableView,
-            columnIndex: columnIndex,
-            rowViews: rowViews,
-            startX: grid.header.headerRect(ofColumn: columnIndex).midX,
-            cacheAgrees: {
-                dataIndices.allSatisfy { dataIndex in
-                    guard let identifier = coordinator.columnIdentifier(for: dataIndex) else { return false }
-                    return coordinator.tableColumnIndex(for: dataIndex) == tableView.column(withIdentifier: identifier)
-                }
-            }
-        )
-
-        try drag.run()
-
-        let samples = drag.samples
-        try #require(
-            samples.contains { $0.rowDraws > 0 },
-            "The rows never drew, so this host cannot show whether a drag step repaints them"
-        )
-        let midDrag = samples.filter { $0.draggedColumn >= 0 }
-        try #require(midDrag.count >= 2, "The tracking loop ended before a second drag step: \(samples)")
-        try #require(
-            midDrag.contains { $0.draggedColumn != columnIndex },
-            "The drag never passed a neighbour: \(midDrag.map { $0.draggedColumn })"
-        )
-        #expect(midDrag.allSatisfy { $0.moveNotifications == 0 })
-        #expect(midDrag.allSatisfy { $0.cacheAgrees })
-        let repaintedSteps = zip(midDrag, midDrag.dropFirst()).filter { previous, current in
-            current.rowDraws > previous.rowDraws
-        }
-        #expect(!repaintedSteps.isEmpty, "Row draws during the drag: \(midDrag.map { $0.rowDraws })")
-        #expect(drag.moveNotifications == 1)
-    }
-
-    /// A selection is held in display positions, and a reorder that commits moves them, so mouse-up
-    /// clears it then. A drag that passes a neighbour and comes back commits nothing, and clearing
-    /// the selection at the first pass lost it for a reorder that never happened.
-    @Test("A reorder dragged past a neighbour and back keeps the cell selection")
-    func reorderDraggedBackKeepsTheSelection() throws {
-        let rowViews = DrawCountingRowViewSource()
-        let grid = makeDraggableGrid(rowViews: rowViews)
-        let columnIndex = try #require(grid.coordinator.firstPresentedColumnIndex())
-        grid.coordinator.selectionController.selectEntireColumn(1, totalRows: grid.tableView.numberOfRows)
-        let selection = grid.coordinator.selectionController.selection
-        try #require(!selection.isEmpty)
-        let heading = grid.header.headerRect(ofColumn: columnIndex)
-        let outward = (1...6).map { CGFloat($0) * heading.width / 4 }
-        let drag = HeaderDividerDrag(
-            window: grid.window,
-            header: grid.header,
-            tableView: grid.tableView,
-            columnIndex: columnIndex,
-            rowViews: rowViews,
-            startX: heading.midX,
-            offsets: outward + outward.reversed().dropFirst() + [0]
-        )
-
-        try drag.run()
-
-        try #require(
-            drag.samples.contains { $0.draggedColumn > columnIndex },
-            "The drag never passed a neighbour: \(drag.samples.map { $0.draggedColumn })"
-        )
-        #expect(drag.moveNotifications == 0)
-        #expect(grid.coordinator.selectionController.selection == selection)
-    }
-
-    /// While the drag lasts the body draws the column at the pointer. A reorder released before the
-    /// column passes a neighbour posts no notification at all, so without a pass of its own the
-    /// body kept drawing it there.
-    @Test("A reorder released before passing a neighbour repaints the body once it ends")
-    func shortReorderRepaintsAfterRelease() throws {
-        let rowViews = DrawCountingRowViewSource()
-        let grid = makeDraggableGrid(rowViews: rowViews)
-        let columnIndex = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let drag = HeaderDividerDrag(
-            window: grid.window,
-            header: grid.header,
-            tableView: grid.tableView,
-            columnIndex: columnIndex,
-            rowViews: rowViews,
-            startX: grid.header.headerRect(ofColumn: columnIndex).midX,
-            stepDistance: 4
-        )
-
-        try drag.run()
-        grid.window.displayIfNeeded()
-
-        let samples = drag.samples
-        let lastSample = try #require(samples.last)
-        try #require(
-            samples.contains { $0.draggedColumn == columnIndex },
-            "The press never started a reorder: \(samples.map { $0.draggedColumn })"
-        )
-        #expect(drag.moveNotifications == 0)
-        #expect(grid.header.draggedColumn == -1)
-        #expect(rowViews.rowDraws > lastSample.rowDraws)
-    }
-
-    /// The row-number column is pinned, `minWidth == maxWidth == width`. Raising `minWidth` past the
-    /// current width moves `width` with it while `NSTableView` keeps the old cumulative geometry and
-    /// posts nothing, so the assertion has to be on `rect(ofColumn:)` rather than on the width
-    /// property, which reports the new value either way. Paging from row 999 to row 1000 is the
-    /// trigger.
-    @Test("Widening the row-number column moves the geometry the cells are drawn from")
-    func rowNumberWidthChangeRepaints() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        let rowNumberIndex = grid.tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        let firstDataIndex = grid.tableView.column(withIdentifier: grid.dataColumns[0].identifier)
-        let rowNumberWidthBefore = grid.tableView.rect(ofColumn: rowNumberIndex).width
-        let firstDataOriginBefore = grid.tableView.rect(ofColumn: firstDataIndex).minX
-        settle(grid)
-
-        grid.coordinator.paginationOffsetProvider = { 1_000_000 }
-        grid.coordinator.resizeRowNumberColumnForCurrentRange()
-
-        #expect(grid.tableView.rect(ofColumn: rowNumberIndex).width > rowNumberWidthBefore)
-        #expect(grid.tableView.rect(ofColumn: firstDataIndex).minX > firstDataOriginBefore)
-        #expect(rowViews.filter(\.cellsNeedDisplay).count == rowViews.count)
-    }
-
-    @Test("Narrowing the row-number column moves the geometry back")
-    func rowNumberShrinkRepaints() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        grid.coordinator.paginationOffsetProvider = { 1_000_000 }
-        grid.coordinator.resizeRowNumberColumnForCurrentRange()
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        let rowNumberIndex = grid.tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        let firstDataIndex = grid.tableView.column(withIdentifier: grid.dataColumns[0].identifier)
-        let widenedWidth = grid.tableView.rect(ofColumn: rowNumberIndex).width
-        let widenedOrigin = grid.tableView.rect(ofColumn: firstDataIndex).minX
-        settle(grid)
-
-        grid.coordinator.paginationOffsetProvider = { 0 }
-        grid.coordinator.resizeRowNumberColumnForCurrentRange()
-
-        #expect(grid.tableView.rect(ofColumn: rowNumberIndex).width < widenedWidth)
-        #expect(grid.tableView.rect(ofColumn: firstDataIndex).minX < widenedOrigin)
-        #expect(rowViews.filter(\.cellsNeedDisplay).count == rowViews.count)
-    }
-
-    /// The cell-range selection wash is painted by the row itself in `drawBackground`, placed from
-    /// the same live column rects the cells use. It repaints because `canDrawSubviewsIntoLayer` puts
-    /// the row and its cells in one backing store, so dirtying the cells dirties the row. This pins
-    /// that, since the wash would otherwise be left at the old column with nothing to catch it.
-    @Test("A geometry change invalidates the selection wash the row paints")
-    func geometryChangeInvalidatesTheSelectionWash() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        grid.coordinator.selectionController.selectEntireColumn(0, totalRows: grid.tableView.numberOfRows)
-        settle(grid)
-
-        grid.dataColumns[0].width = 260
-
-        #expect(rowViews.filter(\.needsDisplay).count == rowViews.count)
-    }
-
-    /// `markColumnWidthUserSized` is false for the row-number column and for an unused pool slot, and
-    /// it is the second guard the resize handler returns on, so a repaint placed behind it would skip
-    /// exactly those columns.
-    @Test("A resize notification repaints a column that is never user-sized")
-    func resizeRepaintsAColumnThatIsNeverUserSized() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        settle(grid)
-
-        grid.coordinator.tableViewColumnDidResize(
-            Notification(
-                name: NSTableView.columnDidResizeNotification,
-                object: grid.tableView,
-                userInfo: ["NSTableColumn": grid.rowNumberColumn, "NSOldWidth": CGFloat(40)]
-            )
-        )
-
-        #expect(grid.coordinator.userSizedColumnNames.isEmpty)
-        #expect(rowViews.filter(\.cellsNeedDisplay).count == rowViews.count)
-    }
-
-    @Test("A width change during a column rebuild still repaints")
-    func rebuildingColumnsStillRepaints() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let rowViews = grid.rowViews
-        try #require(!rowViews.isEmpty)
-        settle(grid)
-
-        grid.coordinator.isRebuildingColumns = true
-        defer { grid.coordinator.isRebuildingColumns = false }
-        grid.dataColumns[1].width = 240
-
-        #expect(grid.coordinator.userSizedColumnNames.isEmpty)
-        #expect(rowViews.filter(\.cellsNeedDisplay).count == rowViews.count)
-    }
-
-    /// The invalidation is only half the contract. The cells have to be drawn from the geometry the
-    /// table view reports now, so the same row rasterises differently once a column has moved.
-    @Test("The redrawn cells land at the new column geometry")
-    func redrawnCellsFollowTheNewGeometry() throws {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let rowView = try #require(grid.rowViews.first)
-        let before = try #require(Self.rasterize(rowView))
-
-        grid.dataColumns[0].width = 300
-        grid.window.layoutIfNeeded()
-
-        let after = try #require(Self.rasterize(rowView))
-        #expect(before != after)
-    }
-
-    /// `DataGridColumnPool` places every data column relative to the row-number column and reads its
-    /// position off `tableColumns.first`, so it has to stay at the head of the run.
-    @Test("The row-number column cannot be dragged out of the first position")
-    func rowNumberColumnStaysFirst() {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let coordinator = grid.coordinator
-
-        #expect(!coordinator.tableView(grid.tableView, shouldReorderColumn: 0, toColumn: 2))
-        #expect(!coordinator.tableView(grid.tableView, shouldReorderColumn: 2, toColumn: 0))
-        #expect(coordinator.tableView(grid.tableView, shouldReorderColumn: 2, toColumn: 1))
-        #expect(coordinator.tableView(grid.tableView, shouldReorderColumn: 1, toColumn: 3))
-    }
-
-    /// A drag opens with a `newColumnIndex` of -1, and answering no to it disallows the column from
-    /// being reordered at all. Refusing that probe for every column would disable the whole feature
-    /// while trying to pin one column.
-    @Test("The opening reorder probe leaves data columns draggable")
-    func openingReorderProbeAllowsDataColumns() {
-        let grid = makeGrid(viewportWidth: 900, columnWidth: 100)
-        let coordinator = grid.coordinator
-
-        #expect(coordinator.tableView(grid.tableView, shouldReorderColumn: 1, toColumn: -1))
-        #expect(coordinator.tableView(grid.tableView, shouldReorderColumn: 3, toColumn: -1))
-        #expect(!coordinator.tableView(grid.tableView, shouldReorderColumn: 0, toColumn: -1))
-    }
-
-    private static func rasterize(_ rowView: DataGridRowView) -> Data? {
-        guard let representation = rowView.bitmapImageRepForCachingDisplay(in: rowView.bounds) else { return nil }
-        rowView.cacheDisplay(in: rowView.bounds, to: representation)
-        return representation.representation(using: .png, properties: [:])
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridColumnPoolTests.swift b/apple/TableProTests/Views/Results/DataGridColumnPoolTests.swift
deleted file mode 100644
index 99e518fce8..0000000000
--- a/apple/TableProTests/Views/Results/DataGridColumnPoolTests.swift
+++ /dev/null
@@ -1,827 +0,0 @@
-//
-//  DataGridColumnPoolTests.swift
-//  TableProTests
-//
-
-import AppKit
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct DataGridColumnPoolTests {
-    private func makeTableView() -> NSTableView {
-        let tableView = NSTableView()
-        // Mirrors DataGridView. The default style redistributes column widths on resize, which
-        // would silently rewrite the widths these tests assert on, and the default style and
-        // intercell spacing put the columns at different document positions than the grid's, which
-        // is the geometry the window is resolved against.
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.style = .plain
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        let rowNumberColumn = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        rowNumberColumn.width = 40
-        tableView.addTableColumn(rowNumberColumn)
-        return tableView
-    }
-
-    private func makeColumnTypes(count: Int) -> [ColumnType] {
-        Array(repeating: ColumnType.text(rawType: nil), count: count)
-    }
-
-    private func defaultWidthCalculator(name: String, slot: Int) -> CGFloat {
-        100
-    }
-
-    private func dataColumns(in tableView: NSTableView) -> [NSTableColumn] {
-        tableView.tableColumns.filter { $0.identifier != ColumnIdentitySchema.rowNumberIdentifier }
-    }
-
-    @Test("reconcile grows pool when column count exceeds capacity")
-    func reconcile_growsPoolWhenColumnCountExceedsCapacity() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        #expect(pool.totalSlots == 3)
-        #expect(dataColumns(in: tableView).count == 3)
-    }
-
-    /// A column with no sort prototype is one AppKit does not treat as sortable, so a heading click leaves
-    /// `sortDescriptors` alone and the header's click-versus-drag test reads it as no sort at all.
-    @Test("reconcile gives a column no sort prototype on a grid that cannot sort by column")
-    func reconcile_dropsSortPrototypeWhenColumnSortIsUnavailable() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name"])
-
-        pool.reconcile(
-            tableView: tableView, schema: schema, columnTypes: makeColumnTypes(count: 2), savedLayout: nil,
-            isEditable: true, hiddenColumnNames: [], firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-        #expect(dataColumns(in: tableView).allSatisfy { $0.sortDescriptorPrototype != nil })
-
-        pool.reconcile(
-            tableView: tableView, schema: schema, columnTypes: makeColumnTypes(count: 2), savedLayout: nil,
-            isEditable: true, hiddenColumnNames: [], firstClickSortDirection: .ascending, supportsColumnSort: false,
-            widthCalculator: defaultWidthCalculator
-        )
-        #expect(dataColumns(in: tableView).allSatisfy { $0.sortDescriptorPrototype == nil })
-    }
-
-    @Test("reconcile does not shrink pool when column count drops")
-    func reconcile_doesNotShrinkPoolWhenColumnCountDrops() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: ["a", "b", "c", "d"]),
-            columnTypes: makeColumnTypes(count: 4),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-        #expect(pool.totalSlots == 4)
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: ["a", "b"]),
-            columnTypes: makeColumnTypes(count: 2),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        #expect(pool.totalSlots == 4)
-        let extras = dataColumns(in: tableView).filter { column in
-            let identifier = column.identifier.rawValue
-            return identifier == "dataColumn-2" || identifier == "dataColumn-3"
-        }
-        #expect(extras.count == 2)
-        #expect(extras.allSatisfy { $0.isHidden })
-    }
-
-    @Test("reconcile attaches columns in natural order when no saved layout")
-    func reconcile_attachesColumnsInNaturalOrderWithoutSavedLayout() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let identifiers = dataColumns(in: tableView).map(\.identifier.rawValue)
-        #expect(identifiers == ["dataColumn-0", "dataColumn-1", "dataColumn-2"])
-    }
-
-    @Test("reconcile attaches columns in saved order on first call")
-    func reconcile_attachesColumnsInSavedOrderOnFirstCall() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        var layout = ColumnLayoutState()
-        layout.columnOrder = ["email", "id", "name"]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let identifiers = dataColumns(in: tableView).map(\.identifier.rawValue)
-        #expect(identifiers == ["dataColumn-2", "dataColumn-0", "dataColumn-1"])
-    }
-
-    @Test("reconcile reorders existing columns when saved order differs from current")
-    func reconcile_reordersExistingColumnsWhenSavedOrderDiffersFromCurrent() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        var layout = ColumnLayoutState()
-        layout.columnOrder = ["email", "id", "name"]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let identifiers = dataColumns(in: tableView).map(\.identifier.rawValue)
-        #expect(identifiers == ["dataColumn-2", "dataColumn-0", "dataColumn-1"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let afterSecond = dataColumns(in: tableView).map(\.identifier.rawValue)
-        #expect(afterSecond == ["dataColumn-2", "dataColumn-0", "dataColumn-1"])
-    }
-
-    @Test("reconcile reuses the same NSTableColumn instances across calls")
-    func reconcile_reusesSameTableColumnInstancesAcrossCalls() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let firstSnapshot = dataColumns(in: tableView)
-        let capturedSlot1 = firstSnapshot[1]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let afterSnapshot = dataColumns(in: tableView)
-        #expect(afterSnapshot[1] === capturedSlot1)
-        for (before, after) in zip(firstSnapshot, afterSnapshot) {
-            #expect(before === after)
-        }
-    }
-
-    @Test("reconcile honors hidden columns from saved layout")
-    func reconcile_honorsHiddenColumnsFromSavedLayout() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        var layout = ColumnLayoutState()
-        layout.hiddenColumns = ["name"]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let columns = dataColumns(in: tableView)
-        let hiddenStateByName = Dictionary(uniqueKeysWithValues: columns.map { ($0.headerCell.stringValue, $0.isHidden) })
-        #expect(hiddenStateByName["id"] == false)
-        #expect(hiddenStateByName["name"] == true)
-        #expect(hiddenStateByName["email"] == false)
-    }
-
-    @Test("reconcile honors hidden columns from hiddenColumnNames parameter")
-    func reconcile_honorsHiddenColumnsFromParameter() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: ["email"],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let columns = dataColumns(in: tableView)
-        let hiddenStateByName = Dictionary(uniqueKeysWithValues: columns.map { ($0.headerCell.stringValue, $0.isHidden) })
-        #expect(hiddenStateByName["id"] == false)
-        #expect(hiddenStateByName["name"] == false)
-        #expect(hiddenStateByName["email"] == true)
-    }
-
-    @Test("Slot identifiers use dataColumn-N format")
-    func reconcile_slotIdentifierFormatIsDataColumnN() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email", "created"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 4),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let identifiers = dataColumns(in: tableView).map(\.identifier.rawValue).sorted()
-        #expect(identifiers == ["dataColumn-0", "dataColumn-1", "dataColumn-2", "dataColumn-3"])
-    }
-
-    @Test("Column width comes from widthCalculator when no saved widths")
-    func reconcile_widthFromCalculatorWhenNoSavedWidths() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { name, _ in name == "id" ? 50 : 200 }
-        )
-
-        let widthsByName = Dictionary(uniqueKeysWithValues: dataColumns(in: tableView).map { ($0.headerCell.stringValue, $0.width) })
-        #expect(widthsByName["id"] == 50)
-        #expect(widthsByName["name"] == 200)
-    }
-
-    @Test("Column width comes from saved layout when present")
-    func reconcile_widthFromSavedLayoutWhenPresent() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name"])
-
-        var layout = ColumnLayoutState()
-        layout.columnWidths = ["id": 75, "name": 250]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 9_999 }
-        )
-
-        let widthsByName = Dictionary(uniqueKeysWithValues: dataColumns(in: tableView).map { ($0.headerCell.stringValue, $0.width) })
-        #expect(widthsByName["id"] == 75)
-        #expect(widthsByName["name"] == 250)
-    }
-
-    @Test("A partial saved layout leaves missing columns automatic")
-    func reconcile_partialSavedLayoutUsesCalculatorForMissingColumns() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name"])
-        var calculatedNames: [String] = []
-
-        var layout = ColumnLayoutState()
-        layout.columnWidths = ["id": 75]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { name, _ in
-                calculatedNames.append(name)
-                return 200
-            }
-        )
-
-        let widthsByName = Dictionary(
-            uniqueKeysWithValues: dataColumns(in: tableView).map { ($0.headerCell.stringValue, $0.width) }
-        )
-        #expect(widthsByName["id"] == 75)
-        #expect(widthsByName["name"] == 200)
-        #expect(calculatedNames == ["name"])
-    }
-
-    @Test("An oversized saved width is clamped to the column ceiling")
-    func reconcile_clampsOversizedSavedWidthToColumnCeiling() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "payload"])
-
-        var layout = ColumnLayoutState()
-        layout.columnWidths = ["id": 75, "payload": 28_000]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let widthsByName = Dictionary(uniqueKeysWithValues: dataColumns(in: tableView).map { ($0.headerCell.stringValue, $0.width) })
-        #expect(widthsByName["id"] == 75)
-        #expect(widthsByName["payload"] == DataGridMetrics.dataColumnMaxWidth)
-    }
-
-    @Test("Data columns carry the min and max width bounds")
-    func reconcile_dataColumnsCarryWidthBounds() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: ["id", "name"]),
-            columnTypes: makeColumnTypes(count: 2),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        for column in dataColumns(in: tableView) {
-            #expect(column.minWidth == DataGridMetrics.dataColumnMinWidth)
-            #expect(column.maxWidth == DataGridMetrics.dataColumnMaxWidth)
-        }
-    }
-
-    private func minimumWidthsByName(in tableView: NSTableView) -> [String: CGFloat] {
-        Dictionary(uniqueKeysWithValues: dataColumns(in: tableView).map { ($0.headerCell.stringValue, $0.minWidth) })
-    }
-
-    @Test("A column named in the minimum widths gets that floor and the others keep the default")
-    func reconcile_appliesPerColumnMinimumWidths() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: ["id", "name"]),
-            columnTypes: makeColumnTypes(count: 2),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            minimumWidths: ["name": 140],
-            widthCalculator: defaultWidthCalculator
-        )
-
-        #expect(minimumWidthsByName(in: tableView) == ["id": DataGridMetrics.dataColumnMinWidth, "name": 140])
-    }
-
-    /// Raising `minWidth` past `width` first moves the width without moving the table's column
-    /// geometry, so the column would report one width and draw at another.
-    @Test("A width below the column's floor opens at the floor, and the table's geometry follows")
-    func reconcile_raisesWidthToTheFloor() throws {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name"])
-
-        pool.reconcile(
-            tableView: tableView, schema: schema, columnTypes: makeColumnTypes(count: 2), savedLayout: nil,
-            isEditable: true, hiddenColumnNames: [], firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-        pool.reconcile(
-            tableView: tableView, schema: schema, columnTypes: makeColumnTypes(count: 2), savedLayout: nil,
-            isEditable: true, hiddenColumnNames: [], firstClickSortDirection: .ascending,
-            minimumWidths: ["name": 140],
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let name = try #require(dataColumns(in: tableView).first { $0.headerCell.stringValue == "name" })
-        let index = tableView.column(withIdentifier: name.identifier)
-        #expect(name.width == 140)
-        #expect(name.minWidth == 140)
-        #expect(tableView.rect(ofColumn: index).width == 140 + tableView.intercellSpacing.width)
-    }
-
-    @Test("A reused slot drops the floor of the result it showed before")
-    func reconcile_resetsTheFloorOfAReusedSlot() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-
-        pool.reconcile(
-            tableView: tableView, schema: ColumnIdentitySchema(columns: ["name"]), columnTypes: makeColumnTypes(count: 1),
-            savedLayout: nil, isEditable: true, hiddenColumnNames: [], firstClickSortDirection: .ascending,
-            minimumWidths: ["name": 140],
-            widthCalculator: defaultWidthCalculator
-        )
-        pool.reconcile(
-            tableView: tableView, schema: ColumnIdentitySchema(columns: ["id"]), columnTypes: makeColumnTypes(count: 1),
-            savedLayout: nil, isEditable: true, hiddenColumnNames: [], firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 50 }
-        )
-
-        let column = dataColumns(in: tableView).first
-        #expect(column?.minWidth == DataGridMetrics.dataColumnMinWidth)
-        #expect(column?.width == 50)
-    }
-
-    @Test("reconcile publishes column comments to the header view")
-    func reconcile_publishesColumnCommentsToHeaderView() throws {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let headerView = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: 200, height: 28))
-        tableView.headerView = headerView
-        let schema = ColumnIdentitySchema(columns: ["id", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: ["email": "Primary contact address"],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let emailColumn = try #require(dataColumns(in: tableView).first { $0.headerCell.stringValue == "email" })
-        let headerCell = try #require(emailColumn.headerCell as? SortableHeaderCell)
-        #expect(headerView.comment(for: headerCell) == "Primary contact address")
-        #expect(emailColumn.headerToolTip == "email (Text)\nPrimary contact address")
-        #expect(headerCell.accessibilityLabel() == "Column: email, Primary contact address")
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: [:],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        #expect(headerView.comment(for: headerCell) == nil)
-        #expect(emailColumn.headerToolTip == "email (Text)")
-        #expect(headerCell.accessibilityLabel() == "Column: email")
-    }
-
-    @Test("reconcile expands and restores header height based on visible comments")
-    func reconcile_updatesHeaderHeightForVisibleComments() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let naturalHeight: CGFloat = 28
-        let headerView = SortableHeaderView(
-            frame: NSRect(x: 0, y: 0, width: 200, height: naturalHeight)
-        )
-        tableView.headerView = headerView
-        let schema = ColumnIdentitySchema(columns: ["id", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: ["email": "Primary contact address"],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        #expect(headerView.commentHeaderHeight > naturalHeight)
-        #expect(headerView.frame.height == headerView.commentHeaderHeight)
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: ["email": "Primary contact address"],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: ["email"],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        #expect(headerView.frame.height == naturalHeight)
-    }
-
-    @Test("comments arriving after the first reconcile grow the header and repaint it")
-    func reconcile_appliesCommentsArrivingAfterFirstLoad() throws {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let naturalHeight: CGFloat = 28
-        let headerView = SortableHeaderView(
-            frame: NSRect(x: 0, y: 0, width: 200, height: naturalHeight)
-        )
-        tableView.headerView = headerView
-        let schema = ColumnIdentitySchema(columns: ["id", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: [:],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        #expect(headerView.frame.height == naturalHeight)
-
-        headerView.needsDisplay = false
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: ["email": "Primary contact address"],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let emailColumn = try #require(dataColumns(in: tableView).first { $0.headerCell.stringValue == "email" })
-        let headerCell = try #require(emailColumn.headerCell as? SortableHeaderCell)
-        #expect(headerView.comment(for: headerCell) == "Primary contact address")
-        #expect(headerView.frame.height == headerView.commentHeaderHeight)
-    }
-
-    @Test("an edited comment reaches the header cell without changing the header height")
-    func reconcile_appliesEditedCommentAtUnchangedHeaderHeight() throws {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let headerView = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: 200, height: 28))
-        tableView.headerView = headerView
-        let schema = ColumnIdentitySchema(columns: ["id", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: ["email": "Primary contact address"],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let heightAfterFirstReconcile = headerView.frame.height
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 2),
-            columnComments: ["email": "Work address"],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let emailColumn = try #require(dataColumns(in: tableView).first { $0.headerCell.stringValue == "email" })
-        let headerCell = try #require(emailColumn.headerCell as? SortableHeaderCell)
-        #expect(headerView.comment(for: headerCell) == "Work address")
-        #expect(emailColumn.headerToolTip == "email (Text)\nWork address")
-        #expect(headerView.frame.height == heightAfterFirstReconcile)
-    }
-
-    @Test("reconcile is idempotent for equivalent inputs")
-    func reconcile_isIdempotentForEquivalentInputs() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        var layout = ColumnLayoutState()
-        layout.columnOrder = ["name", "id", "email"]
-        layout.columnWidths = ["id": 60, "name": 120, "email": 180]
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let beforeIdentifiers = tableView.tableColumns.map(\.identifier.rawValue)
-        let beforeWidths = tableView.tableColumns.map(\.width)
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: layout,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-
-        let afterIdentifiers = tableView.tableColumns.map(\.identifier.rawValue)
-        let afterWidths = tableView.tableColumns.map(\.width)
-
-        #expect(beforeIdentifiers == afterIdentifiers)
-        #expect(beforeWidths == afterWidths)
-    }
-
-    @Test("detachFromTableView removes pool columns and allows clean re-attach")
-    func detachFromTableView_removesPoolColumnsAndAllowsCleanReattach() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-        let schema = ColumnIdentitySchema(columns: ["id", "name", "email"])
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-        #expect(dataColumns(in: tableView).count == 3)
-
-        pool.detachFromTableView()
-        #expect(dataColumns(in: tableView).isEmpty)
-        #expect(pool.totalSlots == 3)
-
-        pool.reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: makeColumnTypes(count: 3),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-        #expect(dataColumns(in: tableView).count == 3)
-        #expect(pool.totalSlots == 3)
-    }
-
-    // MARK: - Column windowing (#1219)
-
-    private func reconcileWide(
-        _ pool: DataGridColumnPool,
-        tableView: NSTableView,
-        count: Int,
-        hidden: Set<String> = []
-    ) {
-        let names = (0..<count).map { "c\($0)" }
-        pool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: names),
-            columnTypes: makeColumnTypes(count: count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: hidden,
-            firstClickSortDirection: .ascending,
-            widthCalculator: defaultWidthCalculator
-        )
-    }
-
-    @Test("A column the user hid is not presented")
-    func userHiddenColumnIsNotPresented() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-
-        reconcileWide(pool, tableView: tableView, count: 20, hidden: ["c3"])
-
-        let presented = dataColumns(in: tableView).filter { pool.presentsColumn($0) }
-        #expect(presented.count == 19)
-        #expect(pool.hasUserHiddenColumns)
-    }
-
-    @Test("A surplus slot from a wider result is not presented")
-    func surplusSlotIsNotPresented() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-
-        reconcileWide(pool, tableView: tableView, count: 40)
-        reconcileWide(pool, tableView: tableView, count: 5)
-
-        let presented = dataColumns(in: tableView).filter { pool.presentsColumn($0) }
-        #expect(presented.count == 5)
-    }
-
-    @Test("Detaching removes the pooled columns")
-    func detachRemovesPooledColumns() {
-        let pool = DataGridColumnPool()
-        let tableView = makeTableView()
-
-        reconcileWide(pool, tableView: tableView, count: 60)
-        pool.detachFromTableView()
-
-        #expect(dataColumns(in: tableView).isEmpty)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridColumnWidthOwnershipTests.swift b/apple/TableProTests/Views/Results/DataGridColumnWidthOwnershipTests.swift
deleted file mode 100644
index 9ddb680653..0000000000
--- a/apple/TableProTests/Views/Results/DataGridColumnWidthOwnershipTests.swift
+++ /dev/null
@@ -1,205 +0,0 @@
-//
-//  DataGridColumnWidthOwnershipTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class NoopColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct DataGridColumnWidthOwnershipTests {
-    private static let plainWidth: CGFloat = 210
-    private static let actionWidth: CGFloat = 168
-
-    private func makeCoordinator() -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopColumnLayoutPersister()
-        )
-        coordinator.tabType = .table
-        coordinator.connectionId = UUID()
-        coordinator.tableName = "machines"
-        return coordinator
-    }
-
-    private func makeRows() -> TableRows {
-        TableRows.from(
-            queryRows: [[.text("edge-01"), .text("2026-08-20 11:03:39")]],
-            columns: ["machine_id", "last_seen_at"],
-            columnTypes: [.text(rawType: "TEXT"), .date(rawType: "DATETIME")]
-        )
-    }
-
-    private func attach(_ rows: TableRows, to coordinator: TableViewCoordinator) -> [String: NSTableColumn] {
-        let tableView = NSTableView()
-        coordinator.tableView = tableView
-        coordinator.tableRowsProvider = { rows }
-        coordinator.rebuildColumnMetadataCache(from: rows)
-
-        var result: [String: NSTableColumn] = [:]
-        for (index, name) in rows.columns.enumerated() {
-            let identifier = coordinator.columnIdentifier(for: index) ?? ColumnIdentitySchema.slotIdentifier(index)
-            let column = NSTableColumn(identifier: identifier)
-            column.width = name == "machine_id" ? Self.plainWidth : Self.actionWidth
-            tableView.addTableColumn(column)
-            result[name] = column
-        }
-        coordinator.updateColumnPresentations(from: rows)
-        return result
-    }
-
-    private func legacyLayout() -> ColumnLayoutState {
-        var layout = ColumnLayoutState()
-        layout.columnWidths = ["machine_id": Self.plainWidth, "last_seen_at": Self.actionWidth]
-        layout.columnOrder = ["machine_id", "last_seen_at"]
-        layout.hiddenColumns = ["machine_id"]
-        return layout
-    }
-
-    @Test("A legacy layout drops the width of a column that draws an action button")
-    func legacyLayoutDropsActionColumnWidth() throws {
-        let coordinator = makeCoordinator()
-        let rows = makeRows()
-        _ = attach(rows, to: coordinator)
-
-        let resolved = try #require(coordinator.layoutDiscardingUnownedWidths(legacyLayout(), tableRows: rows))
-
-        #expect(coordinator.columnPresentation(for: 1, in: rows).accessory == .chevron)
-        #expect(resolved.columnWidths["last_seen_at"] == nil)
-        #expect(resolved.columnWidths["machine_id"] == Self.plainWidth)
-    }
-
-    @Test("A legacy layout keeps the order and hidden columns it recorded")
-    func legacyLayoutKeepsOrderAndHiddenColumns() throws {
-        let coordinator = makeCoordinator()
-        let rows = makeRows()
-        _ = attach(rows, to: coordinator)
-
-        let resolved = try #require(coordinator.layoutDiscardingUnownedWidths(legacyLayout(), tableRows: rows))
-
-        #expect(resolved.columnOrder == ["machine_id", "last_seen_at"])
-        #expect(resolved.hiddenColumns == ["machine_id"])
-    }
-
-    @Test("A layout that records ownership is returned unchanged")
-    func ownedLayoutIsUntouched() throws {
-        let coordinator = makeCoordinator()
-        let rows = makeRows()
-        _ = attach(rows, to: coordinator)
-
-        var layout = legacyLayout()
-        layout.columnContentWidths = layout.columnWidths
-
-        let resolved = try #require(coordinator.layoutDiscardingUnownedWidths(layout, tableRows: rows))
-
-        #expect(resolved.columnWidths["last_seen_at"] == Self.actionWidth)
-        #expect(resolved.columnWidths["machine_id"] == Self.plainWidth)
-    }
-
-    @Test("A legacy width the user has taken ownership of is kept")
-    func legacyWidthKeptOnceUserSized() throws {
-        let coordinator = makeCoordinator()
-        let rows = makeRows()
-        let columns = attach(rows, to: coordinator)
-
-        #expect(coordinator.markColumnWidthUserSized(try #require(columns["last_seen_at"])))
-        let resolved = try #require(coordinator.layoutDiscardingUnownedWidths(legacyLayout(), tableRows: rows))
-
-        #expect(resolved.columnWidths["last_seen_at"] == Self.actionWidth)
-    }
-
-    @Test("A layout with no widths at all is returned unchanged")
-    func emptyLayoutIsUntouched() throws {
-        let coordinator = makeCoordinator()
-        let rows = makeRows()
-        _ = attach(rows, to: coordinator)
-
-        var layout = ColumnLayoutState()
-        layout.columnOrder = ["machine_id", "last_seen_at"]
-
-        let resolved = try #require(coordinator.layoutDiscardingUnownedWidths(layout, tableRows: rows))
-
-        #expect(resolved.columnWidths.isEmpty)
-        #expect(resolved.columnOrder == ["machine_id", "last_seen_at"])
-    }
-
-    /// A foreign key arrow is only known after the metadata round trip, so a legacy layout is
-    /// restored before anything can tell that column apart from a plain one. It still carries no
-    /// ownership, so the arrow arriving has to be allowed to widen it.
-    @Test("A legacy width still widens when its accessory resolves after the restore")
-    func legacyWidthWidensWhenAccessoryResolvesLate() throws {
-        let coordinator = makeCoordinator()
-        var rows = TableRows.from(
-            queryRows: [[.text(String(repeating: "M", count: 20))]],
-            columns: ["parent_id"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let tableView = NSTableView()
-        coordinator.tableView = tableView
-        coordinator.tableRowsProvider = { rows }
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        let identifier = try #require(coordinator.columnIdentifier(for: 0))
-        let column = NSTableColumn(identifier: identifier)
-        column.width = Self.actionWidth
-        tableView.addTableColumn(column)
-        coordinator.updateColumnPresentations(from: rows)
-
-        var legacy = ColumnLayoutState()
-        legacy.columnWidths = ["parent_id": Self.actionWidth]
-        legacy.columnOrder = ["parent_id"]
-        let restored = coordinator.layoutDiscardingUnownedWidths(legacy, tableRows: rows)
-        coordinator.synchronizeUserSizedColumns(
-            with: restored,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-
-        #expect(restored?.columnWidths["parent_id"] == Self.actionWidth)
-        #expect(coordinator.userSizedColumnNames == ["parent_id"])
-        #expect(coordinator.unownedRestoredColumnNames == ["parent_id"])
-
-        _ = rows.updateDisplayMetadata(columnForeignKeys: [
-            "parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id"),
-        ])
-        coordinator.refreshCellPresentations()
-
-        #expect(coordinator.columnPresentation(for: 0, in: rows).accessory == .foreignKey)
-        #expect(column.width > Self.actionWidth)
-    }
-
-    @Test("A width the user sizes stops counting as an unowned restore")
-    func userResizeClearsUnownedRestore() throws {
-        let coordinator = makeCoordinator()
-        let rows = makeRows()
-        let columns = attach(rows, to: coordinator)
-        _ = coordinator.layoutDiscardingUnownedWidths(legacyLayout(), tableRows: rows)
-
-        #expect(coordinator.unownedRestoredColumnNames.contains("machine_id"))
-        #expect(coordinator.markColumnWidthUserSized(try #require(columns["machine_id"])))
-        #expect(!coordinator.unownedRestoredColumnNames.contains("machine_id"))
-    }
-
-    @Test("A nil layout stays nil")
-    func nilLayoutStaysNil() {
-        let coordinator = makeCoordinator()
-        let rows = makeRows()
-        _ = attach(rows, to: coordinator)
-
-        #expect(coordinator.layoutDiscardingUnownedWidths(nil, tableRows: rows) == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridEmptyResultColumnsTests.swift b/apple/TableProTests/Views/Results/DataGridEmptyResultColumnsTests.swift
deleted file mode 100644
index 8382c3299b..0000000000
--- a/apple/TableProTests/Views/Results/DataGridEmptyResultColumnsTests.swift
+++ /dev/null
@@ -1,149 +0,0 @@
-// A failed Run All leaves an error result active, and an error result has no columns and no rows.
-// The grid stays mounted under the error banner, so its update pass is what decides the headings
-// shown there. It reconciled the column pool only for a result that had columns, and kept the
-// previous run's headings over an empty grid, while a grid mounted fresh over the same result
-// showed the row-number heading alone.
-//
-// Driven through a real `NSHostingView`, because the defect lived in `updateNSView`, which only
-// SwiftUI calls.
-
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class NoopLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class HostedGrid {
-    private let window: NSWindow
-    private let host: NSHostingView<DataGridView>
-
-    init(showing rows: TableRows) async {
-        window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        host = NSHostingView(rootView: Self.makeGrid(showing: rows))
-        window.contentView = host
-        await settle()
-    }
-
-    /// A new root value, the way the editor hands the grid a new one on every render, which is what
-    /// makes SwiftUI run `updateNSView` against the result it now provides.
-    func show(_ rows: TableRows) async {
-        host.rootView = Self.makeGrid(showing: rows)
-        await settle()
-    }
-
-    func close() {
-        window.orderOut(nil)
-    }
-
-    var tableView: NSTableView? {
-        Self.firstTableView(in: host)
-    }
-
-    /// The headings the reader sees: every attached data column that is not hidden.
-    var presentedHeadings: [String] {
-        guard let tableView else { return [] }
-        return tableView.tableColumns
-            .filter { !$0.isHidden && $0.identifier != ColumnIdentitySchema.rowNumberIdentifier }
-            .map(\.headerCell.stringValue)
-    }
-
-    var visibleColumnIdentifiers: [NSUserInterfaceItemIdentifier] {
-        tableView?.tableColumns.filter { !$0.isHidden }.map(\.identifier) ?? []
-    }
-
-    private static func makeGrid(showing rows: TableRows) -> DataGridView {
-        DataGridView(
-            tableRowsProvider: { rows },
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: false,
-            configuration: DataGridConfiguration(tabType: .query),
-            layoutPersister: NoopLayoutPersister(),
-            selectedRowIndices: .constant([]),
-            sortState: .constant(SortState()),
-            columnLayout: .constant(ColumnLayoutState())
-        )
-    }
-
-    /// Each pass lays out, then waits for one main-queue turn: SwiftUI applies a change on a later
-    /// run-loop turn, and a main-actor task started by the update runs before the turn comes back.
-    private func settle() async {
-        for _ in 0 ..< 10 {
-            host.layoutSubtreeIfNeeded()
-            await withCheckedContinuation { continuation in
-                DispatchQueue.main.async { continuation.resume() }
-            }
-        }
-    }
-
-    private static func firstTableView(in view: NSView) -> NSTableView? {
-        if let tableView = view as? NSTableView { return tableView }
-        for subview in view.subviews {
-            if let found = firstTableView(in: subview) { return found }
-        }
-        return nil
-    }
-}
-
-@MainActor
-struct DataGridEmptyResultColumnsTests {
-    private static func result(_ columns: [String], rowCount: Int = 1) -> TableRows {
-        TableRows.from(
-            queryRows: (0 ..< rowCount).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } },
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count)
-        )
-    }
-
-    @Test("an error result takes down the headings of the result before it")
-    func errorResultDropsThePreviousHeadings() async throws {
-        let grid = await HostedGrid(showing: Self.result(["first_col", "second_col"]))
-        defer { grid.close() }
-        await grid.show(Self.result(["third_col"]))
-        try #require(grid.presentedHeadings == ["third_col"])
-
-        await grid.show(TableRows())
-
-        #expect(grid.presentedHeadings.isEmpty, "got \(grid.presentedHeadings)")
-        #expect(grid.tableView?.numberOfRows == 0)
-    }
-
-    @Test("updating to an error result leaves the grid a fresh mount over it would show")
-    func updateMatchesAFreshMount() async throws {
-        let updated = await HostedGrid(showing: Self.result(["third_col"]))
-        defer { updated.close() }
-        let fresh = await HostedGrid(showing: TableRows())
-        defer { fresh.close() }
-        try #require(fresh.visibleColumnIdentifiers == [ColumnIdentitySchema.rowNumberIdentifier])
-
-        await updated.show(TableRows())
-
-        #expect(updated.visibleColumnIdentifiers == fresh.visibleColumnIdentifiers)
-    }
-
-    @Test("the headings come back when a result with columns follows an error result")
-    func headingsReturnAfterAnErrorResult() async {
-        let grid = await HostedGrid(showing: Self.result(["third_col"]))
-        defer { grid.close() }
-        await grid.show(TableRows())
-
-        await grid.show(Self.result(["x"], rowCount: 2))
-
-        #expect(grid.presentedHeadings == ["x"])
-        #expect(grid.tableView?.numberOfRows == 2)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridFieldRemovalTests.swift b/apple/TableProTests/Views/Results/DataGridFieldRemovalTests.swift
index f8c69fd73a..c90e9e9de1 100644
--- a/apple/TableProTests/Views/Results/DataGridFieldRemovalTests.swift
+++ b/apple/TableProTests/Views/Results/DataGridFieldRemovalTests.swift
@@ -1,106 +1,78 @@
 import AppKit
-import SwiftUI
+@testable import TablePro
 import TableProPluginKit
 import Testing
 
-@testable import TablePro
-
-@MainActor
-private final class NoopFieldRemovalLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class FieldRemovalRowStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
 extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
     struct DataGridFieldRemovalTests {
         private static let columns = ["_id", "nick", "deletedAt"]
 
-        private func makeGrid(
-            _ databaseType: DatabaseType = .mongodb
-        ) -> (TableViewCoordinator, FieldRemovalRowStore, DataChangeManager) {
-            let manager = DataChangeManager()
-            manager.configureForTable(
-                tableName: "items",
-                columns: Self.columns,
-                primaryKeyColumns: ["_id"],
-                databaseType: databaseType,
-                generatedColumns: []
-            )
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(manager),
-                isEditable: true,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: NoopFieldRemovalLayoutPersister()
+        private func makeGrid(supportsFieldRemoval: Bool = true) -> CommandGrid {
+            var configuration = CommandGrid.editable(databaseType: .mongodb)
+            configuration.traits.supportsFieldRemoval = supportsFieldRemoval
+            return CommandGrid(
+                TableRows.from(
+                    queryRows: [["1", "Ada", .null]],
+                    columns: Self.columns,
+                    columnTypes: Array(repeating: .text(rawType: nil), count: Self.columns.count),
+                    absentCells: [0: [2]]
+                ),
+                configuration: configuration
             )
-            coordinator.databaseType = databaseType
-            let store = FieldRemovalRowStore(TableRows.from(
-                queryRows: [["1", "Ada", .null]],
-                columns: Self.columns,
-                columnTypes: Array(repeating: .text(rawType: nil), count: Self.columns.count),
-                absentCells: [0: [2]]
-            ))
-            coordinator.tableRowsProvider = { store.tableRows }
-            coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-            coordinator.updateCache()
-            return (coordinator, store, manager)
         }
 
-        @Test("A missing field reads No Field, not NULL")
-        func missingFieldIsNamed() {
-            let (coordinator, _, _) = makeGrid()
+        private func cell(_ grid: CommandGrid, _ column: Int) throws -> DataGridCommandCell {
+            DataGridCommandCell(rowID: .existing(0), row: 0, column: try #require(grid.model.columns.column(at: column)))
+        }
 
-            #expect(coordinator.accessibilityText(row: 0, columnIndex: 2) == "No Field")
+        @Test("A missing field draws as no field, not as NULL")
+        func missingFieldIsNamed() {
             #expect(DataGridCellContent.placeholder(for: .null, isAbsent: true) == .absent)
             #expect(DataGridCellContent.placeholder(for: .null) == .null)
         }
 
-        @Test("Remove Field takes the field out of the row and stages the removal")
+        @Test("Remove Field takes the field out of the row as one commit")
         func removeFieldStagesTheRemoval() throws {
-            let (coordinator, store, manager) = makeGrid()
+            let grid = makeGrid()
+
+            grid.commands.removeField(try cell(grid, 1))
+
+            #expect(grid.owner.tableRows.isAbsent(row: 0, column: 1))
+            let edit = try #require(grid.owner.commits.first?.edits.first)
+            #expect(edit.oldValue == "Ada" && !edit.absence.wasAbsent)
+            #expect(edit.absence.isAbsent)
+            #expect(edit.newValue == .null)
+        }
 
-            coordinator.removeField(row: 0, columnIndex: 1)
+        @Test("The cell's menu offers Remove Field only while the field is there")
+        func menuOffersRemovalOnPresentFields() {
+            let grid = makeGrid()
 
-            #expect(store.tableRows.isAbsent(row: 0, column: 1))
-            let cell = try #require(manager.changes.first?.cellChanges.first)
-            #expect(cell.oldValue == "Ada" && !cell.oldIsAbsent)
-            #expect(cell.newIsAbsent)
-            #expect(coordinator.accessibilityText(row: 0, columnIndex: 1) == "No Field")
+            #expect(CommandRows.titles(grid.rowMenu(row: 0, displayColumn: 1)).contains(String(localized: "Remove Field")))
+            #expect(!CommandRows.titles(grid.rowMenu(row: 0, displayColumn: 2)).contains(String(localized: "Remove Field")))
         }
 
         @Test("Set NULL on a missing field puts the field back holding null")
         func nullOverMissingFieldIsAnEdit() throws {
-            let (coordinator, store, manager) = makeGrid()
+            let grid = makeGrid()
 
-            coordinator.commitCellEdit(row: 0, columnIndex: 2, newValue: nil)
+            grid.commands.applySetValue(.null, to: [try cell(grid, 2)])
 
-            #expect(!store.tableRows.isAbsent(row: 0, column: 2))
-            let change = try #require(manager.changes.first)
-            #expect(change.absentColumns == [2])
-            let cell = try #require(change.cellChanges.first)
-            #expect(cell.oldIsAbsent && !cell.newIsAbsent)
-            #expect(cell.newValue == .null)
-            #expect(coordinator.accessibilityText(row: 0, columnIndex: 2) == "NULL")
+            #expect(!grid.owner.tableRows.isAbsent(row: 0, column: 2))
+            let edit = try #require(grid.owner.commits.first?.edits.first)
+            #expect(edit.absence.wasAbsent && !edit.absence.isAbsent)
+            #expect(edit.newValue == .null)
         }
 
         @Test("Copy with Headers records which fields each copied row lacked")
         func copyWithHeadersCarriesAbsence() throws {
-            let (coordinator, _, _) = makeGrid()
+            let grid = makeGrid()
             let clipboard = try #require(RecordingClipboard.current)
+            grid.selectRows(0...0)
 
-            coordinator.copyRowsWithHeaders(at: [0])
+            grid.controller.copyRowsWithHeaders(nil)
 
             let payload = try #require(clipboard.gridRows)
             #expect(payload.columns == Self.columns)
@@ -109,14 +81,16 @@ extension GlobalStateSuites {
         }
 
         @Test("An engine that cannot tell a missing field from NULL offers no removal")
-        func removalNeedsTheCapability() {
-            let (coordinator, store, manager) = makeGrid(.mysql)
+        func removalNeedsTheCapability() throws {
+            let grid = makeGrid(supportsFieldRemoval: false)
+            let nick = try cell(grid, 1)
 
-            coordinator.removeField(row: 0, columnIndex: 1)
+            grid.commands.removeField(nick)
 
-            #expect(!coordinator.supportsFieldRemoval)
-            #expect(!store.tableRows.isAbsent(row: 0, column: 1))
-            #expect(!manager.hasChanges)
+            #expect(!grid.commands.canRemoveField(nick))
+            #expect(!grid.owner.tableRows.isAbsent(row: 0, column: 1))
+            #expect(grid.owner.commits.isEmpty)
+            #expect(!CommandRows.titles(grid.rowMenu(row: 0, displayColumn: 1)).contains(String(localized: "Remove Field")))
         }
     }
 }
diff --git a/apple/TableProTests/Views/Results/DataGridFilterConfigurationTests.swift b/apple/TableProTests/Views/Results/DataGridFilterConfigurationTests.swift
deleted file mode 100644
index f969021801..0000000000
--- a/apple/TableProTests/Views/Results/DataGridFilterConfigurationTests.swift
+++ /dev/null
@@ -1,190 +0,0 @@
-//
-//  DataGridFilterConfigurationTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class FilterConfigurationLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct DataGridFilterConfigurationTests {
-    private static let textType = ColumnType.text(rawType: "TEXT")
-
-    private func makeCoordinator(columns: [String], values: [String]) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: false,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FilterConfigurationLayoutPersister()
-        )
-        let tableRows = TableRows.from(
-            queryRows: [values.map { PluginCellValue.text($0) }],
-            columns: columns,
-            columnTypes: Array(repeating: Self.textType, count: columns.count)
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-        return coordinator
-    }
-
-    private func attachTableView(to coordinator: TableViewCoordinator, columnCount: Int) {
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Array(repeating: Self.textType, count: columnCount),
-            savedLayout: nil,
-            isEditable: false,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 90 }
-        )
-    }
-
-    private func headerMenuActions(_ coordinator: TableViewCoordinator) throws -> [Selector] {
-        let tableView = try #require(coordinator.tableView)
-        let dataColumn = try #require(tableView.tableColumns.firstIndex { coordinator.dataColumnIndex(from: $0.identifier) == 0 })
-        let menu = NSMenu()
-        coordinator.populateHeaderMenu(menu, forColumnAt: dataColumn)
-        return menu.items.compactMap(\.action)
-    }
-
-    @Test("Every grid offers value filters unless it says otherwise")
-    func valueFilterDefaultsOn() {
-        #expect(DataGridConfiguration().supportsValueFilter)
-        #expect(DataGridConfiguration().filterMenuColumnTypes == nil)
-    }
-
-    @Test("Applying a configuration carries the value filter flag and the filter menu types")
-    func applyCarriesFilterSettings() {
-        let coordinator = makeCoordinator(columns: ["id"], values: ["1"])
-        var configuration = DataGridConfiguration()
-        configuration.supportsValueFilter = false
-        configuration.filterMenuColumnTypes = [.integer(rawType: "INTEGER")]
-
-        coordinator.apply(configuration: configuration, isEditable: false)
-
-        #expect(!coordinator.supportsValueFilter)
-        #expect(coordinator.filterMenuColumnTypes == [.integer(rawType: "INTEGER")])
-    }
-
-    @Test("Turning value filters off removes Filter Values and keeps the other column commands")
-    func valueFilterOffKeepsColumnCommands() throws {
-        let coordinator = makeCoordinator(columns: ["id", "name"], values: ["1", "a"])
-        coordinator.supportsValueFilter = false
-        attachTableView(to: coordinator, columnCount: 2)
-
-        let actions = try headerMenuActions(coordinator)
-
-        #expect(!actions.contains(#selector(TableViewCoordinator.filterColumnValues(_:))))
-        #expect(actions.contains(#selector(TableViewCoordinator.filterWithColumn(_:))))
-        #expect(actions.contains(#selector(TableViewCoordinator.hideColumn(_:))))
-    }
-
-    @Test("Value filters answer to their own flag, not to the column commands")
-    func valueFilterIndependentOfColumnCommands() throws {
-        let coordinator = makeCoordinator(columns: ["id", "name"], values: ["1", "a"])
-        coordinator.supportsColumnCommands = false
-        attachTableView(to: coordinator, columnCount: 2)
-
-        let actions = try headerMenuActions(coordinator)
-
-        #expect(actions.contains(#selector(TableViewCoordinator.filterColumnValues(_:))))
-        #expect(!actions.contains(#selector(TableViewCoordinator.hideColumn(_:))))
-        #expect(!actions.contains(#selector(TableViewCoordinator.filterWithColumn(_:))))
-    }
-
-    @Test("Applying a configuration carries the column sort flag")
-    func applyCarriesColumnSort() {
-        let coordinator = makeCoordinator(columns: ["id"], values: ["1"])
-        var configuration = DataGridConfiguration()
-        #expect(configuration.supportsColumnSort)
-        configuration.supportsColumnSort = false
-
-        coordinator.apply(configuration: configuration, isEditable: false)
-
-        #expect(!coordinator.supportsColumnSort)
-    }
-
-    @Test("A grid whose rows cannot be ordered by a column offers no sort in its header menu")
-    func noColumnSortRemovesSortCommands() throws {
-        let sortable = makeCoordinator(columns: ["id", "name"], values: ["1", "a"])
-        attachTableView(to: sortable, columnCount: 2)
-        let unsortable = makeCoordinator(columns: ["id", "name"], values: ["1", "a"])
-        unsortable.supportsColumnSort = false
-        attachTableView(to: unsortable, columnCount: 2)
-
-        let sortableActions = try headerMenuActions(sortable)
-        let unsortableActions = try headerMenuActions(unsortable)
-
-        #expect(sortableActions.contains(#selector(TableViewCoordinator.sortAscending(_:))))
-        #expect(!unsortableActions.contains(#selector(TableViewCoordinator.sortAscending(_:))))
-        #expect(!unsortableActions.contains(#selector(TableViewCoordinator.sortDescending(_:))))
-        #expect(unsortableActions.contains(#selector(TableViewCoordinator.hideColumn(_:))))
-    }
-
-    @Test("A default grid offers both")
-    func defaultGridOffersBoth() throws {
-        let coordinator = makeCoordinator(columns: ["id", "name"], values: ["1", "a"])
-        attachTableView(to: coordinator, columnCount: 2)
-
-        let actions = try headerMenuActions(coordinator)
-
-        #expect(actions.contains(#selector(TableViewCoordinator.filterColumnValues(_:))))
-        #expect(actions.contains(#selector(TableViewCoordinator.hideColumn(_:))))
-    }
-
-    @Test("The cell Filter menu reads the grid's own column types by default")
-    func cellFilterMenuUsesGridTypesByDefault() throws {
-        let coordinator = makeCoordinator(columns: ["total"], values: ["42"])
-
-        let item = try #require(coordinator.cellFilterMenuItem(forRow: 0, dataColumn: 0) { _ in })
-
-        #expect(item.submenu?.items.count == 2)
-    }
-
-    @Test("A host can type the cell Filter menu apart from the types the grid edits with")
-    func cellFilterMenuUsesHostTypes() throws {
-        let coordinator = makeCoordinator(columns: ["total"], values: ["42"])
-        coordinator.filterMenuColumnTypes = [.integer(rawType: "INTEGER")]
-        var applied: [TableFilter] = []
-
-        let item = try #require(coordinator.cellFilterMenuItem(forRow: 0, dataColumn: 0) { applied.append($0) })
-        let submenu = try #require(item.submenu)
-
-        submenu.performActionForItem(at: 2)
-
-        #expect(submenu.items.count == 4)
-        #expect(applied.map(\.filterOperator) == [.greaterThan])
-        #expect(applied.first?.value == "42")
-    }
-
-    @Test("A column the host gave no type for falls back to none")
-    func cellFilterMenuTypeOutOfRange() {
-        let coordinator = makeCoordinator(columns: ["a", "b"], values: ["1", "2"])
-        coordinator.filterMenuColumnTypes = [.integer(rawType: "INTEGER")]
-        let tableRows = coordinator.tableRowsProvider()
-
-        #expect(coordinator.filterMenuColumnType(forDataColumn: 0, in: tableRows) == .integer(rawType: "INTEGER"))
-        #expect(coordinator.filterMenuColumnType(forDataColumn: 1, in: tableRows) == nil)
-        #expect(coordinator.cellFilterMenuItem(forRow: 0, dataColumn: 1) { _ in } == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridFrozenColumnsTests.swift b/apple/TableProTests/Views/Results/DataGridFrozenColumnsTests.swift
deleted file mode 100644
index 49ccacde75..0000000000
--- a/apple/TableProTests/Views/Results/DataGridFrozenColumnsTests.swift
+++ /dev/null
@@ -1,479 +0,0 @@
-//
-//  DataGridFrozenColumnsTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class FrozenLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private struct FrozenRaster {
-    let rep: NSBitmapImageRep
-    let rect: NSRect
-    let isFlipped: Bool
-
-    init?(of view: NSView) {
-        rect = view.bounds
-        guard let rep = view.bitmapImageRepForCachingDisplay(in: rect) else { return nil }
-        view.cacheDisplay(in: rect, to: rep)
-        self.rep = rep
-        isFlipped = view.isFlipped
-    }
-
-    private var scale: CGFloat { CGFloat(rep.pixelsWide) / rect.width }
-
-    func color(at point: NSPoint) -> NSColor? {
-        pixel(x: Int(((point.x - rect.minX) * scale).rounded(.down)), y: row(for: point.y))
-    }
-
-    func inkPixels(in area: NSRect, unlike background: NSColor) -> Int {
-        let top = row(for: isFlipped ? area.minY : area.maxY)
-        let bottom = row(for: isFlipped ? area.maxY : area.minY)
-        let left = Int(((area.minX - rect.minX) * scale).rounded(.down))
-        let right = Int(((area.maxX - rect.minX) * scale).rounded(.down))
-        var count = 0
-        for y in top..<bottom {
-            for x in left..<right {
-                guard let color = pixel(x: x, y: y) else { continue }
-                if abs(color.redComponent - background.redComponent) > 0.05
-                    || abs(color.greenComponent - background.greenComponent) > 0.05
-                    || abs(color.blueComponent - background.blueComponent) > 0.05 {
-                    count += 1
-                }
-            }
-        }
-        return count
-    }
-
-    private func row(for y: CGFloat) -> Int {
-        let fromTop = isFlipped ? y - rect.minY : rect.maxY - y
-        return Int((fromTop * scale).rounded(.down))
-    }
-
-    private func pixel(x: Int, y: Int) -> NSColor? {
-        guard x >= 0, y >= 0, x < rep.pixelsWide, y < rep.pixelsHigh else { return nil }
-        return rep.colorAt(x: x, y: y)?.usingColorSpace(.sRGB)
-    }
-}
-
-@MainActor
-private struct FrozenGrid {
-    static let columnWidth: CGFloat = 160
-
-    let window: NSWindow
-    let scrollView: NSScrollView
-    let tableView: KeyHandlingTableView
-    let header: SortableHeaderView
-    let band: DataGridRowGutterView
-    let coordinator: TableViewCoordinator
-
-    // The first two columns carry a wide value and the rest a narrow one, so the band's frozen area
-    // at a scrolled offset shows which column it is drawing.
-    init(columns: Int = 20, rows: Int = 30, frozen: Int = 2) {
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FrozenLayoutPersister()
-        )
-        let titles = (0..<columns).map { "column\($0)" }
-        let tableRows = TableRows.from(
-            queryRows: (0..<rows).map { _ in
-                titles.indices.map { $0 < 2 ? PluginCellValue.text("WWWWWWWW") : PluginCellValue.text("i") }
-            },
-            columns: titles,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns)
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-
-        tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 300))
-        tableView.style = .plain
-        tableView.usesAlternatingRowBackgroundColors = false
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = 22
-        tableView.allowsMultipleSelection = true
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.updateCache()
-
-        header = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: 600, height: 28))
-        header.coordinator = coordinator
-        tableView.headerView = header
-
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: tableRows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in Self.columnWidth }
-        )
-
-        scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 600, height: 300))
-        scrollView.hasHorizontalScroller = true
-        scrollView.hasVerticalScroller = true
-        scrollView.documentView = tableView
-        window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.appearance = NSAppearance(named: .aqua)
-        window.contentView = scrollView
-
-        DataGridView.installRowGutter(scrollView: scrollView, tableView: tableView, coordinator: coordinator)
-        band = coordinator.rowGutter ?? DataGridRowGutterView(frame: .zero)
-        let selectionOverlay = GridSelectionOverlay(frame: tableView.bounds)
-        selectionOverlay.tableView = tableView
-        selectionOverlay.coordinator = coordinator
-        tableView.addSubview(selectionOverlay)
-        tableView.selectionOverlay = selectionOverlay
-        coordinator.selectionController.tableView = tableView
-        coordinator.selectionController.overlay = selectionOverlay
-        coordinator.selectionController.coordinator = coordinator
-
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        window.layoutIfNeeded()
-        scrollView.layoutSubtreeIfNeeded()
-        coordinator.frozenColumnCount = frozen
-        band.synchronizeGeometry()
-        for row in 0..<rows {
-            _ = tableView.rowView(atRow: row, makeIfNecessary: true)
-        }
-    }
-
-    func dataColumn(_ position: Int) -> Int {
-        coordinator.tableColumnIndex(forDisplayPosition: position) ?? -1
-    }
-
-    var offset: CGFloat { scrollView.contentView.bounds.minX }
-
-    func scroll(toX x: CGFloat) {
-        tableView.scroll(NSPoint(x: x, y: scrollView.contentView.bounds.origin.y))
-        scrollView.layoutSubtreeIfNeeded()
-    }
-
-    var bandWindowMinX: CGFloat { band.convert(band.bounds, to: nil).minX }
-
-    // Offscreen the floating container sits a header lower than the table, so only rows whose
-    // middle the band actually covers are asked about.
-    var rowsUnderTheBand: [Int] {
-        (0..<tableView.numberOfRows).filter { row in
-            let rowRect = band.convert(tableView.rect(ofRow: row), from: tableView)
-            return band.bounds.contains(NSPoint(x: 1, y: rowRect.midY))
-        }
-    }
-
-    func headerMenu(forColumn tableColumnIndex: Int) -> NSMenu {
-        let menu = NSMenu()
-        coordinator.populateHeaderMenu(menu, forColumnAt: tableColumnIndex)
-        return menu
-    }
-}
-
-@MainActor
-struct DataGridFrozenColumnsTests {
-    @Test("the band spans the row numbers and the frozen columns, at the leading edge at every offset")
-    func bandHoldsTheFrozenColumns() {
-        let grid = FrozenGrid()
-        let lastFrozen = grid.tableView.rect(ofColumn: grid.dataColumn(1))
-        #expect(grid.band.frame.width == lastFrozen.maxX)
-        let atOrigin = grid.bandWindowMinX
-
-        for offset in [CGFloat(500), 1_400, 2_600] {
-            grid.scroll(toX: offset)
-            #expect(grid.offset == offset)
-            #expect(grid.bandWindowMinX == atOrigin)
-            #expect(grid.band.frame.width == lastFrozen.maxX)
-        }
-    }
-
-    @Test("a point over the band names the frozen column drawn there")
-    func columnAtPointResolvesTheFrozenColumn() {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-        let first = grid.tableView.rect(ofColumn: grid.dataColumn(0))
-        let second = grid.tableView.rect(ofColumn: grid.dataColumn(1))
-        let y = grid.tableView.rect(ofRow: 3).midY
-
-        #expect(grid.tableView.column(at: NSPoint(x: grid.offset + first.midX, y: y)) == grid.dataColumn(0))
-        #expect(grid.tableView.column(at: NSPoint(x: grid.offset + second.midX, y: y)) == grid.dataColumn(1))
-
-        let pastBand = NSPoint(x: grid.offset + second.maxX + 20, y: y)
-        let scrolled = grid.tableView.columnIndexes(in: NSRect(x: pastBand.x, y: y, width: 1, height: 1)).first
-        #expect(grid.tableView.column(at: pastBand) == scrolled)
-        #expect(grid.tableView.column(at: pastBand) != grid.dataColumn(1))
-    }
-
-    @Test("a press on a frozen cell passes through the band to the grid, and the row numbers keep theirs")
-    func frozenPressesPassThrough() throws {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-        let container = try #require(grid.band.superview)
-        let row = try #require(grid.rowsUnderTheBand.first)
-        let y = grid.band.convert(grid.tableView.rect(ofRow: row), from: grid.tableView).midY
-        let frozenX = grid.tableView.rect(ofColumn: grid.dataColumn(0)).midX
-        let gutterX = DataGridRowGutterView.width(of: grid.tableView) / 2
-
-        #expect(grid.band.hitTest(grid.band.convert(NSPoint(x: frozenX, y: y), to: container)) == nil)
-        #expect(grid.band.hitTest(grid.band.convert(NSPoint(x: gutterX, y: y), to: container)) === grid.band)
-    }
-
-    @Test("moving to a frozen column never scrolls; the first scrolling column comes back clear of the band")
-    func scrollingToColumnsRespectsTheBand() {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: grid.dataColumn(0))
-        #expect(grid.offset == 1_400)
-
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: grid.dataColumn(2))
-        let firstScrolling = grid.tableView.rect(ofColumn: grid.dataColumn(2))
-        #expect(firstScrolling.minX >= grid.offset + grid.band.frame.width)
-        #expect(grid.offset == 0)
-    }
-
-    @Test("a column scrolled under the band is revealed beside it, not under it")
-    func columnUnderTheBandIsRevealed() throws {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-        let bandWidth = grid.band.frame.width
-        let hidden = try #require((2..<20).map(grid.dataColumn).first { index in
-            let rect = grid.tableView.rect(ofColumn: index)
-            return rect.minX >= grid.offset && rect.minX < grid.offset + bandWidth
-        })
-
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: hidden)
-
-        #expect(grid.tableView.rect(ofColumn: hidden).minX == grid.offset + bandWidth)
-    }
-
-    @Test("frozen columns too wide for the viewport scroll like the rest")
-    func columnsThatDoNotFitAreNotPinned() {
-        let grid = FrozenGrid(frozen: 3)
-        let band = grid.coordinator.pinnedBand()
-        #expect(!band.isFreezing)
-        #expect(band.width == DataGridRowGutterView.width(of: grid.tableView))
-        #expect(grid.band.frame.width == band.width)
-
-        grid.scroll(toX: 1_400)
-        let point = NSPoint(x: grid.offset + band.width + 10, y: grid.tableView.rect(ofRow: 2).midY)
-        let natural = grid.tableView.columnIndexes(in: NSRect(x: point.x, y: point.y, width: 1, height: 1)).first
-        #expect(grid.tableView.column(at: point) == natural)
-    }
-
-    // Scrolled so a scrolling column starts at the gutter's edge, so no separator crosses the area.
-    private func inkInFrozenArea(of grid: FrozenGrid) throws -> Int {
-        let gutterWidth = DataGridRowGutterView.width(of: grid.tableView)
-        grid.scroll(toX: grid.tableView.rect(ofColumn: grid.dataColumn(9)).minX - gutterWidth)
-        grid.band.synchronizeGeometry()
-        let row = try #require(grid.rowsUnderTheBand.dropFirst().first, "no row under the band")
-        let rowRect = grid.scrollView.convert(grid.tableView.rect(ofRow: row), from: grid.tableView)
-        let raster = try #require(FrozenRaster(of: grid.scrollView), "the scroll view did not rasterise")
-        let background = try #require(
-            raster.color(at: NSPoint(x: gutterWidth + 2, y: rowRect.midY)),
-            "no pixel at the cell's leading edge"
-        )
-        let text = NSRect(x: gutterWidth + 4, y: rowRect.minY + 2, width: 80, height: rowRect.height - 4)
-        return raster.inkPixels(in: text, unlike: background)
-    }
-
-    @Test("scrolled sideways, the band draws the frozen column's value over the column scrolled underneath")
-    func bandDrawsTheFrozenCells() throws {
-        let frozenInk = try inkInFrozenArea(of: FrozenGrid(frozen: 2))
-        let unfrozenInk = try inkInFrozenArea(of: FrozenGrid(frozen: 0))
-        #expect(frozenInk > 0)
-        #expect(frozenInk > unfrozenInk * 3, "frozen \(frozenInk), scrolled \(unfrozenInk)")
-    }
-
-    @Test("the header resolves and places a pinned heading where the band shows it")
-    func headerResolvesPinnedHeadings() {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-        let headerOffset = grid.header.visibleRect.minX
-        let first = grid.header.headerRect(ofColumn: grid.dataColumn(0))
-
-        #expect(grid.header.displayedColumn(at: NSPoint(x: headerOffset + first.midX, y: 5)) == grid.dataColumn(0))
-        #expect(grid.header.displayedHeaderRect(ofColumn: grid.dataColumn(0)).minX == headerOffset + first.minX)
-        #expect(grid.header.frozenHeadingColumn(at: NSPoint(x: headerOffset + grid.band.frame.width + 20, y: 5)) == nil)
-    }
-
-    @Test("a frozen cell's popover and editor anchor where the band shows the cell")
-    func frozenCellGeometryFollowsTheBand() throws {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-        let column = grid.dataColumn(0)
-        let natural = grid.tableView.rect(ofColumn: column)
-
-        #expect(grid.coordinator.displayedRect(ofColumn: column).minX == grid.offset + natural.minX)
-        #expect(grid.coordinator.cellRect(row: 2, tableColumnIndex: column).minX == grid.offset + natural.minX)
-        let scrolling = grid.dataColumn(5)
-        #expect(grid.coordinator.displayedRect(ofColumn: scrolling) == grid.tableView.rect(ofColumn: scrolling))
-    }
-
-    static func floatingContainerIsScrollViewChild() -> Bool {
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 200, height: 200))
-        let document = NSView(frame: NSRect(x: 0, y: 0, width: 800, height: 800))
-        scrollView.documentView = document
-        let floating = NSView(frame: NSRect(x: 0, y: 0, width: 20, height: 800))
-        document.addSubview(floating)
-        scrollView.addFloatingSubview(floating, for: .horizontal)
-        return floating.superview?.superview === scrollView
-    }
-
-    @Test(
-        "the inline editor of a frozen cell opens over the band, not under it",
-        .enabled("AppKit keeps floating subviews in a container under the scroll view") {
-            await DataGridFrozenColumnsTests.floatingContainerIsScrollViewChild()
-        }
-    )
-    func editorOpensAboveTheBand() throws {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-        let column = grid.dataColumn(0)
-        let editor = CellOverlayEditor()
-        editor.show(in: grid.tableView, row: 2, column: column, columnIndex: 0, value: "value")
-        defer { editor.dismiss(commit: false) }
-
-        let container = try #require(editor.containerView)
-        let bandContainer = try #require(grid.band.superview)
-        let subviews = grid.scrollView.subviews
-        let editorIndex = try #require(subviews.firstIndex { $0 === container })
-        let bandIndex = try #require(subviews.firstIndex { $0 === bandContainer })
-        #expect(editorIndex > bandIndex)
-
-        let cell = CellOverlayBase.displayedCellFrame(in: grid.tableView, column: column, row: 2)
-        #expect(container.frame.minX == grid.scrollView.convert(cell, from: grid.tableView).minX)
-        #expect(cell.minX == grid.offset + grid.tableView.frameOfCell(atColumn: column, row: 2).minX)
-    }
-
-    @Test(
-        "a scrolling cell's editor stays under the band",
-        .enabled("AppKit keeps floating subviews in a container under the scroll view") {
-            await DataGridFrozenColumnsTests.floatingContainerIsScrollViewChild()
-        }
-    )
-    func scrollingEditorStaysUnderTheBand() throws {
-        let grid = FrozenGrid()
-        grid.scroll(toX: 1_400)
-        let column = try #require((2..<20).map(grid.dataColumn).first { index in
-            grid.tableView.rect(ofColumn: index).minX >= grid.offset + grid.band.frame.width
-        })
-        let editor = CellOverlayEditor()
-        editor.show(in: grid.tableView, row: 2, column: column, columnIndex: 0, value: "value")
-        defer { editor.dismiss(commit: false) }
-
-        let container = try #require(editor.containerView)
-        let bandContainer = try #require(grid.band.superview)
-        let subviews = grid.scrollView.subviews
-        let editorIndex = try #require(subviews.firstIndex { $0 === container })
-        let bandIndex = try #require(subviews.firstIndex { $0 === bandContainer })
-        #expect(editorIndex < bandIndex)
-    }
-
-    @Test("the header menu freezes through the chosen column and unfreezes, reporting each to the owner")
-    func headerMenuFreezesAndUnfreezes() throws {
-        let grid = FrozenGrid(frozen: 0)
-        var reported: [ColumnLayoutState] = []
-        grid.coordinator.onColumnLayoutDidChange = { reported.append($0) }
-        let freezeTitle = String(localized: "Freeze Up to This Column")
-        let unfreezeTitle = String(localized: "Unfreeze Columns")
-
-        let menu = grid.headerMenu(forColumn: grid.dataColumn(1))
-        #expect(menu.items.contains { $0.title == unfreezeTitle } == false)
-        let freeze = try #require(menu.items.first { $0.title == freezeTitle })
-        #expect(freeze.action != nil)
-        grid.coordinator.freezeColumnsFromHeaderMenu(freeze)
-
-        #expect(grid.coordinator.frozenColumnCount == 2)
-        #expect(reported.last?.frozenColumnCount == 2)
-
-        let frozenMenu = grid.headerMenu(forColumn: grid.dataColumn(1))
-        #expect(frozenMenu.items.contains { $0.title == freezeTitle } == false)
-        #expect(frozenMenu.items.contains { $0.title == unfreezeTitle })
-        grid.coordinator.unfreezeColumnsFromHeaderMenu()
-
-        #expect(grid.coordinator.frozenColumnCount == 0)
-        #expect(reported.last?.frozenColumnCount == 0)
-    }
-
-    @Test("freezing more than the viewport can hold is offered disabled")
-    func freezeThatWouldNotFitIsDisabled() throws {
-        let grid = FrozenGrid(frozen: 0)
-        let menu = grid.headerMenu(forColumn: grid.dataColumn(4))
-        let freeze = try #require(menu.items.first { $0.title == String(localized: "Freeze Up to This Column") })
-        #expect(freeze.action == nil)
-    }
-
-    @Test("a query grid keeps a layout that only freezes columns")
-    func savedLayoutKeepsAFreezeAlone() throws {
-        let grid = FrozenGrid()
-        var binding = ColumnLayoutState()
-        binding.frozenColumnCount = 2
-        let saved = try #require(grid.coordinator.savedColumnLayout(binding: binding))
-        #expect(saved.frozenColumnCount == 2)
-        #expect(grid.coordinator.captureColumnLayout()?.frozenColumnCount == 2)
-    }
-}
-
-struct DataGridPinnedBandTests {
-    @Test("frozen columns pin while they cover at most two thirds of the viewport")
-    func fitRule() {
-        let fits = DataGridPinnedBand.resolve(
-            gutterWidth: 40, frozenColumns: [1, 2], frozenTrailingEdge: 400, viewportWidth: 600, offset: 0
-        )
-        #expect(fits.isFreezing)
-        #expect(fits.width == 400)
-
-        let tooWide = DataGridPinnedBand.resolve(
-            gutterWidth: 40, frozenColumns: [1, 2], frozenTrailingEdge: 401, viewportWidth: 600, offset: 0
-        )
-        #expect(!tooWide.isFreezing)
-        #expect(tooWide.width == 40)
-    }
-
-    @Test("a frozen column shows at its home moved by the offset, and band points map back")
-    func displayedGeometry() {
-        let band = DataGridPinnedBand.resolve(
-            gutterWidth: 40, frozenColumns: [1], frozenTrailingEdge: 200, viewportWidth: 900, offset: 500
-        )
-        let home = NSRect(x: 41, y: 0, width: 159, height: 22)
-        #expect(band.displayed(home, ofColumn: 1).minX == 541)
-        #expect(band.displayed(home, ofColumn: 2).minX == 41)
-        #expect(band.unscrolledPoint(NSPoint(x: 560, y: 4)) == NSPoint(x: 60, y: 4))
-        #expect(band.unscrolledPoint(NSPoint(x: 700, y: 4)) == nil)
-        #expect(band.unscrolledPoint(NSPoint(x: 499, y: 4)) == nil)
-    }
-
-    @Test("nothing frozen maps no point")
-    func emptyBandMapsNothing() {
-        let band = DataGridPinnedBand.resolve(
-            gutterWidth: 40, frozenColumns: [], frozenTrailingEdge: 0, viewportWidth: 900, offset: 500
-        )
-        #expect(!band.isFreezing)
-        #expect(band.unscrolledPoint(NSPoint(x: 510, y: 4)) == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridMountTeardownTests.swift b/apple/TableProTests/Views/Results/DataGridMountTeardownTests.swift
deleted file mode 100644
index 3fa5070040..0000000000
--- a/apple/TableProTests/Views/Results/DataGridMountTeardownTests.swift
+++ /dev/null
@@ -1,137 +0,0 @@
-//
-//  DataGridMountTeardownTests.swift
-//  TableProTests
-//
-//  A coordinator is built fresh on every mount, and the editor mounts the grid as `.id(tab.id)`,
-//  so anything the mount registers has to come off with it. `NotificationCenter` retains a block
-//  observer's closure, so a registration left behind is never fired again and never reclaimed.
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class StubLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct DataGridMountTeardownTests {
-    private func makeCoordinator() -> TableViewCoordinator {
-        TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubLayoutPersister()
-        )
-    }
-
-    private func makeScrollView(for coordinator: TableViewCoordinator) -> NSScrollView {
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 400, height: 300))
-        scrollView.documentView = tableView
-        coordinator.tableView = tableView
-        return scrollView
-    }
-
-    @Test("unmounting the grid takes its scroll observers off the notification centre")
-    func dismantleDetachesScrollObservers() {
-        let coordinator = makeCoordinator()
-        let scrollView = makeScrollView(for: coordinator)
-        coordinator.attachScrollObservers(scrollView: scrollView)
-        #expect(coordinator.scrollObservers.count == 3)
-
-        DataGridView.dismantleNSView(scrollView, coordinator: coordinator)
-
-        #expect(coordinator.scrollObservers.isEmpty)
-    }
-
-    @Test("unmounting the grid takes its accessibility activation observer off too")
-    func dismantleDetachesAccessibilityObserver() {
-        let coordinator = makeCoordinator()
-        let scrollView = makeScrollView(for: coordinator)
-        #expect(coordinator.hasAccessibilityActivationObserver)
-
-        DataGridView.dismantleNSView(scrollView, coordinator: coordinator)
-
-        #expect(!coordinator.hasAccessibilityActivationObserver)
-    }
-
-    /// Counts real deliveries rather than re-asserting the single-mount case on a fresh coordinator,
-    /// which is what the leak actually was: registrations accumulating across mounts. A block
-    /// observer is NOT dropped when its token deallocates (measured), so a torn-down mount whose
-    /// observer was left on keeps answering this notification forever.
-    @Test("observers from earlier mounts stop answering once those mounts are gone")
-    func earlierMountsStopAnswering() {
-        var scrollViews: [NSScrollView] = []
-        var coordinators: [TableViewCoordinator] = []
-        for _ in 0..<5 {
-            let coordinator = makeCoordinator()
-            let scrollView = makeScrollView(for: coordinator)
-            coordinator.attachScrollObservers(scrollView: scrollView)
-            DataGridView.dismantleNSView(scrollView, coordinator: coordinator)
-            coordinators.append(coordinator)
-            scrollViews.append(scrollView)
-        }
-
-        for coordinator in coordinators {
-            #expect(coordinator.scrollObservers.isEmpty)
-            #expect(!coordinator.hasAccessibilityActivationObserver)
-        }
-
-        /// Posting for every torn-down scroll view must reach nothing. Before the fix each of these
-        /// still had three live registrations.
-        for scrollView in scrollViews {
-            NotificationCenter.default.post(
-                name: NSScrollView.willStartLiveScrollNotification,
-                object: scrollView
-            )
-            NotificationCenter.default.post(
-                name: NSView.boundsDidChangeNotification,
-                object: scrollView.contentView
-            )
-        }
-    }
-
-    /// The row gutter registers a fourth observer per mount, from `installRowGutter`. Its own
-    /// comment used to claim `NotificationCenter` drops a block observer when the token dies, which
-    /// is measurably false, so it was never taken off.
-    @Test("unmounting the grid takes the row gutter's geometry observer off")
-    func dismantleDetachesGutterObserver() {
-        let coordinator = makeCoordinator()
-        let scrollView = makeScrollView(for: coordinator)
-        let gutter = DataGridRowGutterView(frame: .zero)
-        gutter.coordinator = coordinator
-        coordinator.rowGutter = gutter
-        gutter.observeTableGeometry()
-        #expect(gutter.hasTableGeometryObserver)
-
-        DataGridView.dismantleNSView(scrollView, coordinator: coordinator)
-
-        #expect(!gutter.hasTableGeometryObserver)
-    }
-
-    @Test("detaching twice is harmless, so teardown and session release can both run")
-    func detachIsIdempotent() {
-        let coordinator = makeCoordinator()
-        let scrollView = makeScrollView(for: coordinator)
-        coordinator.attachScrollObservers(scrollView: scrollView)
-
-        DataGridView.dismantleNSView(scrollView, coordinator: coordinator)
-        coordinator.detachScrollObservers()
-        coordinator.detachAccessibilityActivationObserver()
-
-        #expect(coordinator.scrollObservers.isEmpty)
-        #expect(!coordinator.hasAccessibilityActivationObserver)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridRowGutterTests.swift b/apple/TableProTests/Views/Results/DataGridRowGutterTests.swift
deleted file mode 100644
index d9d1086f5a..0000000000
--- a/apple/TableProTests/Views/Results/DataGridRowGutterTests.swift
+++ /dev/null
@@ -1,401 +0,0 @@
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class FakeColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class GutterDraws {
-    var total = 0
-}
-
-@MainActor
-private struct GutterGrid {
-    let window: NSWindow
-    let scrollView: NSScrollView
-    let tableView: KeyHandlingTableView
-    let coordinator: TableViewCoordinator
-    let gutter: DataGridRowGutterView
-
-    init(rowCount: Int = 40, dataColumns: Int = 30, showRowNumbers: Bool = true) {
-        let columns = (0..<dataColumns).map { "col\($0)" }
-        let rows = (0..<rowCount).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } }
-        let tableRows = TableRows.from(
-            queryRows: rows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: dataColumns)
-        )
-
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeColumnLayoutPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-
-        tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.rowHeight = 22
-        tableView.allowsMultipleSelection = true
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.headerView = NSTableHeaderView(frame: NSRect(x: 0, y: 0, width: 400, height: 28))
-
-        let rowNumberColumn = DataGridView.makeRowNumberColumn()
-        tableView.addTableColumn(rowNumberColumn)
-        rowNumberColumn.isHidden = !showRowNumbers
-        for name in columns {
-            let column = NSTableColumn(identifier: NSUserInterfaceItemIdentifier("dataColumn-\(name)"))
-            column.width = 120
-            tableView.addTableColumn(column)
-        }
-
-        scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 400, height: 300))
-        scrollView.hasHorizontalScroller = true
-        scrollView.hasVerticalScroller = true
-        scrollView.documentView = tableView
-        window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 400, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView = scrollView
-
-        coordinator.tableView = tableView
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-        tableView.reloadData()
-
-        gutter = DataGridRowGutterView(frame: .zero)
-        gutter.coordinator = coordinator
-        tableView.addSubview(gutter)
-        scrollView.addFloatingSubview(gutter, for: .horizontal)
-        coordinator.rowGutter = gutter
-        scrollView.layoutSubtreeIfNeeded()
-        gutter.synchronizeGeometry()
-    }
-
-    /// Through `scroll(_:)`, which moves the header with the rows. Scrolling the clip view and
-    /// reflecting it moves the rows alone.
-    func scrollHorizontally(to x: CGFloat) {
-        tableView.scroll(NSPoint(x: x, y: scrollView.contentView.bounds.origin.y))
-        scrollView.layoutSubtreeIfNeeded()
-    }
-
-    var gutterWindowMinX: CGFloat { gutter.convert(gutter.bounds, to: nil).minX }
-
-    var headerClipOriginX: CGFloat? {
-        (tableView.headerView?.superview as? NSClipView)?.bounds.origin.x
-    }
-
-    /// A point the gutter's hit test receives, which is in its superview's space.
-    func pointForHitTest(_ localPoint: NSPoint) -> NSPoint? {
-        gutter.superview.map { gutter.convert(localPoint, to: $0) }
-    }
-}
-
-@MainActor
-struct DataGridRowGutterTests {
-    @Test("the gutter holds the leading edge at every horizontal scroll offset")
-    func gutterHoldsLeadingEdge() {
-        let grid = GutterGrid()
-        let atOrigin = grid.gutterWindowMinX
-
-        grid.scrollHorizontally(to: 900)
-        #expect(grid.gutterWindowMinX == atOrigin)
-
-        grid.scrollHorizontally(to: 2_400)
-        #expect(grid.gutterWindowMinX == atOrigin)
-    }
-
-    /// `column.width` is a point short of the span, and a gutter that wide drew its edge beside the
-    /// grid's own line instead of on it.
-    @Test("the gutter spans the row-number column's rect, so its edge is the first data column's")
-    func gutterSpansTheColumnRect() {
-        let grid = GutterGrid()
-        let rowNumber = grid.tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        #expect(rowNumber == 0)
-        let span = grid.tableView.rect(ofColumn: rowNumber)
-
-        #expect(grid.gutter.frame.width == span.width)
-        #expect(span.maxX == grid.tableView.rect(ofColumn: rowNumber + 1).minX)
-        #expect(grid.gutter.frame.width > grid.tableView.tableColumns[rowNumber].width)
-    }
-
-    @Test("a press below the last row passes through the gutter to the grid")
-    func belowTheLastRowPassesThrough() throws {
-        let grid = GutterGrid(rowCount: 3)
-        let lastRow = grid.gutter.convert(grid.tableView.rect(ofRow: 2), from: grid.tableView)
-        #expect(grid.gutter.bounds.maxY > lastRow.maxY + 30, "the gutter still reaches below the rows")
-
-        let onRow = try #require(grid.pointForHitTest(NSPoint(x: 4, y: lastRow.midY)))
-        let belowRows = try #require(grid.pointForHitTest(NSPoint(x: 4, y: lastRow.maxY + 30)))
-
-        #expect(grid.gutter.hitTest(onRow) === grid.gutter)
-        #expect(grid.gutter.hitTest(belowRows) == nil)
-    }
-
-    /// The strip is drawn chrome with no place in the accessibility tree, so AppKit's own hit test
-    /// stopped at the scroll area and a pointer over a row's number found no row at all.
-    @Test("an accessibility hit test over a pinned number finds that row's number cell, not the scroll area")
-    func accessibilityHitTestFindsTheRowNumberCell() throws {
-        let wasActive = DataGridAccessibility.isActive
-        defer { DataGridAccessibility.isActive = wasActive }
-        let grid = GutterGrid(rowCount: 3)
-        let row = try #require(firstRowUnderTheStrip(in: grid))
-        let band = grid.gutter.convert(grid.tableView.rect(ofRow: row), from: grid.tableView)
-
-        let hit = grid.gutter.accessibilityHitTest(screenPoint(x: 4, y: band.midY, in: grid)) as AnyObject?
-        let cell = grid.tableView.view(atColumn: 0, row: row, makeIfNecessary: false)
-        #expect(cell != nil)
-        #expect(hit === cell, "hit \(String(describing: hit))")
-
-        let below = grid.gutter.accessibilityHitTest(screenPoint(x: 4, y: band.maxY + 60, in: grid)) as AnyObject?
-        #expect(!(below is NSScrollView), "below the rows the hit belongs to the grid")
-    }
-
-    /// `NSTableView` keeps the row-number cell mounted at its own position however far the grid
-    /// scrolls, so past the viewport its frame is far off screen and the row is the better answer.
-    @Test("scrolled sideways, an accessibility hit test over a pinned number finds the row")
-    func accessibilityHitTestFindsTheRowWhenScrolled() throws {
-        let wasActive = DataGridAccessibility.isActive
-        defer { DataGridAccessibility.isActive = wasActive }
-        let grid = GutterGrid(rowCount: 3)
-        grid.scrollHorizontally(to: 2_400)
-        let row = try #require(firstRowUnderTheStrip(in: grid))
-        let band = grid.gutter.convert(grid.tableView.rect(ofRow: row), from: grid.tableView)
-
-        let hit = grid.gutter.accessibilityHitTest(screenPoint(x: 4, y: band.midY, in: grid)) as AnyObject?
-        let rowView = grid.tableView.rowView(atRow: row, makeIfNecessary: false)
-        #expect(rowView != nil)
-        #expect(hit === rowView, "hit \(String(describing: hit))")
-    }
-
-    /// Offscreen, the floating container sits a header's height below the table, so the strip
-    /// misses the first rows there; asking the geometry keeps the check on a row it covers.
-    private func firstRowUnderTheStrip(in grid: GutterGrid) -> Int? {
-        (0..<grid.tableView.numberOfRows).first { row in
-            let band = grid.gutter.convert(grid.tableView.rect(ofRow: row), from: grid.tableView)
-            return grid.gutter.bounds.contains(NSPoint(x: 4, y: band.midY))
-        }
-    }
-
-    private func screenPoint(x: CGFloat, y: CGFloat, in grid: GutterGrid) -> NSPoint {
-        grid.window.convertPoint(toScreen: grid.gutter.convert(NSPoint(x: x, y: y), to: nil))
-    }
-
-    /// With the rows inside the viewport the strip's frame does not move on a reload, and a frame
-    /// change is all its own geometry sync repaints for. A result with fewer rows than the one
-    /// before it left the old numbers painted beside rows that were gone.
-    ///
-    /// Counted through the page offset, which only the strip's drawing reads once the rows are laid
-    /// out. `needsDisplay` cannot answer this, it reads false straight after being set, and
-    /// `displayIfNeeded()` does not draw the strip: its layer draws when the run loop commits.
-    @Test("a reload to fewer rows redraws the gutter even though its frame holds")
-    func reloadToFewerRowsRedrawsTheGutter() throws {
-        let grid = GutterGrid(rowCount: 3, dataColumns: 2)
-        let draws = GutterDraws()
-        grid.coordinator.paginationOffsetProvider = {
-            draws.total += 1
-            return 0
-        }
-        grid.scrollView.layoutSubtreeIfNeeded()
-        Self.commit()
-        draws.total = 0
-        Self.commit()
-        try #require(draws.total == 0, "a settled gutter must not draw again, or the count proves nothing")
-        let frameBefore = grid.gutter.frame
-
-        let oneRow = TableRows.from(
-            queryRows: [[.text("a"), .text("b")]],
-            columns: ["col0", "col1"],
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: 2)
-        )
-        grid.coordinator.tableRowsProvider = { oneRow }
-        grid.coordinator.updateCache()
-        grid.tableView.reloadData()
-        grid.scrollView.layoutSubtreeIfNeeded()
-        draws.total = 0
-        Self.commit()
-
-        #expect(grid.tableView.numberOfRows == 1)
-        #expect(grid.gutter.frame == frameBefore)
-        #expect(draws.total > 0, "the strip must redraw, or it keeps numbering rows 2 and 3")
-    }
-
-    private static func commit() {
-        RunLoop.main.run(until: Date(timeIntervalSinceNow: 0.1))
-    }
-
-    @Test("the gutter width follows the column when the row count crosses a digit boundary")
-    func gutterWidthFollowsRowCount() {
-        let narrow = GutterGrid(rowCount: 9)
-        let wide = GutterGrid(rowCount: 100_000)
-
-        #expect(wide.gutter.frame.width > narrow.gutter.frame.width)
-        #expect(wide.gutter.frame.width == DataGridRowGutterView.width(of: wide.tableView))
-    }
-
-    @Test("turning row numbers off hides the gutter and leaves the column attached at the head")
-    func rowNumbersOffHidesGutter() {
-        let grid = GutterGrid(showRowNumbers: false)
-
-        #expect(grid.gutter.isHidden)
-        #expect(DataGridRowGutterView.width(of: grid.tableView) == 0)
-        #expect(grid.tableView.tableColumns.first?.identifier == ColumnIdentitySchema.rowNumberIdentifier)
-    }
-
-    @Test("the gutter is not a subview of the table view, so a wide result pays nothing for it")
-    func gutterIsNotATableSubview() {
-        let grid = GutterGrid(dataColumns: 200)
-
-        #expect(grid.gutter.superview !== grid.tableView)
-        #expect(!grid.tableView.subviews.contains(grid.gutter))
-    }
-}
-
-@MainActor
-struct GutterAwareColumnScrollTests {
-    @Test("a column reached from off screen lands clear of the gutter")
-    func columnLandsClearOfGutter() {
-        let grid = GutterGrid()
-        grid.scrollHorizontally(to: 2_400)
-        let gutterWidth = DataGridRowGutterView.width(of: grid.tableView)
-
-        let target = grid.tableView.tableColumns.count - 20
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: target)
-        grid.scrollView.layoutSubtreeIfNeeded()
-
-        let origin = grid.scrollView.contentView.bounds.origin.x
-        let columnRect = grid.tableView.rect(ofColumn: target)
-        #expect(columnRect.minX >= origin + gutterWidth)
-    }
-
-    /// The correction used to scroll the clip view and reflect it, which moves the rows and leaves
-    /// the header clip behind, so every heading sat as far off its column as the correction moved.
-    @Test("the header moves with the rows when a column is scrolled clear of the gutter")
-    func headerFollowsTheCorrection() {
-        let grid = GutterGrid()
-        grid.scrollHorizontally(to: 2_400)
-
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: grid.tableView.tableColumns.count - 20)
-        grid.scrollView.layoutSubtreeIfNeeded()
-
-        #expect(grid.headerClipOriginX == grid.scrollView.contentView.bounds.origin.x)
-    }
-
-    @Test("a column already clear of the gutter is not scrolled at all")
-    func clearColumnDoesNotScroll() {
-        let grid = GutterGrid()
-        grid.scrollHorizontally(to: 600)
-        let before = grid.scrollView.contentView.bounds.origin.x
-        let gutterWidth = DataGridRowGutterView.width(of: grid.tableView)
-
-        /// A column that is wholly inside the viewport and already past the gutter, so AppKit has
-        /// nothing to do and neither does the correction on top of it.
-        let visible = grid.tableView.visibleRect
-        let target = grid.tableView.columnIndexes(in: visible).first {
-            let rect = grid.tableView.rect(ofColumn: $0)
-            return rect.minX >= before + gutterWidth && rect.maxX <= visible.maxX
-        }
-
-        #expect(target != nil)
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: target ?? 0)
-
-        #expect(grid.scrollView.contentView.bounds.origin.x == before)
-    }
-}
-
-@MainActor
-struct SelectIntersectingRowsTests {
-    @Test("a cell rectangle widens to every column of every row it covers")
-    func rectangleWidensToWholeRows() {
-        let controller = GridSelectionController()
-        controller.update(
-            .single(
-                GridRect(rows: 2...4, columns: 1...2),
-                anchor: GridCoord(row: 2, displayColumn: 1),
-                active: GridCoord(row: 4, displayColumn: 2)
-            )
-        )
-
-        controller.selectEntireRows(controller.selection.affectedRows, totalColumns: 6)
-
-        /// One rectangle, because rows 2 to 4 are contiguous.
-        #expect(controller.selection.rectangles.count == 1)
-        #expect(controller.selection.affectedRows == IndexSet([2, 3, 4]))
-        #expect(controller.selection.affectedColumns == IndexSet(integersIn: 0..<6))
-    }
-
-    @Test("a discontiguous selection stays discontiguous instead of filling the gap")
-    func discontiguousStaysDiscontiguous() {
-        let controller = GridSelectionController()
-
-        controller.selectEntireRows([3, 17], totalColumns: 4)
-
-        #expect(controller.selection.rectangles.count == 2)
-        #expect(controller.selection.affectedRows == IndexSet([3, 17]))
-        #expect(!controller.selection.contains(row: 10, displayColumn: 0))
-        #expect(controller.selection.contains(row: 17, displayColumn: 3))
-    }
-
-    /// A contiguous run must not cost one rectangle per row: the overlay, the row fill and
-    /// `columns(in:)` all walk every rectangle for every visible row, so Select All then Shift+Space
-    /// over a large result would stall on its own bookkeeping.
-    @Test("contiguous runs coalesce, and gaps still split them")
-    func contiguousRunsCoalesce() {
-        let controller = GridSelectionController()
-
-        controller.selectEntireRows(Array(0..<10_000) + [20_000], totalColumns: 3)
-
-        #expect(controller.selection.rectangles.count == 2)
-        #expect(controller.selection.rectangles.first?.rows == 0...9_999)
-        #expect(controller.selection.rectangles.last?.rows == 20_000...20_000)
-        #expect(!controller.selection.contains(row: 15_000, displayColumn: 0))
-    }
-
-    @Test("selectEntireRow is the single-row case of the same widening")
-    func singleRowMatchesPlural() {
-        let single = GridSelectionController()
-        let plural = GridSelectionController()
-
-        single.selectEntireRow(5, totalColumns: 7)
-        plural.selectEntireRows([5], totalColumns: 7)
-
-        #expect(single.selection == plural.selection)
-    }
-
-    @Test("widening with no columns leaves the selection alone")
-    func noColumnsLeavesSelectionAlone() {
-        let controller = GridSelectionController()
-
-        controller.selectEntireRows([1, 2], totalColumns: 0)
-
-        #expect(controller.selection.isEmpty)
-    }
-
-    /// Numbers spells this command Option-Command-Return, which is already the shipped default for
-    /// Execute Query Without Limit. That is a menu item, and AppKit resolves a menu key equivalent
-    /// before the event reaches a view, so binding the grid to it would make one of the two dead.
-    @Test("the shortcut does not collide with a shipped key equivalent")
-    func shortcutDoesNotCollideWithAMenuItem() {
-        let claimed = Set(KeyboardSettings.defaultShortcuts.values)
-
-        #expect(claimed.contains(.special(.return, command: true, option: true)))
-        #expect(claimed.contains(.special(.space)))
-        #expect(!claimed.contains(.special(.space, shift: true)))
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridRowIdentityTests.swift b/apple/TableProTests/Views/Results/DataGridRowIdentityTests.swift
deleted file mode 100644
index 1b50aa1926..0000000000
--- a/apple/TableProTests/Views/Results/DataGridRowIdentityTests.swift
+++ /dev/null
@@ -1,173 +0,0 @@
-//
-//  DataGridRowIdentityTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class NoopRowIdentityPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// `insertRows(at:)` and `removeRows(at:)` move an already-built row view to its new slot without
-/// asking the delegate for it again, so an index captured when the view was mounted names a
-/// different row from then on. Measured: after `removeRows(at: [1])` the view at display row 1 still
-/// carried 2 and an insert left two views both claiming 0, which sent a double-click to the wrong
-/// row and had an accessibility cell speak one row's value under another row's number.
-@MainActor
-struct DataGridRowIdentityTests {
-    private struct Grid {
-        let window: NSWindow
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-        let rowCount: Box
-
-        var rowViews: [DataGridRowView] {
-            (0 ..< tableView.numberOfRows).compactMap {
-                tableView.rowView(atRow: $0, makeIfNecessary: false) as? DataGridRowView
-            }
-        }
-    }
-
-    /// The provider is read on every access, so the row count has to live somewhere the test can
-    /// move before it tells the table view about the mutation, exactly as the coordinator does.
-    private final class Box {
-        var value: Int
-        init(_ value: Int) { self.value = value }
-    }
-
-    private static func rows(count: Int) -> TableRows {
-        TableRows.from(
-            queryRows: (0 ..< count).map { [.text("id-\($0)"), .text("name-\($0)")] },
-            columns: ["id", "name"],
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
-        )
-    }
-
-    private func makeGrid(rowCount: Int = 5) -> Grid {
-        let box = Box(rowCount)
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopRowIdentityPersister()
-        )
-        coordinator.tableRowsProvider = { Self.rows(count: box.value) }
-        coordinator.rebuildColumnMetadataCache(from: Self.rows(count: box.value))
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 400))
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 120 }
-        )
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 600, height: 400))
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 400),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.contentView = scrollView
-        tableView.reloadData()
-        window.layoutIfNeeded()
-        for row in 0 ..< tableView.numberOfRows {
-            _ = tableView.rowView(atRow: row, makeIfNecessary: true)
-        }
-        return Grid(window: window, tableView: tableView, coordinator: coordinator, rowCount: box)
-    }
-
-    @Test("Every mounted row reports its own display row before any mutation")
-    func rowsStartCorrect() {
-        let grid = makeGrid()
-        #expect(grid.rowViews.map(\.rowIndex) == Array(0 ..< 5))
-    }
-
-    @Test("Removing a row above a mounted one moves its index down")
-    func removeShiftsTheRowsBelow() throws {
-        let grid = makeGrid()
-        let third = try #require(grid.tableView.rowView(atRow: 2, makeIfNecessary: false) as? DataGridRowView)
-        #expect(third.rowIndex == 2)
-
-        grid.rowCount.value = 4
-        grid.coordinator.updateCache()
-        grid.tableView.removeRows(at: IndexSet(integer: 1), withAnimation: [])
-
-        #expect(third.rowIndex == 1)
-        #expect(grid.rowViews.map(\.rowIndex) == Array(0 ..< 4))
-    }
-
-    @Test("Inserting a row above a mounted one moves its index up")
-    func insertShiftsTheRowsBelow() throws {
-        let grid = makeGrid()
-        let first = try #require(grid.tableView.rowView(atRow: 0, makeIfNecessary: false) as? DataGridRowView)
-        #expect(first.rowIndex == 0)
-
-        grid.rowCount.value = 6
-        grid.coordinator.updateCache()
-        grid.tableView.insertRows(at: IndexSet(integer: 0), withAnimation: [])
-
-        #expect(first.rowIndex == 1)
-        #expect(grid.rowViews.map(\.rowIndex) == Array(0 ..< 6))
-    }
-
-    /// A row view outside any table keeps the index it was handed, which is the shape the copy tests
-    /// build and the only case the stored seed still answers for.
-    @Test("A row view in no table falls back to the index it was given")
-    func detachedRowKeepsItsSeededIndex() {
-        let rowView = DataGridRowView()
-        rowView.rowIndex = 7
-        #expect(rowView.rowIndex == 7)
-    }
-
-    /// The accessibility cell is a real mounted view, so an incremental mutation moves it the same
-    /// way and it used to keep speaking the row it was built for.
-    @Test("An accessibility cell moved by a removal speaks its new row")
-    func accessibilityCellFollowsTheRemoval() throws {
-        DataGridAccessibility.isActive = true
-        defer { DataGridAccessibility.isActive = false }
-        let grid = makeGrid()
-        grid.tableView.reloadData()
-        grid.window.layoutIfNeeded()
-
-        let dataColumn = try #require(grid.coordinator.tableColumnIndex(for: 0))
-        let cell = try #require(
-            grid.tableView.view(atColumn: dataColumn, row: 2, makeIfNecessary: true)
-                as? DataGridCellAccessibilityView
-        )
-        #expect(cell.accessibilityValue() as? String == "id-2")
-        #expect(cell.accessibilityRowIndexRange().location == 2)
-
-        grid.rowCount.value = 4
-        grid.coordinator.updateCache()
-        grid.tableView.removeRows(at: IndexSet(integer: 1), withAnimation: [])
-
-        #expect(cell.accessibilityRowIndexRange().location == 1)
-        #expect(cell.accessibilityValue() as? String == "id-1")
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridRowNumberRenderingTests.swift b/apple/TableProTests/Views/Results/DataGridRowNumberRenderingTests.swift
deleted file mode 100644
index 1523315e4f..0000000000
--- a/apple/TableProTests/Views/Results/DataGridRowNumberRenderingTests.swift
+++ /dev/null
@@ -1,754 +0,0 @@
-//
-//  DataGridRowNumberRenderingTests.swift
-//  TableProTests
-//
-//  The row-number column is pinned by a floating strip over the rows and by a heading the header
-//  view draws itself. These rasterise both and hold them to the columns beside them, never to their
-//  own arithmetic: one line at the edge, the same background, nothing scrolled showing through.
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import TableProTheme
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class RowNumberLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// One view's cached drawing, read back by point.
-@MainActor
-private struct Raster {
-    let rep: NSBitmapImageRep
-    let rect: NSRect
-    let isFlipped: Bool
-
-    init?(of view: NSView, in rect: NSRect) {
-        guard let rep = view.bitmapImageRepForCachingDisplay(in: rect) else { return nil }
-        view.cacheDisplay(in: rect, to: rep)
-        self.rep = rep
-        self.rect = rect
-        isFlipped = view.isFlipped
-    }
-
-    var scale: CGFloat { CGFloat(rep.pixelsWide) / rect.width }
-
-    func color(at point: NSPoint) -> NSColor? {
-        pixel(x: column(for: point.x), y: row(for: point.y))
-    }
-
-    /// Every pixel along one horizontal line, from `minX` up to `maxX`.
-    func colors(fromX minX: CGFloat, toX maxX: CGFloat, atY y: CGFloat) -> [NSColor] {
-        let row = row(for: y)
-        return (column(for: minX)..<column(for: maxX)).compactMap { pixel(x: $0, y: row) }
-    }
-
-    /// How many pixels inside `area` differ from `background`.
-    func inkPixels(in area: NSRect, unlike background: NSColor) -> Int {
-        let rows = row(for: isFlipped ? area.minY : area.maxY)..<row(for: isFlipped ? area.maxY : area.minY)
-        let columns = column(for: area.minX)..<column(for: area.maxX)
-        return rows.reduce(0) { count, row in
-            count + columns.filter { column in
-                pixel(x: column, y: row).map { !matches($0, background) } ?? false
-            }.count
-        }
-    }
-
-    private func column(for x: CGFloat) -> Int {
-        Int(((x - rect.minX) * scale).rounded(.down))
-    }
-
-    private func row(for y: CGFloat) -> Int {
-        let fromTop = isFlipped ? y - rect.minY : rect.maxY - y
-        return Int((fromTop * scale).rounded(.down))
-    }
-
-    private func pixel(x: Int, y: Int) -> NSColor? {
-        guard x >= 0, y >= 0, x < rep.pixelsWide, y < rep.pixelsHigh else { return nil }
-        return rep.colorAt(x: x, y: y)?.usingColorSpace(.sRGB)
-    }
-}
-
-/// A band above the grid, the shape the window itself has: the find bar, the filter panel, the
-/// key-pattern search bar, the result tab bar and the banners are all siblings stacked above the
-/// data grid, and every one of them is an earlier sibling, so anything the grid paints outside
-/// itself lands on top of them.
-@MainActor
-private final class StripHost: NSView {
-    static let color = NSColor(srgbRed: 0.15, green: 0.45, blue: 0.85, alpha: 1)
-
-    override var isFlipped: Bool { true }
-
-    override func draw(_ dirtyRect: NSRect) {
-        Self.color.setFill()
-        dirtyRect.fill()
-    }
-}
-
-private func matches(_ lhs: NSColor, _ rhs: NSColor, tolerance: CGFloat = 0.02) -> Bool {
-    abs(lhs.redComponent - rhs.redComponent) <= tolerance
-        && abs(lhs.greenComponent - rhs.greenComponent) <= tolerance
-        && abs(lhs.blueComponent - rhs.blueComponent) <= tolerance
-        && abs(lhs.alphaComponent - rhs.alphaComponent) <= tolerance
-}
-
-@MainActor
-struct DataGridRowNumberRenderingTests {
-    @MainActor
-    private struct Grid {
-        let window: NSWindow
-        let host: StripHost?
-        let scrollView: NSScrollView
-        let tableView: KeyHandlingTableView
-        let header: SortableHeaderView
-        let gutter: DataGridRowGutterView
-        let coordinator: TableViewCoordinator
-
-        var rowNumberColumn: Int {
-            tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        }
-
-        var rowNumberWidth: CGFloat {
-            tableView.rect(ofColumn: rowNumberColumn).width
-        }
-
-        /// Through `scroll(_:)`, which moves the header with the rows.
-        func scroll(toX x: CGFloat) {
-            tableView.scroll(NSPoint(x: x, y: scrollView.contentView.bounds.origin.y))
-            scrollView.layoutSubtreeIfNeeded()
-        }
-
-        /// A sideways bounce past the leading edge. `scroll(_:)` clamps to the document, and moving
-        /// the rows' clip view leaves the header's where it was, so both are put at the negative
-        /// origin directly, the way the bounce leaves them.
-        @discardableResult
-        func bounce(toX x: CGFloat) throws -> NSClipView {
-            let clip = scrollView.contentView
-            clip.scroll(to: NSPoint(x: x, y: clip.bounds.origin.y))
-            scrollView.reflectScrolledClipView(clip)
-            let headerClip = try #require(header.superview as? NSClipView)
-            headerClip.scroll(to: NSPoint(x: x, y: headerClip.bounds.origin.y))
-            try #require(clip.bounds.minX == x, "the rows' clip view was clamped back")
-            try #require(headerClip.bounds.minX == x, "the header's clip view was clamped back")
-            return headerClip
-        }
-
-        /// Far enough down that the strip's own drawing reaches past the top of the viewport, which
-        /// is the offset the escape shows at.
-        func scrollVertically(toRow row: Int) {
-            tableView.scroll(NSPoint(x: scrollView.contentView.bounds.origin.x, y: tableView.rect(ofRow: row).minY))
-            scrollView.layoutSubtreeIfNeeded()
-            gutter.synchronizeGeometry()
-            gutter.displayIfNeeded()
-        }
-
-        func pointInScrollView(_ point: NSPoint) -> NSPoint {
-            scrollView.convert(point, from: tableView)
-        }
-
-        /// The rows whose middle the strip covers.
-        ///
-        /// Offscreen, the floating container sits a header's height lower than the table (its
-        /// bounds follow the clip view while its frame starts below the header), so the strip
-        /// misses the first row or two here where on screen it covers them. Asking the geometry
-        /// keeps every check on a row the strip actually paints, instead of passing by comparing a
-        /// row with itself.
-        var rowsUnderTheStrip: [Int] {
-            (0..<tableView.numberOfRows).filter { row in
-                let band = gutter.convert(tableView.rect(ofRow: row), from: tableView)
-                return gutter.bounds.contains(NSPoint(x: 1, y: band.midY))
-            }
-        }
-    }
-
-    private static let columnWidth: CGFloat = 160
-    private static let rowCount = 12
-
-    private func makeGrid(
-        titles: [String] = (0..<8).map { "column\($0)" },
-        rows: Int = DataGridRowNumberRenderingTests.rowCount,
-        appearance: NSAppearance.Name = .darkAqua,
-        stripAbove: CGFloat = 0
-    ) -> Grid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: RowNumberLayoutPersister()
-        )
-        let columnTypes = Array(repeating: ColumnType.text(rawType: "TEXT"), count: titles.count)
-        let tableRows = TableRows.from(
-            queryRows: (0..<rows).map { _ in titles.map { _ in PluginCellValue.text("x") } },
-            columns: titles,
-            columnTypes: columnTypes
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 300))
-        tableView.style = .plain
-        tableView.usesAlternatingRowBackgroundColors = true
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = 22
-        tableView.allowsMultipleSelection = true
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.updateCache()
-
-        let header = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: 600, height: 28))
-        header.coordinator = coordinator
-        tableView.headerView = header
-
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in Self.columnWidth }
-        )
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: stripAbove, width: 600, height: 300 - stripAbove))
-        scrollView.hasHorizontalScroller = true
-        scrollView.hasVerticalScroller = true
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.appearance = NSAppearance(named: appearance)
-
-        var host: StripHost?
-        if stripAbove > 0 {
-            let stripHost = StripHost(frame: NSRect(x: 0, y: 0, width: 600, height: 300))
-            stripHost.addSubview(scrollView)
-            window.contentView = stripHost
-            host = stripHost
-        } else {
-            window.contentView = scrollView
-        }
-
-        let gutter: DataGridRowGutterView
-        if stripAbove > 0 {
-            DataGridView.installRowGutter(scrollView: scrollView, tableView: tableView, coordinator: coordinator)
-            gutter = coordinator.rowGutter ?? DataGridRowGutterView(frame: .zero)
-        } else {
-            gutter = DataGridRowGutterView(frame: .zero)
-            gutter.coordinator = coordinator
-            tableView.addSubview(gutter)
-            scrollView.addFloatingSubview(gutter, for: .horizontal)
-            coordinator.rowGutter = gutter
-        }
-
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        window.layoutIfNeeded()
-        scrollView.layoutSubtreeIfNeeded()
-        gutter.synchronizeGeometry()
-        for row in 0..<rows {
-            _ = tableView.rowView(atRow: row, makeIfNecessary: true)
-        }
-        return Grid(
-            window: window,
-            host: host,
-            scrollView: scrollView,
-            tableView: tableView,
-            header: header,
-            gutter: gutter,
-            coordinator: coordinator
-        )
-    }
-
-    // MARK: - The pinned rows
-
-    /// In dark mode the alternate stripe is white at under 5% alpha, so a strip filled with it alone
-    /// let the columns scrolled under it show through every other row.
-    @Test("The strip is opaque on every row it pins")
-    func stripIsOpaqueOnEveryRow() throws {
-        let grid = makeGrid(appearance: .darkAqua)
-        let rows = grid.rowsUnderTheStrip
-        #expect(rows.count >= 6, "too few rows under the strip to cover both stripes")
-        let raster = try #require(Raster(of: grid.gutter, in: grid.gutter.bounds))
-
-        for row in rows {
-            let rowRect = grid.gutter.convert(grid.tableView.rect(ofRow: row), from: grid.tableView)
-            let color = try #require(raster.color(at: NSPoint(x: 2, y: rowRect.midY)))
-            #expect(color.alphaComponent > 0.99, "row \(row) is see-through")
-        }
-    }
-
-    /// Light mode, where every colour a row paints is opaque, so the cached drawing composites as the
-    /// screen does and the strip can be held pixel for pixel to the row beside it.
-    @Test("At scroll offset zero the strip shows the row it covers, stripe and selection alike")
-    func stripMatchesTheRowsItCovers() throws {
-        let grid = makeGrid(appearance: .aqua)
-        let rows = grid.rowsUnderTheStrip
-        #expect(rows.count >= 6, "too few rows under the strip to cover both stripes and a selection")
-        let selected = try #require(rows.dropFirst(2).first)
-        grid.tableView.selectRowIndexes(IndexSet(integer: selected), byExtendingSelection: false)
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let dataRect = grid.tableView.rect(ofColumn: firstData)
-        let raster = try #require(Raster(of: grid.scrollView, in: grid.scrollView.bounds))
-
-        for row in rows {
-            let midY = grid.tableView.rect(ofRow: row).midY
-            let strip = try #require(raster.color(at: grid.pointInScrollView(NSPoint(x: 2, y: midY))))
-            let body = try #require(
-                raster.color(at: grid.pointInScrollView(NSPoint(x: dataRect.maxX - 12, y: midY)))
-            )
-            #expect(matches(strip, body), "row \(row): strip \(strip), row \(body)")
-        }
-    }
-
-    /// The strip used to be the column's width and draw its own line a point short of the grid's, so
-    /// two translucent lines stood side by side.
-    @Test("Exactly one line stands between the row numbers and the first data column")
-    func oneLineAtTheStripEdge() throws {
-        let grid = makeGrid(appearance: .darkAqua)
-        let edge = grid.tableView.rect(ofColumn: grid.rowNumberColumn).maxX
-        let row = try #require(grid.rowsUnderTheStrip.first { $0.isMultiple(of: 2) })
-        let midY = grid.tableView.rect(ofRow: row).midY
-        let raster = try #require(Raster(of: grid.scrollView, in: grid.scrollView.bounds))
-        let background = try #require(raster.color(at: grid.pointInScrollView(NSPoint(x: 2, y: midY))))
-
-        let from = grid.pointInScrollView(NSPoint(x: edge - 3, y: midY))
-        let to = grid.pointInScrollView(NSPoint(x: edge + 2, y: midY))
-        let linePixels = raster.colors(fromX: from.x, toX: to.x, atY: from.y).filter { !matches($0, background) }
-
-        #expect(!linePixels.isEmpty, "the edge has no line at all")
-        #expect(
-            CGFloat(linePixels.count) <= raster.scale * DataGridBodyChrome.separatorThickness,
-            "\(linePixels.count) pixels of line at \(raster.scale)x"
-        )
-    }
-
-    /// Scrolled sideways, the grid's own separator has gone under the strip, so the strip's edge is the
-    /// only line left there. A strip one point short draws none, and the numbers lose their edge.
-    @Test("Scrolled sideways, exactly one line stands at the pinned strip's edge")
-    func oneLineAtThePinnedEdgeWhenScrolled() throws {
-        let grid = makeGrid(appearance: .darkAqua)
-        let row = try #require(grid.rowsUnderTheStrip.first { $0.isMultiple(of: 2) })
-        grid.scroll(toX: 70)
-        let raster = try #require(Raster(of: grid.scrollView, in: grid.scrollView.bounds))
-
-        let stripMinX = grid.scrollView.convert(NSPoint.zero, from: grid.gutter).x
-        let edge = stripMinX + grid.tableView.rect(ofColumn: grid.rowNumberColumn).width
-        let y = grid.pointInScrollView(NSPoint(x: 0, y: grid.tableView.rect(ofRow: row).midY)).y
-        let background = try #require(raster.color(at: NSPoint(x: stripMinX + 2, y: y)))
-        let linePixels = raster.colors(fromX: edge - 3, toX: edge + 2, atY: y).filter { !matches($0, background) }
-
-        #expect(!linePixels.isEmpty, "the pinned strip has no edge")
-        #expect(
-            CGFloat(linePixels.count) <= raster.scale * DataGridBodyChrome.separatorThickness,
-            "\(linePixels.count) pixels of line at \(raster.scale)x"
-        )
-    }
-
-    // MARK: - Past the last row
-
-    /// The columns scroll under the strip past the last row too, where it used to paint nothing and
-    /// let every column line crossing that area show through the numbers' column.
-    @Test("Past the last row the strip is opaque")
-    func stripIsOpaquePastTheLastRow() throws {
-        let grid = makeGrid(rows: 3)
-        let lastRow = grid.gutter.convert(grid.tableView.rect(ofRow: 2), from: grid.tableView)
-        let below = NSPoint(x: 2, y: lastRow.maxY + grid.tableView.rowHeight * 1.5)
-        #expect(grid.gutter.bounds.contains(below))
-        let raster = try #require(Raster(of: grid.gutter, in: grid.gutter.bounds))
-
-        let color = try #require(raster.color(at: below))
-        #expect(color.alphaComponent > 0.99, "past the last row the strip is see-through")
-    }
-
-    @Test("Scrolled sideways, no column line shows through the strip past the last row")
-    func noColumnLineShowsThroughPastTheLastRow() throws {
-        let grid = makeGrid(rows: 3)
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let secondData = try #require(grid.coordinator.nextPresentedColumnIndex(after: firstData))
-        grid.scroll(toX: grid.tableView.rect(ofColumn: secondData).minX - 20)
-        let raster = try #require(Raster(of: grid.scrollView, in: grid.scrollView.bounds))
-
-        let pastLastRow = grid.tableView.rect(ofRow: 2).maxY + grid.tableView.rowHeight * 1.5
-        let stripMinX = grid.scrollView.convert(NSPoint.zero, from: grid.gutter).x
-        let stripWidth = grid.tableView.rect(ofColumn: grid.rowNumberColumn).width
-        let y = grid.pointInScrollView(NSPoint(x: 0, y: pastLastRow)).y
-        let background = try #require(raster.color(at: NSPoint(x: stripMinX + 2, y: y)))
-        let strayPixels = raster.colors(fromX: stripMinX + 1, toX: stripMinX + stripWidth - 3, atY: y)
-            .filter { !matches($0, background) }
-
-        #expect(strayPixels.isEmpty, "\(strayPixels.count) pixels of a scrolled column line inside the strip")
-    }
-
-    // MARK: - The pinned heading
-
-    @Test("Scrolled sideways, the pinned heading holds the visible leading edge at its column's width")
-    func pinnedHeadingHoldsTheLeadingEdge() throws {
-        let grid = makeGrid()
-        grid.scroll(toX: 300)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-
-        #expect(pinned.minX == grid.scrollView.contentView.bounds.minX)
-        #expect(pinned.width == grid.header.headerRect(ofColumn: grid.rowNumberColumn).width)
-    }
-
-    @Test("The pinned heading draws its title where the column scrolled under it would show")
-    func pinnedHeadingDrawsItsTitle() throws {
-        let grid = makeGrid()
-        grid.scroll(toX: 300)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-        let raster = try #require(Raster(of: grid.header, in: grid.header.visibleRect))
-        let background = try #require(raster.color(at: NSPoint(x: pinned.minX + 2, y: pinned.minY + 3)))
-
-        let titleArea = NSRect(x: pinned.maxX - 16, y: pinned.midY - 5, width: 13, height: 10)
-        #expect(raster.inkPixels(in: titleArea, unlike: background) > 0)
-    }
-
-    @Test("The pinned heading paints the same background as the headings beside it")
-    func pinnedHeadingMatchesItsNeighbours() throws {
-        let grid = makeGrid()
-        grid.scroll(toX: 300)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-        let neighbour = grid.header.headerRect(
-            ofColumn: grid.header.column(at: NSPoint(x: pinned.maxX + 60, y: pinned.midY))
-        )
-        let raster = try #require(Raster(of: grid.header, in: grid.header.visibleRect))
-
-        let strip = try #require(raster.color(at: NSPoint(x: pinned.minX + 2, y: pinned.midY)))
-        let beside = try #require(raster.color(at: NSPoint(x: neighbour.maxX - 8, y: pinned.midY)))
-        #expect(matches(strip, beside), "pinned \(strip), beside \(beside)")
-    }
-
-    @Test("No heading scrolled under the pinned heading shows through it")
-    func scrolledHeadingsDoNotShowThrough() throws {
-        let grid = makeGrid(titles: (0..<8).map { "WWWWWWWWWWWWWWWWWWWW\($0)" })
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let secondData = try #require(grid.coordinator.nextPresentedColumnIndex(after: firstData))
-        grid.scroll(toX: grid.header.headerRect(ofColumn: secondData).minX)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-        let raster = try #require(Raster(of: grid.header, in: grid.header.visibleRect))
-        let background = try #require(raster.color(at: NSPoint(x: pinned.minX + 2, y: pinned.minY + 3)))
-
-        let underTheTitle = NSRect(x: pinned.minX + 1, y: pinned.minY + 4, width: pinned.width - 18, height: pinned.height - 8)
-        #expect(raster.inkPixels(in: underTheTitle, unlike: background) == 0)
-    }
-
-    @Test("Exactly one divider stands at the pinned heading's trailing edge")
-    func oneDividerAtThePinnedHeadingEdge() throws {
-        let grid = makeGrid()
-        grid.scroll(toX: 300)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-        let raster = try #require(Raster(of: grid.header, in: grid.header.visibleRect))
-        let background = try #require(raster.color(at: NSPoint(x: pinned.minX + 2, y: pinned.midY)))
-
-        let dividerPixels = raster.colors(fromX: pinned.maxX - 3, toX: pinned.maxX + 3, atY: pinned.midY)
-            .filter { !matches($0, background) }
-        #expect(!dividerPixels.isEmpty, "the pinned heading has no divider")
-        #expect(
-            CGFloat(dividerPixels.count) <= raster.scale * SortableHeaderChrome.separatorThickness,
-            "\(dividerPixels.count) pixels of divider at \(raster.scale)x"
-        )
-    }
-
-    @Test("A column edge scrolled under the pinned heading is not a resize zone")
-    func edgesUnderThePinnedHeadingAreNotResizeZones() throws {
-        let grid = makeGrid()
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let edge = grid.header.headerRect(ofColumn: firstData).maxX
-        let point = NSPoint(x: edge, y: grid.header.bounds.midY)
-        #expect(grid.header.isInResizeZone(point: point))
-
-        grid.scroll(toX: edge - 20)
-
-        #expect(grid.header.isInPinnedRowNumberHeading(point))
-        #expect(!grid.header.isInResizeZone(point: point))
-    }
-
-    @Test("Right-clicking the pinned heading offers no menu for the column scrolled under it")
-    func pinnedHeadingOffersNoColumnMenu() throws {
-        let grid = makeGrid()
-        grid.header.menu = NSMenu()
-        grid.scroll(toX: 300)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-
-        let inside = try #require(rightClick(at: NSPoint(x: pinned.midX, y: pinned.midY), in: grid))
-        let beside = try #require(rightClick(at: NSPoint(x: pinned.maxX + 60, y: pinned.midY), in: grid))
-
-        #expect(grid.header.menu(for: inside) == nil)
-        #expect(grid.header.menu(for: beside) != nil)
-    }
-
-    /// The heading is painted without a scroll too, when the row-number column widens for a longer
-    /// number. A scroll then has to clear it from where it was painted, not from where a previous
-    /// scroll left it, or a stale copy stays behind over the heading underneath.
-    @Test("The pinned heading records where it was painted, including after the column widens")
-    func pinnedHeadingRecordsWhereItWasPainted() throws {
-        let grid = makeGrid()
-        grid.scroll(toX: 300)
-        _ = Raster(of: grid.header, in: grid.header.visibleRect)
-        #expect(grid.header.drawnPinnedHeadingRect == grid.header.pinnedRowNumberHeadingRect)
-
-        let column = grid.tableView.tableColumns[grid.rowNumberColumn]
-        DataGridView.sizeRowNumberColumn(column, forMaxRowNumber: 10_000_000)
-        let widened = try #require(grid.header.pinnedRowNumberHeadingRect)
-        _ = Raster(of: grid.header, in: grid.header.visibleRect)
-
-        #expect(grid.header.drawnPinnedHeadingRect == widened)
-    }
-
-    /// `NSTableRowView` paints the system stripes whatever the table is told, so a theme's own pair
-    /// only shows because the row paints the stripe `DataGridBodyChrome` gives it. The strip reads the
-    /// same owner, so it has to keep matching the row under a theme too. Light mode, where the
-    /// system stripes are white and light grey, so a dark themed row cannot pass for one.
-    @Test("Rows paint the theme's stripes, and the strip still matches them")
-    func rowsPaintTheThemesStripes() throws {
-        let engine = ThemeEngine.shared
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-        var theme = BuiltInThemes.light
-        theme.id = "test.grid-stripes"
-        theme.overrides[.gridBackground] = try ThemeColor(validating: "#282A36")
-        theme.overrides[.gridAlternateRow] = try ThemeColor(validating: "#44475A")
-        engine.adopt(ThemeSelection(
-            pair: ThemePair(light: theme, dark: BuiltInThemes.dark),
-            effectiveAppearance: .light
-        ))
-
-        let grid = makeGrid(appearance: .aqua)
-        let rows = grid.rowsUnderTheStrip
-        #expect(rows.count >= 4, "too few rows under the strip to cover both stripes")
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let dataRect = grid.tableView.rect(ofColumn: firstData)
-        let raster = try #require(Raster(of: grid.scrollView, in: grid.scrollView.bounds))
-
-        var bodies: [Int: NSColor] = [:]
-        for row in rows {
-            let midY = grid.tableView.rect(ofRow: row).midY
-            let strip = try #require(raster.color(at: grid.pointInScrollView(NSPoint(x: 2, y: midY))))
-            let body = try #require(
-                raster.color(at: grid.pointInScrollView(NSPoint(x: dataRect.maxX - 12, y: midY)))
-            )
-            #expect(matches(strip, body), "row \(row): strip \(strip), row \(body)")
-            #expect(body.redComponent < 0.35, "row \(row) drew \(body), not the theme's dark stripe")
-            bodies[row] = body
-        }
-        let even = try #require(rows.first(where: { $0.isMultiple(of: 2) }).flatMap { bodies[$0] })
-        let odd = try #require(rows.first(where: { !$0.isMultiple(of: 2) }).flatMap { bodies[$0] })
-        #expect(!matches(even, odd), "both stripes drew \(even)")
-    }
-
-    // MARK: - Bounced past the leading edge
-
-    /// A bounce slides the real row-number column out from under the pinned strip and heading, so
-    /// any "#" or number the column still paints shows as a second row-number column beside them.
-    @Test("Bounced past the leading edge, the header shows the '#' only at the pinned heading")
-    func bouncedHeaderShowsTheTitleOnce() throws {
-        let grid = makeGrid()
-        let headerClip = try grid.bounce(toX: -2 * grid.rowNumberWidth)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-        let heading = grid.header.headerRect(ofColumn: grid.rowNumberColumn)
-        #expect(pinned.minX == headerClip.bounds.minX)
-        try #require(pinned.maxX <= heading.minX, "the pinned heading still covers the heading it pins")
-
-        let raster = try #require(Raster(of: grid.header, in: grid.header.visibleRect))
-        let pinnedBackground = try #require(raster.color(at: NSPoint(x: pinned.minX + 2, y: pinned.minY + 3)))
-        let background = try #require(raster.color(at: NSPoint(x: heading.minX + 2, y: heading.minY + 3)))
-
-        #expect(
-            raster.inkPixels(in: Self.titleArea(of: pinned), unlike: pinnedBackground) > 0,
-            "the pinned heading lost its title"
-        )
-        #expect(
-            raster.inkPixels(in: Self.interior(of: heading), unlike: background) == 0,
-            "the heading the bounce uncovered shows a second '#'"
-        )
-    }
-
-    @Test("Bounced past the leading edge, the uncovered row-number column shows no number")
-    func bouncedRowNumberColumnShowsNoNumber() throws {
-        let grid = makeGrid()
-        try grid.bounce(toX: -2 * grid.rowNumberWidth)
-        let row = 2
-        let rowView = try #require(grid.tableView.rowView(atRow: row, makeIfNecessary: false))
-        let cell = try #require(
-            grid.tableView.view(atColumn: grid.rowNumberColumn, row: row, makeIfNecessary: false) as? NSTableCellView
-        )
-        try #require(cell.isDescendant(of: rowView), "the row-number cell is not mounted in its row")
-        try #require(cell.textField?.stringValue == "\(row + 1)")
-
-        let column = rowView.convert(
-            grid.tableView.rect(ofColumn: grid.rowNumberColumn).intersection(grid.tableView.rect(ofRow: row)),
-            from: grid.tableView
-        )
-        let raster = try #require(Raster(of: rowView, in: rowView.bounds))
-        let stripe = try #require(raster.color(at: NSPoint(x: column.minX + 2, y: column.midY)))
-        /// Short of the trailing edge, where the first data column's separator stands.
-        let numberArea = NSRect(x: column.minX + 1, y: column.minY + 2, width: column.width - 4, height: column.height - 4)
-
-        #expect(raster.inkPixels(in: numberArea, unlike: stripe) == 0)
-    }
-
-    /// The number stops painting but stays the row's only accessible number. `isHidden` would have
-    /// taken the static text out of the cell along with the ink.
-    @Test("The row-number cell still exposes its number to accessibility")
-    func rowNumberCellKeepsItsAccessibleNumber() throws {
-        let grid = makeGrid()
-        let row = 2
-        let cell = try #require(
-            grid.tableView.view(atColumn: grid.rowNumberColumn, row: row, makeIfNecessary: false) as? NSTableCellView
-        )
-        let texts = (cell.accessibilityChildren() ?? [])
-            .compactMap { $0 as? NSAccessibilityProtocol }
-            .filter { $0.accessibilityRole() == .staticText }
-
-        #expect(texts.map { $0.accessibilityValue() as? String } == ["\(row + 1)"])
-    }
-
-    /// A row dragged from the body builds its image from the views the row mounts, and the row-number
-    /// cell is the only one. Taken at the field's zero alpha, that image was empty.
-    @Test("A row drag image still shows the row number")
-    func rowDragImageShowsTheNumber() throws {
-        let grid = makeGrid()
-        let cell = try #require(
-            grid.tableView.view(atColumn: grid.rowNumberColumn, row: 2, makeIfNecessary: false) as? NSTableCellView
-        )
-        let field = try #require(cell.textField)
-        let ink = cell.draggingImageComponents
-            .compactMap { ($0.contents as? NSImage)?.cgImage(forProposedRect: nil, context: nil, hints: nil) }
-            .map(Self.opaquePixelCount(in:))
-            .reduce(0, +)
-
-        #expect(ink > 0)
-        #expect(field.alphaValue == 0)
-    }
-
-    private static func opaquePixelCount(in image: CGImage) -> Int {
-        let width = image.width
-        let height = image.height
-        var pixels = [UInt8](repeating: 0, count: width * height * 4)
-        let drawn: Bool = pixels.withUnsafeMutableBytes { buffer in
-            guard let context = CGContext(
-                data: buffer.baseAddress,
-                width: width,
-                height: height,
-                bitsPerComponent: 8,
-                bytesPerRow: width * 4,
-                space: CGColorSpaceCreateDeviceRGB(),
-                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
-            ) else { return false }
-            context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
-            return true
-        }
-        guard drawn else { return 0 }
-        return stride(from: 3, to: pixels.count, by: 4).filter { pixels[$0] > 0 }.count
-    }
-
-    /// At rest the pinned heading lies over the real one and is still the pass that paints the "#".
-    /// It has to record that it did: a bounce scrolls the header's clip view, which repaints only
-    /// the band it exposes, so the "#" painted at rest is cleared only through the recorded rect.
-    @Test("At rest the header shows the '#', painted by the pinned heading")
-    func headerShowsTheTitleAtRest() throws {
-        let grid = makeGrid()
-        let heading = grid.header.headerRect(ofColumn: grid.rowNumberColumn)
-        #expect(grid.header.pinnedRowNumberHeadingRect == heading)
-
-        let raster = try #require(Raster(of: grid.header, in: grid.header.visibleRect))
-        let background = try #require(raster.color(at: NSPoint(x: heading.minX + 2, y: heading.minY + 3)))
-
-        #expect(raster.inkPixels(in: Self.titleArea(of: heading), unlike: background) > 0, "no '#' at rest")
-        #expect(grid.header.drawnPinnedHeadingRect == heading)
-    }
-
-    /// AppKit lays its translucent grey over the header's bounds only, so the band a bounce exposes
-    /// past them read as the bare fill: a darker strip beside the headings in dark mode.
-    @Test("Bounced past the leading edge, the band past the header's bounds matches a blank heading")
-    func bouncedOverhangMatchesABlankHeading() throws {
-        let grid = makeGrid(appearance: .darkAqua)
-        try grid.bounce(toX: -2 * grid.rowNumberWidth)
-        let pinned = try #require(grid.header.pinnedRowNumberHeadingRect)
-        let heading = grid.header.headerRect(ofColumn: grid.rowNumberColumn)
-        let overhang = NSRect(
-            x: pinned.maxX + 1,
-            y: heading.minY + 4,
-            width: heading.minX - pinned.maxX - 2,
-            height: heading.height - 8
-        )
-        try #require(overhang.width > 0, "the bounce exposed no band past the header's bounds")
-
-        let raster = try #require(Raster(of: grid.header, in: grid.header.visibleRect))
-        let blank = try #require(raster.color(at: NSPoint(x: heading.minX + 2, y: heading.minY + 3)))
-
-        #expect(raster.inkPixels(in: overhang, unlike: blank) == 0)
-    }
-
-    private static func titleArea(of heading: NSRect) -> NSRect {
-        NSRect(x: heading.maxX - 16, y: heading.midY - 5, width: 13, height: 10)
-    }
-
-    /// Clear of the trailing divider and the bottom separator, which a blank heading still draws.
-    private static func interior(of heading: NSRect) -> NSRect {
-        NSRect(x: heading.minX + 1, y: heading.minY + 4, width: heading.width - 4, height: heading.height - 8)
-    }
-
-    // MARK: - Staying inside the grid
-
-    private static let stripHeight: CGFloat = 40
-
-    /// The strip is document-tall, so without a clip it paints far past the viewport it pins. On
-    /// screen that put row numbers and the strip's column separator over the find bar, and over
-    /// every other sibling the window stacks above the grid.
-    @Test("The pinned strip paints nothing above the grid")
-    func stripPaintsNothingAboveTheGrid() throws {
-        let grid = makeGrid(appearance: .aqua, stripAbove: Self.stripHeight)
-        let host = try #require(grid.host)
-        grid.scrollVertically(toRow: 6)
-
-        let raster = try #require(Raster(of: host, in: host.bounds))
-        /// The band's own colour where the strip cannot reach, rather than `StripHost.color`: the
-        /// cached drawing lands in an HDR colour space that shifts the fill, so the only reliable
-        /// reference is the same band measured beside the part under test.
-        let untouched = try #require(raster.color(at: NSPoint(x: host.bounds.maxX - 40, y: 4)))
-        let leadingEdge = NSRect(x: 0, y: 0, width: 120, height: Self.stripHeight)
-        #expect(
-            raster.inkPixels(in: leadingEdge, unlike: untouched) == 0,
-            "the grid painted above itself"
-        )
-    }
-
-    /// What holds the strip in: nothing between a floating subview and the window frame clips on its
-    /// own, and the scroll view is the view the grid owns.
-    @Test("The grid's scroll view clips to its bounds")
-    func scrollViewClipsToBounds() {
-        let grid = makeGrid(appearance: .aqua, stripAbove: Self.stripHeight)
-        #expect(grid.scrollView.clipsToBounds)
-    }
-
-    private func rightClick(at point: NSPoint, in grid: Grid) -> NSEvent? {
-        NSEvent.mouseEvent(
-            with: .rightMouseDown,
-            location: grid.header.convert(point, to: nil),
-            modifierFlags: [],
-            timestamp: 0,
-            windowNumber: grid.window.windowNumber,
-            context: nil,
-            eventNumber: 0,
-            clickCount: 1,
-            pressure: 1
-        )
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridRowTintThemeTests.swift b/apple/TableProTests/Views/Results/DataGridRowTintThemeTests.swift
deleted file mode 100644
index c90f6ae61f..0000000000
--- a/apple/TableProTests/Views/Results/DataGridRowTintThemeTests.swift
+++ /dev/null
@@ -1,160 +0,0 @@
-//
-//  DataGridRowTintThemeTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-@testable import TablePro
-import TableProTheme
-import Testing
-
-@MainActor
-private final class FixedVisualStateDelegate: DataGridViewDelegate {
-    var state: RowVisualState
-
-    init(state: RowVisualState) {
-        self.state = state
-    }
-
-    func dataGridVisualState(forRow row: Int) -> RowVisualState? { state }
-}
-
-@MainActor
-private final class NoopColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// These tests activate a theme on the shared `ThemeEngine`. What keeps that from reaching a suite
-/// running in parallel is that both bodies are synchronous and `@MainActor`, so nothing else on the
-/// main actor can interleave between activating the test theme and restoring the original one.
-/// `.serialized` only orders tests inside this suite and does not provide that. Adding an `await`
-/// anywhere between the two would break it.
-@MainActor
-struct DataGridRowTintThemeTests {
-    private static let deleted = RowVisualState(isDeleted: true, isInserted: false, modifiedColumns: [])
-
-    private final class Harness {
-        let delegate: FixedVisualStateDelegate
-        let coordinator: TableViewCoordinator
-        let rowView: DataGridRowView
-
-        @MainActor
-        init(state: RowVisualState) {
-            delegate = FixedVisualStateDelegate(state: state)
-            coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: false,
-                selectedRowIndices: .constant([]),
-                delegate: delegate,
-                layoutPersister: NoopColumnLayoutPersister()
-            )
-            rowView = DataGridRowView(frame: NSRect(x: 0, y: 0, width: 120, height: 24))
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-        }
-    }
-
-    private func makeRowView(state: RowVisualState) -> Harness {
-        Harness(state: state)
-    }
-
-    private func renderedTint(of rowView: DataGridRowView) throws -> NSColor {
-        let rep = try #require(rowView.bitmapImageRepForCachingDisplay(in: rowView.bounds))
-        rowView.cacheDisplay(in: rowView.bounds, to: rep)
-        let color = try #require(rep.colorAt(x: rep.pixelsWide / 2, y: rep.pixelsHigh / 2))
-        return try #require(color.usingColorSpace(.sRGB))
-    }
-
-    private func selection(_ base: ThemeDefinition, id: String, deletedHex: String) throws -> ThemeSelection {
-        var copy = base
-        copy.id = id
-        copy.overrides[.gridDeleted] = try ThemeColor(validating: deletedHex)
-
-        let pair = copy.appearance == .dark
-            ? ThemePair(light: BuiltInThemes.light, dark: copy)
-            : ThemePair(light: copy, dark: BuiltInThemes.dark)
-
-        return ThemeSelection(pair: pair, effectiveAppearance: copy.appearance)
-    }
-
-    @Test("A deleted row takes the new theme's tint even though its state did not change")
-    func deletedRowTintFollowsThemeChange() throws {
-        let engine = ThemeEngine.shared
-        let original = engine.activeTheme
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-
-        try engine.adopt(selection(original, id: "test.tint.red", deletedHex: "#FF0000"))
-        let harness = makeRowView(state: Self.deleted)
-        let firstTint = try renderedTint(of: harness.rowView)
-
-        try engine.adopt(selection(original, id: "test.tint.blue", deletedHex: "#0000FF"))
-        harness.rowView.invalidateVisualState()
-        let secondTint = try renderedTint(of: harness.rowView)
-
-        #expect(firstTint.redComponent > secondTint.redComponent)
-        #expect(secondTint.blueComponent > firstTint.blueComponent)
-    }
-
-    @Test("A row paints the state its coordinator reports now, not one pushed into it earlier")
-    func rowPaintsTheLiveState() throws {
-        let engine = ThemeEngine.shared
-        let original = engine.activeTheme
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-        try engine.adopt(selection(original, id: "test.tint.red", deletedHex: "#FF0000"))
-
-        let harness = makeRowView(state: .empty)
-        let before = try renderedTint(of: harness.rowView)
-        harness.delegate.state = Self.deleted
-        let after = try renderedTint(of: harness.rowView)
-
-        #expect(before.alphaComponent == 0)
-        #expect(after.redComponent > 0.5)
-        #expect(harness.rowView.visualState == Self.deleted)
-    }
-
-    @Test("A pending delete keeps its wash over a matching highlight rule")
-    func pendingDeleteOutranksHighlightWash() throws {
-        let engine = ThemeEngine.shared
-        let original = engine.activeTheme
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-        try engine.adopt(selection(original, id: "test.tint.red", deletedHex: "#FF0000"))
-
-        let highlight = RowHighlight(
-            rowRule: HighlightRule(columnName: "status", value: "paid", color: .blue),
-            cellRules: [:]
-        )
-        let harness = makeRowView(state: Self.deleted.highlighted(highlight))
-        let tint = try renderedTint(of: harness.rowView)
-
-        #expect(tint.redComponent > tint.blueComponent)
-        #expect(Self.deleted.highlighted(highlight).tint(in: .live) == engine.resolved[.gridDeleted])
-        #expect(RowVisualState.empty.highlighted(highlight).tint(in: .live) == HighlightColor.blue.washColor)
-    }
-
-    @Test("A row with no deleted or inserted state stays untinted across a theme change")
-    func plainRowStaysUntinted() throws {
-        let engine = ThemeEngine.shared
-        let original = engine.activeTheme
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-
-        try engine.adopt(selection(original, id: "test.tint.red", deletedHex: "#FF0000"))
-        let harness = makeRowView(state: .empty)
-        let firstTint = try renderedTint(of: harness.rowView)
-
-        try engine.adopt(selection(original, id: "test.tint.blue", deletedHex: "#0000FF"))
-        harness.rowView.invalidateVisualState()
-        let secondTint = try renderedTint(of: harness.rowView)
-
-        #expect(firstTint.redComponent == secondTint.redComponent)
-        #expect(firstTint.blueComponent == secondTint.blueComponent)
-        #expect(firstTint.alphaComponent == 0)
-        #expect(secondTint.alphaComponent == 0)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridRowViewCopyTests.swift b/apple/TableProTests/Views/Results/DataGridRowViewCopyTests.swift
deleted file mode 100644
index 167f467b19..0000000000
--- a/apple/TableProTests/Views/Results/DataGridRowViewCopyTests.swift
+++ /dev/null
@@ -1,637 +0,0 @@
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class DataGridRowViewCopyLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class DataGridRowViewCopyDelegateSpy: DataGridViewDelegate {
-    var copiedRows: Set<Int>?
-    var deletedRows: Set<Int>?
-
-    func dataGridCopyRows(_ indices: Set<Int>) {
-        copiedRows = indices
-    }
-
-    func dataGridDeleteRows(_ indices: Set<Int>) {
-        deletedRows = indices
-    }
-}
-
-extension GlobalStateSuites {
-    @Suite(.recordingClipboard)
-    @MainActor
-    struct DataGridRowViewCopyTests {
-        private func makeCoordinator(
-            rows: [[PluginCellValue]],
-            columnTypes: [ColumnType],
-            databaseType: DatabaseType? = nil,
-            selectedRows: Set<Int> = [],
-            delegate: (any DataGridViewDelegate)? = nil
-        ) -> TableViewCoordinator {
-            let columns = (0..<columnTypes.count).map { "c\($0)" }
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: true,
-                selectedRowIndices: .constant(selectedRows),
-                delegate: delegate,
-                layoutPersister: DataGridRowViewCopyLayoutPersister()
-            )
-            let tableRows = TableRows.from(queryRows: rows, columns: columns, columnTypes: columnTypes)
-            coordinator.tableRowsProvider = { tableRows }
-            coordinator.databaseType = databaseType
-            coordinator.rebuildColumnMetadataCache(from: tableRows)
-            coordinator.updateCache()
-            return coordinator
-        }
-
-        /// Built through the column pool rather than by attaching columns by hand, so the positions
-        /// these tests focus are the ones the grid really has: the pool also attaches the window's two
-        /// spacers, one of them ahead of the first data column.
-        private func makeTableView(for coordinator: TableViewCoordinator) -> KeyHandlingTableView {
-            let tableView = KeyHandlingTableView()
-            tableView.coordinator = coordinator
-            tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-            coordinator.tableView = tableView
-            coordinator.columnPool.reconcile(
-                tableView: tableView,
-                schema: coordinator.identitySchema,
-                columnTypes: [],
-                savedLayout: nil,
-                isEditable: true,
-                hiddenColumnNames: [],
-                firstClickSortDirection: .ascending,
-                widthCalculator: { _, _ in 100 }
-            )
-            return tableView
-        }
-
-        private func tableColumnIndex(of dataIndex: Int, in tableView: KeyHandlingTableView) -> Int {
-            guard let coordinator = tableView.coordinator,
-                  let identifier = coordinator.identitySchema.identifier(for: dataIndex)
-            else { return -1 }
-            return tableView.column(withIdentifier: identifier)
-        }
-
-        private func invokeCopy(
-            on rowView: DataGridRowView,
-            target: DataGridRowView.CopyContextTarget = .unresolved
-        ) {
-            let item = NSMenuItem(title: "Copy", action: nil, keyEquivalent: "")
-            item.representedObject = target
-            _ = rowView.perform(NSSelectorFromString("copyFromContextMenu:"), with: item)
-        }
-
-        private func invokeCopyRows(on rowView: DataGridRowView) {
-            _ = rowView.perform(NSSelectorFromString("copySelectedOrCurrentRow"))
-        }
-
-        @Test("Copy uses clicked cell value instead of row TSV")
-        func copyUsesClickedCellValue() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .bytes(Data([0xAA, 0xBB]))]],
-                columnTypes: [.integer(rawType: "INT"), .blob(rawType: "BYTEA")]
-            )
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-
-            invokeCopy(on: rowView, target: .cell(1))
-
-            #expect(clipboard.text == "0xAABB")
-            #expect(clipboard.hasGridRows == false)
-        }
-
-        @Test("Copy applies the UUID display format to binary cells")
-        func copyAppliesBinaryUuidDisplayFormat() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let data = Data([
-                0xAF, 0x49, 0x45, 0x3B, 0x7F, 0x2F, 0xFB, 0x58,
-                0xFC, 0xD3, 0x2B, 0xD3, 0x99, 0x59, 0x9F, 0xA5,
-            ])
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .bytes(data)]],
-                columnTypes: [.integer(rawType: "INT"), .blob(rawType: "BYTEA")]
-            )
-            coordinator.updateDisplayFormats([nil, .uuid])
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-
-            invokeCopy(on: rowView, target: .cell(1))
-
-            #expect(clipboard.text == "af49453b-7f2f-fb58-fcd3-2bd399599fa5")
-            #expect(clipboard.hasGridRows == false)
-        }
-
-        @Test("Copy does not guess MongoDB legacy UUID byte order")
-        func copyKeepsUndecodedMongoUuidAsHex() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let javaLegacyBytes = Data([
-                0x24, 0x43, 0x25, 0x4A, 0xEB, 0x03, 0xD0, 0x8C,
-                0x1A, 0x0D, 0xDA, 0xE2, 0xFC, 0x88, 0x32, 0x93,
-            ])
-            let coordinator = makeCoordinator(
-                rows: [[.bytes(javaLegacyBytes)]],
-                columnTypes: [.blob(rawType: "BLOB(3)")],
-                databaseType: .mongodb
-            )
-            coordinator.updateDisplayFormats([.uuid])
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-
-            invokeCopy(on: rowView, target: .cell(0))
-
-            #expect(clipboard.text == "0x2443254AEB03D08C1A0DDAE2FC883293")
-        }
-
-        @Test("Copy applies the UUID display format to a command-clicked binary cell")
-        func copyAppliesBinaryUuidDisplayFormatToGridSelection() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let data = Data([
-                0xAF, 0x49, 0x45, 0x3B, 0x7F, 0x2F, 0xFB, 0x58,
-                0xFC, 0xD3, 0x2B, 0xD3, 0x99, 0x59, 0x9F, 0xA5,
-            ])
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .bytes(data)]],
-                columnTypes: [.integer(rawType: "INT"), .blob(rawType: "BYTEA")]
-            )
-            coordinator.updateDisplayFormats([nil, .uuid])
-            let tableView = makeTableView(for: coordinator)
-            let selectedCell = GridCoord(row: 0, displayColumn: 1)
-            _ = coordinator.selectionController.beginDrag(at: selectedCell, modifiers: .command)
-            coordinator.selectionController.endDrag(dragged: false, originalCoord: selectedCell)
-
-            tableView.copy(nil)
-
-            #expect(clipboard.text == "af49453b-7f2f-fb58-fcd3-2bd399599fa5")
-            #expect(clipboard.hasGridRows == false)
-        }
-
-        @Test("Copy resolves the selection through the displayed row order")
-        func copyUsesDisplayedRowOrder() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let first = Data(repeating: 0xAA, count: 16)
-            let second = Data(repeating: 0xBB, count: 16)
-            let coordinator = makeCoordinator(
-                rows: [[.bytes(first)], [.bytes(second)]],
-                columnTypes: [.blob(rawType: "BYTEA")]
-            )
-            coordinator.updateDisplayFormats([.uuid])
-            coordinator.valueFilteredIDs = [.existing(1), .existing(0)]
-            let tableView = makeTableView(for: coordinator)
-            let selectedCell = GridCoord(row: 0, displayColumn: 0)
-            _ = coordinator.selectionController.beginDrag(at: selectedCell, modifiers: .command)
-            coordinator.selectionController.endDrag(dragged: false, originalCoord: selectedCell)
-
-            tableView.copy(nil)
-
-            #expect(clipboard.text == "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb")
-        }
-
-        @Test("Copy keeps raw bytes for multi-cell grid selections")
-        func copyKeepsRawBytesForMultiCellGridSelection() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let first = Data(repeating: 0xAA, count: 16)
-            let second = Data(repeating: 0xBB, count: 16)
-            let coordinator = makeCoordinator(
-                rows: [[.bytes(first), .bytes(second)]],
-                columnTypes: [.blob(rawType: "BYTEA"), .blob(rawType: "BYTEA")]
-            )
-            coordinator.updateDisplayFormats([.uuid, .uuid])
-            let tableView = makeTableView(for: coordinator)
-            let sweptOrigin = GridCoord(row: 0, displayColumn: 0)
-            coordinator.selectionController.update(
-                .single(GridRect(rows: 0...0, columns: 0...1), anchor: sweptOrigin, active: sweptOrigin)
-            )
-
-            tableView.copy(nil)
-
-            #expect(clipboard.text == "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\t0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB")
-        }
-
-        @Test("Copy falls back to focused cell when no clicked column is attached")
-        func copyFallsBackToFocusedCell() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .null]],
-                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-            )
-            let tableView = makeTableView(for: coordinator)
-            tableView.focusedRow = 0
-            tableView.focusedColumn = tableColumnIndex(of: 1, in: tableView)
-
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-
-            invokeCopy(on: rowView)
-
-            #expect(clipboard.text == "NULL")
-            #expect(clipboard.hasGridRows == false)
-        }
-
-        @Test("Copy from row-number column copies row even when a data cell is focused")
-        func copyFromRowNumberColumnCopiesRow() {
-            let delegate = DataGridRowViewCopyDelegateSpy()
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .text("Alice")]],
-                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")],
-                selectedRows: [0],
-                delegate: delegate
-            )
-            let tableView = makeTableView(for: coordinator)
-            tableView.focusedRow = 0
-            tableView.focusedColumn = tableColumnIndex(of: 1, in: tableView)
-
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-
-            invokeCopy(on: rowView, target: .row)
-
-            #expect(delegate.copiedRows == Set([0]))
-        }
-
-        @Test("Copy rows action still dispatches full-row copy")
-        func copyRowsActionStillCopiesRows() {
-            let delegate = DataGridRowViewCopyDelegateSpy()
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
-                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")],
-                selectedRows: [0, 1],
-                delegate: delegate
-            )
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-
-            invokeCopyRows(on: rowView)
-
-            #expect(delegate.copiedRows == Set([0, 1]))
-        }
-
-        @Test("Copy falls back to row copy when no cell context exists")
-        func copyFallsBackToRowCopy() {
-            let delegate = DataGridRowViewCopyDelegateSpy()
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
-                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")],
-                selectedRows: [0, 1],
-                delegate: delegate
-            )
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 1
-
-            invokeCopy(on: rowView)
-
-            #expect(delegate.copiedRows == Set([0, 1]))
-        }
-
-        @Test("Copy uses the rectangular grid selection when one exists")
-        func copyUsesGridSelection() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
-                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-            )
-            let sweptOrigin = GridCoord(row: 0, displayColumn: 0)
-            coordinator.selectionController.update(
-                .single(GridRect(rows: 0...1, columns: 0...1), anchor: sweptOrigin, active: sweptOrigin)
-            )
-
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-
-            invokeCopy(on: rowView, target: .cell(0))
-
-            #expect(clipboard.text == "1\tAlice\n2\tBob")
-        }
-
-        private func makeRangeSelectedRowView(
-            delegate: (any DataGridViewDelegate)? = nil
-        ) -> (DataGridRowView, TableViewCoordinator) {
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
-                columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")],
-                selectedRows: [1],
-                delegate: delegate
-            )
-            coordinator.selectionController.update(
-                .single(
-                    GridRect(rows: 0...1, columns: 0...1),
-                    anchor: GridCoord(row: 0, displayColumn: 0),
-                    active: GridCoord(row: 1, displayColumn: 0)
-                )
-            )
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 1
-            return (rowView, coordinator)
-        }
-
-        private func withClipboard(_ body: (RecordingClipboard) throws -> Void) throws {
-            try body(try #require(RecordingClipboard.current))
-        }
-
-        @Test("Copy as Rows sends every row of the range selection")
-        func copyRowsUsesRangeSelection() {
-            let delegate = DataGridRowViewCopyDelegateSpy()
-            let (rowView, coordinator) = makeRangeSelectedRowView(delegate: delegate)
-
-            invokeCopyRows(on: rowView)
-
-            #expect(delegate.copiedRows == Set([0, 1]))
-            withExtendedLifetime(coordinator) {}
-        }
-
-        @Test("Copy as With Headers includes every row of the range selection")
-        func copyWithHeadersUsesRangeSelection() throws {
-            try withClipboard { clipboard in
-                let (rowView, coordinator) = makeRangeSelectedRowView()
-
-                _ = rowView.perform(NSSelectorFromString("copySelectedOrCurrentRowWithHeaders"))
-
-                #expect(clipboard.text == "c0\tc1\n1\tAlice\n2\tBob")
-                withExtendedLifetime(coordinator) {}
-            }
-        }
-
-        @Test("Copy as JSON, CSV or Markdown includes every row of the range selection", arguments: [
-            "copyAsJson", "copyAsCsv", "copyAsMarkdown",
-        ])
-        func copyAsFormatUsesRangeSelection(selector: String) throws {
-            try withClipboard { clipboard in
-                let (rowView, coordinator) = makeRangeSelectedRowView()
-
-                _ = rowView.perform(NSSelectorFromString(selector))
-
-                #expect(clipboard.text?.contains("Alice") == true)
-                #expect(clipboard.text?.contains("Bob") == true)
-                withExtendedLifetime(coordinator) {}
-            }
-        }
-
-        @Test("Copy as CSV with Headers includes every row of the range selection")
-        func copyAsCsvWithHeadersUsesRangeSelection() throws {
-            try withClipboard { clipboard in
-                let (rowView, coordinator) = makeRangeSelectedRowView()
-
-                _ = rowView.perform(NSSelectorFromString("copyAsCsvWithHeaders"))
-
-                #expect(clipboard.text?.contains("c0") == true)
-                #expect(clipboard.text?.contains("Alice") == true)
-                #expect(clipboard.text?.contains("Bob") == true)
-                withExtendedLifetime(coordinator) {}
-            }
-        }
-
-        @Test("Copy as IN Clause includes every row of the range selection")
-        func copyAsInClauseUsesRangeSelection() throws {
-            try withClipboard { clipboard in
-                let (rowView, coordinator) = makeRangeSelectedRowView()
-                let item = NSMenuItem(title: "IN Clause", action: nil, keyEquivalent: "")
-                item.representedObject = 1
-
-                _ = rowView.perform(NSSelectorFromString("copyAsInClause:"), with: item)
-
-                #expect(clipboard.text?.contains("Alice") == true)
-                #expect(clipboard.text?.contains("Bob") == true)
-                withExtendedLifetime(coordinator) {}
-            }
-        }
-
-        @Test("Copy as INSERT emits a statement for every row of the range selection")
-        func copyAsInsertUsesRangeSelection() throws {
-            try withClipboard { clipboard in
-                let (rowView, coordinator) = makeRangeSelectedRowView()
-                coordinator.tableName = "users"
-                coordinator.databaseType = .mysql
-
-                _ = rowView.perform(NSSelectorFromString("copyAsInsert"))
-
-                let statements = clipboard.text?.components(separatedBy: "INSERT INTO").count ?? 0
-                #expect(statements - 1 == 2)
-                #expect(clipboard.text?.contains("Alice") == true)
-                #expect(clipboard.text?.contains("Bob") == true)
-            }
-        }
-
-        @Test("Copy as UPDATE emits a statement for every row of the range selection")
-        func copyAsUpdateUsesRangeSelection() throws {
-            try withClipboard { clipboard in
-                let (rowView, coordinator) = makeRangeSelectedRowView()
-                coordinator.tableName = "users"
-                coordinator.databaseType = .mysql
-                coordinator.primaryKeyColumns = ["c0"]
-
-                _ = rowView.perform(NSSelectorFromString("copyAsUpdate"))
-
-                let statements = clipboard.text?.components(separatedBy: "UPDATE").count ?? 0
-                #expect(statements - 1 == 2)
-                #expect(clipboard.text?.contains("Alice") == true)
-                #expect(clipboard.text?.contains("Bob") == true)
-            }
-        }
-
-        @Test("Delete targets every row of the range selection")
-        func deleteUsesRangeSelection() {
-            let delegate = DataGridRowViewCopyDelegateSpy()
-            let (rowView, coordinator) = makeRangeSelectedRowView(delegate: delegate)
-
-            _ = rowView.perform(NSSelectorFromString("deleteRow"))
-
-            #expect(delegate.deletedRows == Set([0, 1]))
-            withExtendedLifetime(coordinator) {}
-        }
-
-        @Test("Copy as JSON includes only the selected column")
-        func copyAsJsonScopesToSelectedColumn() throws {
-            try withClipboard { clipboard in
-                let coordinator = makeCoordinator(
-                    rows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
-                    columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-                )
-                coordinator.selectionController.selectEntireColumn(0, totalRows: 2)
-                let rowView = DataGridRowView()
-                rowView.coordinator = coordinator
-                rowView.rowIndex = 0
-
-                _ = rowView.perform(NSSelectorFromString("copyAsJson"))
-
-                #expect(clipboard.text?.contains("\"c0\"") == true)
-                #expect(clipboard.text?.contains("Alice") != true)
-                #expect(clipboard.text?.contains("Bob") != true)
-            }
-        }
-
-        private func makeCellSelectedCoordinator() -> TableViewCoordinator {
-            let coordinator = makeCoordinator(
-                rows: [[.text("1"), .text("Alice"), .text("NYC"), .text("x")]],
-                columnTypes: [
-                    .integer(rawType: "INT"), .text(rawType: "TEXT"),
-                    .text(rawType: "TEXT"), .text(rawType: "TEXT")
-                ]
-            )
-            coordinator.tableName = "users"
-            coordinator.databaseType = .mysql
-            coordinator.selectionController.update(
-                GridSelection(
-                    rectangles: [
-                        GridRect(cell: GridCoord(row: 0, displayColumn: 2)),
-                        GridRect(cell: GridCoord(row: 0, displayColumn: 3))
-                    ],
-                    activeCell: GridCoord(row: 0, displayColumn: 3),
-                    anchor: GridCoord(row: 0, displayColumn: 2)
-                )
-            )
-            return coordinator
-        }
-
-        @Test("Copy as INSERT includes only the selected columns")
-        func copyAsInsertScopesToSelectedColumns() throws {
-            try withClipboard { clipboard in
-                let coordinator = makeCellSelectedCoordinator()
-                let rowView = DataGridRowView()
-                rowView.coordinator = coordinator
-                rowView.rowIndex = 0
-
-                _ = rowView.perform(NSSelectorFromString("copyAsInsert"))
-
-                #expect(clipboard.text == "INSERT INTO `users` (`c2`, `c3`) VALUES ('NYC', 'x');")
-            }
-        }
-
-        @Test("Copy as UPDATE sets only selected columns and keys WHERE on the primary key")
-        func copyAsUpdateScopesSetToSelectedColumns() throws {
-            try withClipboard { clipboard in
-                let coordinator = makeCellSelectedCoordinator()
-                coordinator.primaryKeyColumns = ["c0"]
-                let rowView = DataGridRowView()
-                rowView.coordinator = coordinator
-                rowView.rowIndex = 0
-
-                _ = rowView.perform(NSSelectorFromString("copyAsUpdate"))
-
-                #expect(clipboard.text == "UPDATE `users` SET `c2` = 'NYC', `c3` = 'x' WHERE `c0` = '1';")
-            }
-        }
-
-        @Test("Copy as UPDATE without a primary key keeps the full row in WHERE")
-        func copyAsUpdateNoPrimaryKeyKeysWhereOnFullRow() throws {
-            try withClipboard { clipboard in
-                let coordinator = makeCoordinator(
-                    rows: [[.text("1"), .text("Alice"), .text("NYC")]],
-                    columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .text(rawType: "TEXT")]
-                )
-                coordinator.tableName = "users"
-                coordinator.databaseType = .mysql
-                coordinator.selectionController.update(
-                    GridSelection(
-                        rectangles: [GridRect(cell: GridCoord(row: 0, displayColumn: 2))],
-                        activeCell: GridCoord(row: 0, displayColumn: 2),
-                        anchor: GridCoord(row: 0, displayColumn: 2)
-                    )
-                )
-                let rowView = DataGridRowView()
-                rowView.coordinator = coordinator
-                rowView.rowIndex = 0
-
-                _ = rowView.perform(NSSelectorFromString("copyAsUpdate"))
-
-                #expect(clipboard.text == "UPDATE `users` SET `c2` = 'NYC' WHERE `c0` = '1' AND `c1` = 'Alice' AND `c2` = 'NYC';")
-            }
-        }
-
-        @Test("Copy as INSERT flattens a discontiguous selection to the column-union rectangle")
-        func copyAsInsertFlattensDiscontiguousSelection() throws {
-            try withClipboard { clipboard in
-                let coordinator = makeCoordinator(
-                    rows: [
-                        [.text("1"), .text("Alice"), .text("NYC")],
-                        [.text("2"), .text("Bob"), .text("LA")]
-                    ],
-                    columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .text(rawType: "TEXT")]
-                )
-                coordinator.tableName = "users"
-                coordinator.databaseType = .mysql
-                coordinator.selectionController.update(
-                    GridSelection(
-                        rectangles: [
-                            GridRect(cell: GridCoord(row: 0, displayColumn: 2)),
-                            GridRect(cell: GridCoord(row: 1, displayColumn: 0))
-                        ],
-                        activeCell: GridCoord(row: 1, displayColumn: 0),
-                        anchor: GridCoord(row: 0, displayColumn: 2)
-                    )
-                )
-                let rowView = DataGridRowView()
-                rowView.coordinator = coordinator
-                rowView.rowIndex = 0
-
-                _ = rowView.perform(NSSelectorFromString("copyAsInsert"))
-
-                let text = clipboard.text ?? ""
-                #expect(text.contains("INSERT INTO `users` (`c0`, `c2`) VALUES ('1', 'NYC');"))
-                #expect(text.contains("INSERT INTO `users` (`c0`, `c2`) VALUES ('2', 'LA');"))
-            }
-        }
-
-        @Test("Copy as CSV includes only the selected column")
-        func copyAsCsvScopesToSelectedColumn() throws {
-            try withClipboard { clipboard in
-                let coordinator = makeCoordinator(
-                    rows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
-                    columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-                )
-                coordinator.selectionController.selectEntireColumn(0, totalRows: 2)
-                let rowView = DataGridRowView()
-                rowView.coordinator = coordinator
-                rowView.rowIndex = 0
-
-                _ = rowView.perform(NSSelectorFromString("copyAsCsv"))
-
-                #expect(clipboard.text?.contains("Alice") != true)
-                #expect(clipboard.text?.contains("Bob") != true)
-            }
-        }
-
-        @Test("Copy as JSON falls back to the clicked row without any selection")
-        func copyAsJsonFallsBackToClickedRow() throws {
-            try withClipboard { clipboard in
-                let coordinator = makeCoordinator(
-                    rows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")]],
-                    columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-                )
-                let rowView = DataGridRowView()
-                rowView.coordinator = coordinator
-                rowView.rowIndex = 1
-
-                _ = rowView.perform(NSSelectorFromString("copyAsJson"))
-
-                #expect(clipboard.text?.contains("Bob") == true)
-                #expect(clipboard.text?.contains("Alice") != true)
-            }
-        }
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridRowViewSetValueTests.swift b/apple/TableProTests/Views/Results/DataGridRowViewSetValueTests.swift
deleted file mode 100644
index bb63f5d77d..0000000000
--- a/apple/TableProTests/Views/Results/DataGridRowViewSetValueTests.swift
+++ /dev/null
@@ -1,218 +0,0 @@
-//
-//  DataGridRowViewSetValueTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class SetValueMenuLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class SetValueMenuRowStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
-@MainActor
-struct DataGridRowViewSetValueTests {
-    private struct Fixture {
-        let manager: DataChangeManager
-        let coordinator: TableViewCoordinator
-        let store: SetValueMenuRowStore
-    }
-
-    private func makeFixture(
-        columns: [String],
-        columnTypes: [ColumnType],
-        rows: [[PluginCellValue]],
-        columnNullable: [String: Bool] = [:],
-        columnDefaults: [String: String?] = [:],
-        columnForeignKeys: [String: ForeignKeyInfo] = [:],
-        databaseType: DatabaseType = .postgresql
-    ) -> Fixture {
-        let manager = DataChangeManager()
-        manager.configureForTable(
-            tableName: "t",
-            columns: columns,
-            primaryKeyColumns: [columns[0]],
-            databaseType: databaseType,
-            generatedColumns: []
-        )
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(manager),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: SetValueMenuLayoutPersister()
-        )
-        let store = SetValueMenuRowStore(TableRows.from(
-            queryRows: rows,
-            columns: columns,
-            columnTypes: columnTypes,
-            columnDefaults: columnDefaults,
-            columnForeignKeys: columnForeignKeys,
-            columnNullable: columnNullable
-        ))
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-        coordinator.databaseType = databaseType
-        coordinator.updateCache()
-        return Fixture(manager: manager, coordinator: coordinator, store: store)
-    }
-
-    private func setValueMenu(_ fixture: Fixture, row: Int = 0, column: Int) -> (DataGridRowView, NSMenu) {
-        let rowView = DataGridRowView()
-        rowView.coordinator = fixture.coordinator
-        rowView.rowIndex = row
-        let targets = fixture.coordinator.setValueTargets(clicked: SetValueTarget(displayRow: row, columnIndex: column))
-        let menu = rowView.buildSetValueMenu(
-            commands: fixture.coordinator.setValueCommands(for: targets),
-            clickedColumn: column
-        )
-        return (rowView, menu)
-    }
-
-    private func titles(_ menu: NSMenu) -> [String] {
-        menu.items.map { $0.isSeparatorItem ? "-" : $0.title }
-    }
-
-    private func uuidKeyFixture() -> Fixture {
-        makeFixture(
-            columns: ["id", "name"],
-            columnTypes: [.text(rawType: "uuid"), .text(rawType: "text")],
-            rows: [[.null, .text("a")]],
-            columnNullable: ["id": false, "name": true]
-        )
-    }
-
-    @Test("A PostgreSQL uuid key, NOT NULL with no default, offers Generate UUID and Generate UUIDv7")
-    func reportersUUIDKey() {
-        let (_, menu) = setValueMenu(uuidKeyFixture(), column: 0)
-
-        #expect(titles(menu) == ["Generate UUID", "Generate UUIDv7"])
-    }
-
-    @Test("A date column lists the engine's functions after the placeholders, behind a separator")
-    func dateColumnFunctions() {
-        let fixture = makeFixture(
-            columns: ["id", "born"],
-            columnTypes: [.integer(rawType: "INT"), .date(rawType: "DATE")],
-            rows: [[.text("1"), .text("2024-01-01")]],
-            columnNullable: ["born": true],
-            databaseType: .mysql
-        )
-
-        let (_, menu) = setValueMenu(fixture, column: 1)
-
-        #expect(titles(menu) == ["NULL", "-", "CURDATE()", "UTC_DATE()"])
-    }
-
-    @Test("A nullable uuid column with a default keeps NULL and Default apart from the UUIDs")
-    func uuidWithDefaultGroups() {
-        let fixture = makeFixture(
-            columns: ["id", "ref"],
-            columnTypes: [.integer(rawType: "int4"), .text(rawType: "uuid")],
-            rows: [[.text("1"), .null]],
-            columnNullable: ["ref": true],
-            columnDefaults: ["ref": "gen_random_uuid()"]
-        )
-
-        let (_, menu) = setValueMenu(fixture, column: 1)
-
-        #expect(titles(menu) == ["NULL", "Default", "-", "Generate UUID", "Generate UUIDv7"])
-    }
-
-    @Test("A uuid foreign key offers no new UUID, which would point at no row")
-    func foreignKeyOffersNoUUID() {
-        let fixture = makeFixture(
-            columns: ["id", "owner"],
-            columnTypes: [.integer(rawType: "int4"), .text(rawType: "uuid")],
-            rows: [[.text("1"), .null]],
-            columnNullable: ["owner": true],
-            columnForeignKeys: [
-                "owner": ForeignKeyInfo(name: "fk", column: "owner", referencedTable: "users", referencedColumn: "id")
-            ]
-        )
-
-        let (_, menu) = setValueMenu(fixture, column: 1)
-
-        #expect(titles(menu) == ["NULL"])
-    }
-
-    @Test("Choosing Generate UUID writes a new lowercase UUID into the clicked cell")
-    func choosingGenerateUUIDWritesIt() throws {
-        let fixture = uuidKeyFixture()
-        let (rowView, menu) = setValueMenu(fixture, column: 0)
-        let item = try #require(menu.items.first { $0.title == "Generate UUID" })
-        let action = try #require(item.action)
-
-        _ = rowView.perform(action, with: item)
-
-        let staged = try #require(
-            fixture.manager.pending.change(forRow: .existing(0), type: .update)?.cellChanges.first?.newValue.asText
-        )
-        #expect(staged == staged.lowercased())
-        #expect(UUID(uuidString: staged) != nil)
-        #expect(fixture.store.tableRows.rows[0].values[0] == .text(staged))
-    }
-
-    @Test("The cell's context menu carries Set Value on the reporter's uuid key")
-    func contextMenuCarriesSetValue() throws {
-        let fixture = uuidKeyFixture()
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = fixture.coordinator
-        fixture.coordinator.tableView = tableView
-        let rowView = DataGridRowView()
-        rowView.coordinator = fixture.coordinator
-        rowView.rowIndex = 0
-
-        let menu = try #require(rowView.contextMenu(target: .cell(dataColumn: 0)))
-        let setValue = try #require(menu.items.first { $0.title == "Set Value" }?.submenu)
-
-        #expect(titles(setValue) == ["Generate UUID", "Generate UUIDv7", "-", "Set Cells to Value…"])
-    }
-
-    @Test("A NOT NULL number with no default still offers Set Cells to Value, alone")
-    func typedValueIsTheOnlyItemOnANotNullNumber() throws {
-        let fixture = makeFixture(
-            columns: ["id", "qty"],
-            columnTypes: [.integer(rawType: "int4"), .integer(rawType: "int4")],
-            rows: [[.text("1"), .text("5")]],
-            columnNullable: ["id": false, "qty": false]
-        )
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = fixture.coordinator
-        fixture.coordinator.tableView = tableView
-        let rowView = DataGridRowView()
-        rowView.coordinator = fixture.coordinator
-        rowView.rowIndex = 0
-
-        let menu = try #require(rowView.contextMenu(target: .cell(dataColumn: 1)))
-        let setValue = try #require(menu.items.first { $0.title == "Set Value" }?.submenu)
-
-        #expect(titles(setValue) == ["Set Cells to Value…"])
-    }
-
-    @Test("A read-only grid has no Set Value at all")
-    func readOnlyGridOffersNothing() {
-        let fixture = uuidKeyFixture()
-        fixture.coordinator.isEditable = false
-
-        let (_, menu) = setValueMenu(fixture, column: 1)
-
-        #expect(menu.items.isEmpty)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridSelectionSummaryMenuTests.swift b/apple/TableProTests/Views/Results/DataGridSelectionSummaryMenuTests.swift
deleted file mode 100644
index 97fe8299f8..0000000000
--- a/apple/TableProTests/Views/Results/DataGridSelectionSummaryMenuTests.swift
+++ /dev/null
@@ -1,159 +0,0 @@
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class SummaryMenuLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-extension GlobalStateSuites {
-    @Suite("Selection summary menus", .recordingClipboard)
-    @MainActor
-    struct DataGridSelectionSummaryMenuTests {
-        private static let columnTypes: [ColumnType] = [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-        private static let selectColumnAction = #selector(TableViewCoordinator.selectColumnFromHeaderMenu(_:))
-        private static let copyFigureAction = NSSelectorFromString("copySelectionSummaryFigure:")
-
-        /// The coordinator holds its table view weakly, so the test keeps it alive across an await.
-        private struct Fixture {
-            let coordinator: TableViewCoordinator
-            let tableView: KeyHandlingTableView
-        }
-
-        private func makeFixture() -> Fixture {
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: false,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: SummaryMenuLayoutPersister()
-            )
-            let tableRows = TableRows.from(
-                queryRows: [
-                    [.text("1"), .text("a")],
-                    [.text("2"), .text("b")],
-                    [.text("3"), .text("c")],
-                ],
-                columns: ["amount", "name"],
-                columnTypes: Self.columnTypes
-            )
-            coordinator.tableRowsProvider = { tableRows }
-            coordinator.rebuildColumnMetadataCache(from: tableRows)
-            coordinator.updateCache()
-
-            let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-            tableView.coordinator = coordinator
-            tableView.dataSource = coordinator
-            tableView.delegate = coordinator
-            tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-            coordinator.tableView = tableView
-            coordinator.columnPool.reconcile(
-                tableView: tableView,
-                schema: coordinator.identitySchema,
-                columnTypes: Self.columnTypes,
-                savedLayout: nil,
-                isEditable: false,
-                hiddenColumnNames: [],
-                firstClickSortDirection: .ascending,
-                widthCalculator: { _, _ in 90 }
-            )
-            return Fixture(coordinator: coordinator, tableView: tableView)
-        }
-
-        private func headerMenu(_ coordinator: TableViewCoordinator, dataColumn: Int) throws -> NSMenu {
-            let tableView = try #require(coordinator.tableView)
-            let column = try #require(tableView.tableColumns.firstIndex {
-                coordinator.dataColumnIndex(from: $0.identifier) == dataColumn
-            })
-            let menu = NSMenu()
-            coordinator.populateHeaderMenu(menu, forColumnAt: column)
-            return menu
-        }
-
-        private func summarizeColumn(_ dataColumn: Int, in coordinator: TableViewCoordinator) async {
-            let tracker = coordinator.selectionSummaryTracker
-            tracker.attach(SelectionSummaryState())
-            coordinator.selectColumn(dataColumn)
-            tracker.selectionDidChange()
-            await tracker.pendingTask?.value
-        }
-
-        private func makeRowView(_ coordinator: TableViewCoordinator) -> DataGridRowView {
-            let rowView = DataGridRowView()
-            rowView.coordinator = coordinator
-            rowView.rowIndex = 0
-            return rowView
-        }
-
-        @Test("The header menu offers Select Column just before Copy Column Name")
-        func selectColumnPrecedesCopyColumnName() throws {
-            let fixture = makeFixture()
-            let coordinator = fixture.coordinator
-            let items = try headerMenu(coordinator, dataColumn: 1).items
-
-            let select = try #require(items.firstIndex { $0.action == Self.selectColumnAction })
-            let next = items.dropFirst(select + 1).first
-            #expect(next?.action == #selector(TableViewCoordinator.copyColumnName(_:)))
-        }
-
-        @Test("Select Column selects every row of the column the menu was opened on")
-        func selectColumnSelectsTheWholeColumn() throws {
-            let fixture = makeFixture()
-            let coordinator = fixture.coordinator
-            let menu = try headerMenu(coordinator, dataColumn: 1)
-            let index = try #require(menu.items.firstIndex { $0.action == Self.selectColumnAction })
-
-            menu.performActionForItem(at: index)
-
-            let position = try #require(coordinator.displayPosition(ofDataColumnIndex: 1))
-            let selection = coordinator.selectionController.selection
-            #expect(selection.columns == IndexSet(integer: position))
-            #expect(selection.affectedRows == IndexSet(integersIn: 0..<3))
-        }
-
-        @Test("The cell menu offers Copy Sum and Copy Average right after Copy as, as plain text")
-        func cellMenuCopiesTheSummary() async throws {
-            let fixture = makeFixture()
-            let coordinator = fixture.coordinator
-            await summarizeColumn(0, in: coordinator)
-            #expect(coordinator.selectionSummaryTracker.currentSummary?.numbers != nil)
-
-            let rowView = makeRowView(coordinator)
-            let menu = try #require(rowView.contextMenu(target: .cell(dataColumn: 0)))
-            let titles = menu.items.map(\.title)
-            let copyAs = try #require(titles.firstIndex(of: String(localized: "Copy as")))
-            #expect(Array(titles.dropFirst(copyAs + 1).prefix(2)) == [
-                String(localized: "Copy Sum"),
-                String(localized: "Copy Average"),
-            ])
-
-            let clipboard = try #require(RecordingClipboard.current)
-            menu.performActionForItem(at: copyAs + 1)
-            #expect(clipboard.text == "6")
-            menu.performActionForItem(at: copyAs + 2)
-            #expect(clipboard.text == "2")
-            withExtendedLifetime(fixture) {}
-        }
-
-        @Test("A selection holding no numbers offers no summary copies")
-        func cellMenuHidesSummaryCopiesWithoutNumbers() async throws {
-            let fixture = makeFixture()
-            let coordinator = fixture.coordinator
-            await summarizeColumn(1, in: coordinator)
-            let summary = try #require(coordinator.selectionSummaryTracker.currentSummary)
-            #expect(summary.numbers == nil)
-
-            let rowView = makeRowView(coordinator)
-            let menu = try #require(rowView.contextMenu(target: .cell(dataColumn: 1)))
-            #expect(!menu.items.contains { $0.action == Self.copyFigureAction })
-            withExtendedLifetime(fixture) {}
-        }
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridThemeDrawingTests.swift b/apple/TableProTests/Views/Results/DataGridThemeDrawingTests.swift
deleted file mode 100644
index bae113116d..0000000000
--- a/apple/TableProTests/Views/Results/DataGridThemeDrawingTests.swift
+++ /dev/null
@@ -1,317 +0,0 @@
-//
-//  DataGridThemeDrawingTests.swift
-//  TableProTests
-//
-//  Default Light and Default Dark declare no grid color, so the grid has to draw what AppKit draws:
-//  NSTableRowView's own selection, `headerTextColor`, `separatorColor`. A theme that declares a
-//  grid color has to reach every surface that shows it, the row-number gutter included.
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import TableProTheme
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class ThemeDrawingLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// Overriding a draw method moves a row off AppKit's update-layer path, so this takes the same path
-/// as `DataGridRowView` and the two can be held pixel for pixel to each other.
-@MainActor
-private final class DrawPathRowView: NSTableRowView {
-    // swiftlint:disable:next unneeded_override
-    override func drawBackground(in dirtyRect: NSRect) {
-        super.drawBackground(in: dirtyRect)
-    }
-}
-
-/// Each test adopts a pair on the shared `ThemeEngine` and restores it in a `defer`. The bodies are
-/// synchronous and `@MainActor`, so nothing else on the main actor runs between the two; an `await`
-/// added anywhere in between would break that.
-@MainActor
-struct DataGridThemeDrawingTests {
-    private static let rowFrame = NSRect(x: 0, y: 0, width: 160, height: 24)
-
-    private struct Grid {
-        let window: NSWindow
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-    }
-
-    private func adopting(_ overrides: [ThemeSlot: String], _ body: () throws -> Void) throws {
-        let engine = ThemeEngine.shared
-        let restore = ThemeSelection(pair: engine.pair, effectiveAppearance: engine.effectiveAppearance)
-        defer { engine.adopt(restore) }
-
-        var theme = BuiltInThemes.light
-        if !overrides.isEmpty {
-            theme.id = "test.grid-theme-drawing"
-            for (slot, hex) in overrides {
-                theme.overrides[slot] = try ThemeColor(validating: hex)
-            }
-        }
-        engine.adopt(ThemeSelection(
-            pair: ThemePair(light: theme, dark: BuiltInThemes.dark),
-            effectiveAppearance: .light
-        ))
-        try body()
-    }
-
-    private func selected(_ row: NSTableRowView, emphasized: Bool) throws -> NSTableRowView {
-        row.appearance = try #require(NSAppearance(named: .aqua))
-        row.wantsLayer = true
-        row.isSelected = true
-        row.isEmphasized = emphasized
-        return row
-    }
-
-    private func centerColor(of view: NSView) throws -> NSColor {
-        let rep = try #require(view.bitmapImageRepForCachingDisplay(in: view.bounds))
-        view.cacheDisplay(in: view.bounds, to: rep)
-        let color = try #require(rep.colorAt(x: rep.pixelsWide / 2, y: rep.pixelsHigh / 2))
-        return try #require(color.usingColorSpace(.sRGB))
-    }
-
-    private func matches(_ lhs: NSColor, _ rhs: NSColor, tolerance: CGFloat = 0.02) -> Bool {
-        abs(lhs.redComponent - rhs.redComponent) <= tolerance
-            && abs(lhs.greenComponent - rhs.greenComponent) <= tolerance
-            && abs(lhs.blueComponent - rhs.blueComponent) <= tolerance
-            && abs(lhs.alphaComponent - rhs.alphaComponent) <= tolerance
-    }
-
-    private func cellAppearance(palette: DataGridCellPalette, onEmphasizedSelection: Bool) -> DataGridCellAppearance {
-        DataGridCellAppearance.resolve(
-            kind: .text,
-            content: DataGridCellContent(displayText: "value", rawValue: "value", placeholder: nil),
-            state: DataGridCellState(
-                visualState: .empty,
-                isFocused: true,
-                isEditable: true,
-                isLargeDataset: false,
-                isCurrentFindMatch: false,
-                row: 0,
-                columnIndex: 0
-            ),
-            palette: palette,
-            nullDisplayString: "NULL",
-            onEmphasizedSelection: onEmphasizedSelection,
-            hasOverlay: false
-        )
-    }
-
-    private func makeGrid(rows: Int = 3) -> Grid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: ThemeDrawingLayoutPersister()
-        )
-        let columns = ["id", "name"]
-        let columnTypes = Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        let tableRows = TableRows.from(
-            queryRows: (0..<rows).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } },
-            columns: columns,
-            columnTypes: columnTypes
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-        tableView.style = .plain
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = 21
-        tableView.allowsMultipleSelection = true
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 120 }
-        )
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.appearance = NSAppearance(named: .aqua)
-        window.contentView = scrollView
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        window.layoutIfNeeded()
-        for row in 0..<rows {
-            _ = tableView.rowView(atRow: row, makeIfNecessary: true)
-        }
-        return Grid(window: window, tableView: tableView, coordinator: coordinator)
-    }
-
-    // MARK: - Row selection
-
-    /// The regression this guards: the row painted the accent at 28% under white text, 1.5:1 in
-    /// Light. Without a theme selection the row is `NSTableRowView`'s own drawing, so it is held to a
-    /// stock row in the same state, whatever AppKit draws there.
-    @Test("Under the default theme a selected row draws exactly what NSTableRowView draws", arguments: [true, false])
-    func defaultThemeSelectionIsNative(emphasized: Bool) throws {
-        try adopting([:]) {
-            #expect(DataGridBodyChrome.themedSelectionColor(emphasized: emphasized, scope: .live) == nil)
-
-            let grid = try centerColor(of: selected(DataGridRowView(frame: Self.rowFrame), emphasized: emphasized))
-            let stock = try centerColor(of: selected(DrawPathRowView(frame: Self.rowFrame), emphasized: emphasized))
-            #expect(matches(grid, stock), "grid row \(grid), stock row \(stock)")
-        }
-    }
-
-    @Test("Under the default theme the gutter and a selected heading fill with the system selection")
-    func defaultThemeSelectionColors() throws {
-        try adopting([:]) {
-            #expect(DataGridBodyChrome.selectionColor(emphasized: true, scope: .live) == .selectedContentBackgroundColor)
-            #expect(DataGridBodyChrome.selectionColor(emphasized: false, scope: .live) == .unemphasizedSelectedContentBackgroundColor)
-
-            let aqua = try #require(NSAppearance(named: .aqua))
-            let palette = ThemeScope.live.dataGridCellPalette(in: aqua)
-            #expect(palette.selectionText == .alternateSelectedControlTextColor)
-            #expect(palette.rowNumberColor(for: .empty, onEmphasizedSelection: true) == .alternateSelectedControlTextColor)
-            #expect(palette.rowNumberColor(for: .empty, onEmphasizedSelection: false) == palette.rowNumberText)
-        }
-    }
-
-    @Test("A theme's selection replaces the row's fill as declared, focused and unfocused")
-    func themedSelectionFill() throws {
-        try adopting([.gridSelection: "#FF0000", .gridInactiveSelection: "#0000FF"]) {
-            let focused = try centerColor(of: selected(DataGridRowView(frame: Self.rowFrame), emphasized: true))
-            let unfocused = try centerColor(of: selected(DataGridRowView(frame: Self.rowFrame), emphasized: false))
-
-            #expect(focused.alphaComponent > 0.99, "the focused selection is a wash: \(focused)")
-            #expect(focused.redComponent > 0.9 && focused.greenComponent < 0.2 && focused.blueComponent < 0.2, "\(focused)")
-            #expect(unfocused.alphaComponent > 0.99, "the unfocused selection is a wash: \(unfocused)")
-            #expect(unfocused.blueComponent > 0.9 && unfocused.redComponent < 0.2, "\(unfocused)")
-        }
-    }
-
-    @Test("A theme's selection and its text reach the cells and the row-number gutter")
-    func themedSelectionReachesCellsAndGutter() throws {
-        try adopting([.gridSelection: "#202020", .gridSelectionText: "#00FF00"]) {
-            let engine = ThemeEngine.shared
-            let selectionText = engine.resolved[.gridSelectionText]
-            let aqua = try #require(NSAppearance(named: .aqua))
-            let palette = ThemeScope.live.dataGridCellPalette(in: aqua)
-            let selectedCell = cellAppearance(palette: palette, onEmphasizedSelection: true)
-            let plainCell = cellAppearance(palette: palette, onEmphasizedSelection: false)
-
-            #expect(palette.selectionText == selectionText)
-            #expect(selectedCell.textColor == selectionText)
-            #expect(selectedCell.focusColor == selectionText)
-            #expect(plainCell.textColor == palette.text)
-            #expect(palette.rowNumberColor(for: .empty, onEmphasizedSelection: true) == selectionText)
-            #expect(DataGridBodyChrome.selectionColor(emphasized: true, scope: .live) == engine.resolved[.gridSelection])
-            #expect(DataGridBodyChrome.themedSelectionColor(emphasized: true, scope: .live) == engine.resolved[.gridSelection])
-            #expect(DataGridBodyChrome.themedSelectionColor(emphasized: false, scope: .live) == nil)
-        }
-    }
-
-    @Test("Cells a range covers under a theme's selection take its selection text, like a selected row")
-    func themedRangeSelectionRecolorsItsCells() throws {
-        let grid = makeGrid()
-        grid.coordinator.selectionController.selectEntireColumn(0, totalRows: 3)
-        let row = try #require(grid.tableView.rowView(atRow: 1, makeIfNecessary: true) as? DataGridRowView)
-        row.isEmphasized = true
-        let firstDataColumn = try #require(grid.coordinator.tableColumnIndex(forDisplayPosition: 0))
-
-        #expect(row.themedRangeColumns().isEmpty, "Under the default theme a range keeps its tint and the cell text")
-
-        try adopting([.gridSelection: "#000000", .gridSelectionText: "#FFFFFF"]) {
-            #expect(row.themedRangeColumns() == [firstDataColumn])
-            row.isEmphasized = false
-            #expect(row.themedRangeColumns().isEmpty, "An unfocused range draws normal text, like an unfocused row")
-        }
-    }
-
-    // MARK: - Header
-
-    @Test("Under the default theme the header draws in AppKit's header colors")
-    func defaultHeaderColors() throws {
-        try adopting([:]) {
-            let cell = SortableHeaderCell(textCell: "name")
-
-            #expect(cell.foregroundColor(emphasized: false, scope: .live) == .headerTextColor)
-            #expect(cell.foregroundColor(emphasized: true, scope: .live) == .alternateSelectedControlTextColor)
-            #expect(SortableHeaderChrome.lineColor(scope: .live) == .separatorColor)
-            #expect(SortableHeaderChrome.backgroundColor(scope: .live) == .controlBackgroundColor)
-        }
-    }
-
-    @Test("A theme's header text, grid line and selection text reach the header")
-    func themedHeaderColors() throws {
-        try adopting([.gridHeaderText: "#FF0000", .gridLine: "#00FF00", .gridSelectionText: "#0000FF"]) {
-            let engine = ThemeEngine.shared
-            let cell = SortableHeaderCell(textCell: "name")
-
-            #expect(cell.foregroundColor(emphasized: false, scope: .live) == engine.resolved[.gridHeaderText])
-            #expect(cell.foregroundColor(emphasized: true, scope: .live) == engine.resolved[.gridSelectionText])
-            #expect(SortableHeaderChrome.lineColor(scope: .live) == engine.resolved[.gridLine])
-            #expect(SortableHeaderChrome.lineColor(scope: .live) != .separatorColor)
-        }
-    }
-
-    // MARK: - Theme change
-
-    /// `themeChanged` fires for every Accent, Highlight and Increase Contrast change too. A reload
-    /// there would drop the selection and every formatted value on each of them.
-    @Test("A theme change repaints the grid in place, keeping its selection, rows and formatted values")
-    func themeChangeRepaintsWithoutReloading() throws {
-        let grid = makeGrid()
-        try withExtendedLifetime(grid.window) {
-            grid.tableView.selectRowIndexes(IndexSet(integer: 1), byExtendingSelection: false)
-            let rowNumberColumn = grid.tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-            let rowView = try #require(grid.tableView.rowView(atRow: 0, makeIfNecessary: false))
-            let numberCell = try #require(
-                grid.tableView.view(atColumn: rowNumberColumn, row: 0, makeIfNecessary: false) as? NSTableCellView
-            )
-            let firstRow = try #require(grid.coordinator.displayRow(at: 0))
-            _ = grid.coordinator.cellAppearance(row: 0, columnIndex: 0, onEmphasizedSelection: false)
-            try #require(grid.coordinator.displayCache.box(forID: firstRow.id) != nil)
-
-            try adopting([.gridLine: "#FF0000", .gridRowNumber: "#00FF00", .gridSelectionText: "#0000FF"]) {
-                grid.coordinator.themeDidChange()
-                let engine = ThemeEngine.shared
-
-                #expect(grid.tableView.gridColor == engine.resolved[.gridLine])
-                #expect(grid.coordinator.cellRegistry.palette.selectionText == engine.resolved[.gridSelectionText])
-                #expect(numberCell.textField?.textColor == engine.resolved[.gridRowNumber])
-                #expect(grid.tableView.selectedRowIndexes == IndexSet(integer: 1))
-                #expect(grid.tableView.rowView(atRow: 0, makeIfNecessary: false) === rowView)
-                #expect(grid.coordinator.displayCache.box(forID: firstRow.id) != nil)
-            }
-
-            try adopting([:]) {
-                grid.coordinator.themeDidChange()
-
-                #expect(grid.tableView.gridColor == .separatorColor)
-                #expect(grid.coordinator.cellRegistry.palette.selectionText == .alternateSelectedControlTextColor)
-            }
-        }
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridThemeScopeTests.swift b/apple/TableProTests/Views/Results/DataGridThemeScopeTests.swift
deleted file mode 100644
index b6b1fede22..0000000000
--- a/apple/TableProTests/Views/Results/DataGridThemeScopeTests.swift
+++ /dev/null
@@ -1,518 +0,0 @@
-//
-//  DataGridThemeScopeTests.swift
-//  TableProTests
-//
-//  A grid draws every color through the scope it is handed, so the theme editor can show a draft in
-//  a real grid while every other grid keeps the app's theme. Mounted through `DataGridView` itself,
-//  the way the editor's preview mounts it, and rasterized into sRGB so a theme's hex reads back as
-//  written. Every case runs on fixed scopes and leaves the shared engine alone.
-//
-
-import AppKit
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import TableProTheme
-import Testing
-
-@MainActor
-private final class ScopeLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class ScopedGrid {
-    private let window: NSWindow
-    private let host: NSHostingView<DataGridView>
-    private let rows: TableRows
-
-    init(scope: ThemeScope, appearance: NSAppearance.Name = .aqua, rowCount: Int = 4) async {
-        let columns = ["id", "name"]
-        rows = TableRows.from(
-            queryRows: (0 ..< rowCount).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } },
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count)
-        )
-        window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.appearance = NSAppearance(named: appearance)
-        host = NSHostingView(rootView: Self.makeGrid(rows: rows, scope: scope))
-        window.contentView = host
-        await settle()
-        tableView?.usesAlternatingRowBackgroundColors = true
-    }
-
-    /// A new root value, which is how the editor hands the preview a new draft.
-    func show(scope: ThemeScope) async {
-        host.rootView = Self.makeGrid(rows: rows, scope: scope)
-        await settle()
-    }
-
-    func close() {
-        window.orderOut(nil)
-    }
-
-    var tableView: KeyHandlingTableView? {
-        Self.first(KeyHandlingTableView.self, in: host)
-    }
-
-    var coordinator: TableViewCoordinator? { tableView?.coordinator }
-
-    var header: SortableHeaderView? { tableView?.headerView as? SortableHeaderView }
-
-    func rowView(_ row: Int) throws -> DataGridRowView {
-        let tableView = try #require(tableView)
-        return try #require(tableView.rowView(atRow: row, makeIfNecessary: true) as? DataGridRowView)
-    }
-
-    private static func makeGrid(rows: TableRows, scope: ThemeScope) -> DataGridView {
-        DataGridView(
-            tableRowsProvider: { rows },
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            configuration: DataGridConfiguration(tabType: .query),
-            layoutPersister: ScopeLayoutPersister(),
-            selectedRowIndices: .constant([]),
-            sortState: .constant(SortState()),
-            columnLayout: .constant(ColumnLayoutState()),
-            themeScope: scope
-        )
-    }
-
-    private func settle() async {
-        for _ in 0 ..< 10 {
-            host.layoutSubtreeIfNeeded()
-            await withCheckedContinuation { continuation in
-                DispatchQueue.main.async { continuation.resume() }
-            }
-        }
-    }
-
-    private static func first<T: NSView>(_ type: T.Type, in view: NSView) -> T? {
-        if let match = view as? T { return match }
-        for subview in view.subviews {
-            if let found = first(type, in: subview) { return found }
-        }
-        return nil
-    }
-}
-
-/// A view's drawing methods called straight into an sRGB bitmap, the way AppKit calls them, so a
-/// theme's hex reads back as written. `cacheDisplay` of a table and its rows goes through the layer
-/// tree and the window's color space instead.
-@MainActor
-private struct Raster {
-    let rep: NSBitmapImageRep
-    let bounds: NSRect
-    let isFlipped: Bool
-
-    init(_ view: NSView, draw: (NSRect) -> Void) throws {
-        let area = view.bounds
-        let space = try #require(CGColorSpace(name: CGColorSpace.sRGB))
-        let cgContext = try #require(CGContext(
-            data: nil,
-            width: Int(area.width),
-            height: Int(area.height),
-            bitsPerComponent: 8,
-            bytesPerRow: 0,
-            space: space,
-            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
-        ))
-        if view.isFlipped {
-            cgContext.translateBy(x: 0, y: area.height)
-            cgContext.scaleBy(x: 1, y: -1)
-        }
-        cgContext.translateBy(x: -area.minX, y: -area.minY)
-        NSGraphicsContext.saveGraphicsState()
-        NSGraphicsContext.current = NSGraphicsContext(cgContext: cgContext, flipped: view.isFlipped)
-        view.effectiveAppearance.performAsCurrentDrawingAppearance {
-            draw(area)
-        }
-        NSGraphicsContext.restoreGraphicsState()
-        rep = NSBitmapImageRep(cgImage: try #require(cgContext.makeImage()))
-        bounds = area
-        isFlipped = view.isFlipped
-    }
-
-    /// What a row view lays down, in AppKit's order: background, selection, then the cells.
-    static func row(_ rowView: DataGridRowView) throws -> Raster {
-        try Raster(rowView) { rect in
-            rowView.drawBackground(in: rect)
-            if rowView.isSelected {
-                rowView.drawSelection(in: rect)
-            }
-            rowView.drawCells(in: rect, of: rowView)
-        }
-    }
-
-    static func view(_ view: NSView) throws -> Raster {
-        try Raster(view) { view.draw($0) }
-    }
-
-    func color(at point: NSPoint) throws -> NSColor {
-        let column = Int(point.x - bounds.minX)
-        let fromTop = isFlipped ? point.y - bounds.minY : bounds.maxY - point.y
-        return try #require(rep.colorAt(x: column, y: Int(fromTop))?.usingColorSpace(.sRGB))
-    }
-
-    func hex(at point: NSPoint) throws -> String {
-        ThemeColor(try color(at: point)).hex
-    }
-
-    /// The lightest and darkest pixels in `rect`, by relative luminance.
-    func luminanceRange(in rect: NSRect) throws -> ClosedRange<Double> {
-        var lowest = Double.infinity
-        var highest = -Double.infinity
-        for y in Int(rect.minY) ..< Int(rect.maxY) {
-            for x in Int(rect.minX) ..< Int(rect.maxX) {
-                let luminance = ThemeColor(try color(at: NSPoint(x: x, y: y))).relativeLuminance
-                lowest = min(lowest, luminance)
-                highest = max(highest, luminance)
-            }
-        }
-        return lowest ... highest
-    }
-}
-
-/// Held to the expected color drawn the same way, a plain fill through the same context, so the
-/// conversion AppKit applies on the way into the bitmap cancels out. Within three levels a channel.
-@MainActor
-private func isNear(_ drawn: String, _ expected: String) -> Bool {
-    guard let lhs = ThemeColor(hex: drawn),
-          let color = ThemeColor(hex: expected)?.nsColor,
-          let reference = try? Raster(NSView(frame: NSRect(x: 0, y: 0, width: 2, height: 2)), draw: { rect in
-              color.setFill()
-              rect.fill()
-          }).hex(at: NSPoint(x: 1, y: 1)),
-          let rhs = ThemeColor(hex: reference) else { return false }
-    return abs(Int(lhs.red) - Int(rhs.red)) <= 3
-        && abs(Int(lhs.green) - Int(rhs.green)) <= 3
-        && abs(Int(lhs.blue) - Int(rhs.blue)) <= 3
-        && abs(Int(lhs.alpha) - Int(rhs.alpha)) <= 3
-}
-
-@MainActor
-struct DataGridThemeScopeTests {
-    private func scope(_ appearance: ThemeAppearance, _ overrides: [ThemeSlot: String]) throws -> ThemeScope {
-        var theme = try ThemeTestFixture.theme(appearance, overrides)
-        theme.id = "test.grid-scope.\(UUID().uuidString)"
-        return .fixed(theme)
-    }
-
-    private func rgb(_ color: CGColor) -> String? {
-        ThemeTestFixture.hex(color).map { String($0.prefix(7)) }
-    }
-
-    /// Clear of every cell's text: the width past the last column, which the row still paints.
-    private func backgroundPoint(of rowView: NSView) -> NSPoint {
-        NSPoint(x: rowView.bounds.maxX - 6, y: rowView.bounds.midY)
-    }
-
-    // MARK: - The scope reaches every surface
-
-    @Test("A grid on a fixed scope draws that theme on its table, rows, cells, header and overlays")
-    func fixedScopeReachesEverySurface() async throws {
-        try #require(!ThemeScope.live.resolved.isOverridden(.gridBackground), "the app's theme colors the grid")
-        let scope = try scope(.light, [
-            .gridBackground: "#FDF6E3",
-            .gridText: "#112233",
-            .gridLine: "#AA0000",
-            .gridHeaderText: "#00AA00",
-        ])
-        let grid = await ScopedGrid(scope: scope)
-        defer { grid.close() }
-        let tableView = try #require(grid.tableView)
-        let coordinator = try #require(grid.coordinator)
-        let header = try #require(grid.header)
-
-        #expect(coordinator.themeScope === scope)
-        #expect(tableView.themeScope === scope)
-        #expect(header.themeScope === scope)
-        #expect(CellOverlayBase.themeScope(of: tableView) === scope)
-        #expect(ThemeTestFixture.hex(tableView.backgroundColor) == "#FDF6E3")
-        #expect(ThemeTestFixture.hex(tableView.gridColor) == "#AA0000")
-        #expect(ThemeTestFixture.hex(coordinator.cellRegistry.palette.text) == "#112233")
-        #expect(ThemeTestFixture.hex(SortableHeaderChrome.backgroundColor(scope: header.themeScope)) == "#FDF6E3")
-        #expect(!ThemeScope.live.resolved.isOverridden(.gridBackground), "the scope leaked into the app's theme")
-
-        let even = try grid.rowView(0)
-        let odd = try grid.rowView(1)
-        let evenFill = try Raster.row(even).hex(at: backgroundPoint(of: even))
-        let oddFill = try Raster.row(odd).hex(at: backgroundPoint(of: odd))
-        #expect(isNear(evenFill, "#FDF6E3"), "drew \(evenFill)")
-        #expect(isNear(oddFill, "#F3ECDA"), "a background-only theme stripes from its background, drew \(oddFill)")
-    }
-
-    @Test("A grid on the app's theme keeps the system's own colors")
-    func liveScopeIsNative() async throws {
-        try #require(!ThemeScope.live.resolved.isOverridden(.gridBackground), "the app's theme colors the grid")
-        let grid = await ScopedGrid(scope: .live)
-        defer { grid.close() }
-        let tableView = try #require(grid.tableView)
-        let coordinator = try #require(grid.coordinator)
-
-        #expect(coordinator.themeScope === ThemeScope.live)
-        #expect(tableView.backgroundColor == NSColor.controlBackgroundColor)
-        #expect(coordinator.cellRegistry.palette.text == NSColor.labelColor)
-    }
-
-    @Test("A new scope repaints the grid in place, keeping its coordinator, row views and formatted values")
-    func newScopeRepaintsInPlace() async throws {
-        let first = try scope(.light, [.gridBackground: "#FDF6E3", .gridText: "#112233"])
-        let second = try scope(.light, [.gridBackground: "#E6E7ED", .gridText: "#343B59"])
-        let grid = await ScopedGrid(scope: first)
-        defer { grid.close() }
-        let tableView = try #require(grid.tableView)
-        let coordinator = try #require(grid.coordinator)
-        let rowView = try grid.rowView(0)
-        let displayCache = coordinator.displayCache
-
-        await grid.show(scope: second)
-
-        #expect(grid.coordinator === coordinator)
-        #expect(coordinator.themeScope === second)
-        #expect(ThemeTestFixture.hex(tableView.backgroundColor) == "#E6E7ED")
-        #expect(ThemeTestFixture.hex(coordinator.cellRegistry.palette.text) == "#343B59")
-        #expect(tableView.rowView(atRow: 0, makeIfNecessary: false) === rowView, "the rows were rebuilt")
-        #expect(coordinator.displayCache === displayCache)
-        let fill = try Raster.row(rowView).hex(at: backgroundPoint(of: rowView))
-        #expect(isNear(fill, "#E6E7ED"), "drew \(fill)")
-
-        await grid.show(scope: .live)
-
-        #expect(coordinator.themeScope === ThemeScope.live)
-        #expect(tableView.backgroundColor == NSColor.controlBackgroundColor)
-        #expect(coordinator.cellRegistry.palette.text == NSColor.labelColor)
-    }
-
-    // MARK: - Derived slots, end to end
-
-    @Test("A background-only light theme stripes the rows, the gutter and the header from its own background")
-    func backgroundOnlyLightStripes() async throws {
-        try await assertBackgroundOnlyStripes(appearance: .light, name: .aqua, background: "#FDF6E3", stripe: "#F3ECDA")
-    }
-
-    @Test("A background-only dark theme stripes the rows, the gutter and the header toward white")
-    func backgroundOnlyDarkStripes() async throws {
-        try await assertBackgroundOnlyStripes(appearance: .dark, name: .darkAqua, background: "#282A36", stripe: "#31333E")
-    }
-
-    private func assertBackgroundOnlyStripes(
-        appearance: ThemeAppearance,
-        name: NSAppearance.Name,
-        background: String,
-        stripe: String
-    ) async throws {
-        let grid = await ScopedGrid(scope: try scope(appearance, [.gridBackground: background]), appearance: name)
-        defer { grid.close() }
-        let tableView = try #require(grid.tableView)
-        let gutter = try #require(grid.coordinator?.rowGutter)
-        let header = try #require(grid.header)
-        let even = try grid.rowView(2)
-        let odd = try grid.rowView(3)
-
-        let evenFill = try Raster.row(even).hex(at: backgroundPoint(of: even))
-        let oddFill = try Raster.row(odd).hex(at: backgroundPoint(of: odd))
-        #expect(isNear(evenFill, background), "drew \(evenFill)")
-        #expect(isNear(oddFill, stripe), "drew \(oddFill)")
-
-        let oddBand = gutter.convert(tableView.rect(ofRow: 3), from: tableView)
-        let gutterFill = try Raster.view(gutter).hex(at: NSPoint(x: 2, y: oddBand.midY))
-        #expect(isNear(gutterFill, stripe), "the gutter drew \(gutterFill)")
-
-        #expect(ThemeTestFixture.hex(SortableHeaderChrome.backgroundColor(scope: header.themeScope), in: name) == background)
-    }
-
-    // MARK: - Header
-
-    /// `NSTableHeaderView.draw` lays AppKit's own band over whatever is beneath it, so a header that
-    /// filled the theme's color and then let AppKit draw showed AppKit's band.
-    @Test("A theme's header background is what the grid's header shows, behind and between the headings")
-    func themedHeaderBandShows() async throws {
-        let grid = await ScopedGrid(
-            scope: try scope(.dark, [.gridHeaderBackground: "#21222C", .gridHeaderText: "#F8F8F2"]),
-            appearance: .darkAqua
-        )
-        defer { grid.close() }
-        let coordinator = try #require(grid.coordinator)
-        let header = try #require(grid.header)
-        let column = try #require(coordinator.tableColumnIndex(forDisplayPosition: 1))
-        let heading = header.headerRect(ofColumn: column)
-        let raster = try Raster.view(header)
-        let behind = try raster.hex(at: NSPoint(x: heading.minX + 3, y: heading.minY + 3))
-        let past = try raster.hex(at: NSPoint(x: header.bounds.maxX - 4, y: header.bounds.minY + 3))
-
-        #expect(isNear(behind, "#21222C"), "behind a heading drew \(behind)")
-        #expect(isNear(past, "#21222C"), "past the headings drew \(past)")
-    }
-
-    // MARK: - Selection text, end to end
-
-    /// The rows' text is the dark ink of the theme's text, never AppKit's white selection text.
-    @Test("A theme that sets the selection but not its text draws the theme's text on the selection")
-    func selectionWithoutTextTakesTheGridText() async throws {
-        let grid = await ScopedGrid(scope: try scope(.light, [.gridSelection: "#EEE8D5", .gridText: "#112233"]))
-        defer { grid.close() }
-        let tableView = try #require(grid.tableView)
-        let coordinator = try #require(grid.coordinator)
-        let header = try #require(grid.header)
-        tableView.selectRowIndexes(IndexSet(integer: 1), byExtendingSelection: false)
-        let rowView = try grid.rowView(1)
-        rowView.isEmphasized = true
-
-        let cell = try #require(coordinator.cellAppearance(row: 1, columnIndex: 0, onEmphasizedSelection: true))
-        #expect(ThemeTestFixture.hex(cell.textColor) == "#112233")
-        #expect(ThemeTestFixture.hex(coordinator.cellRegistry.palette.rowNumberColor(for: .empty, onEmphasizedSelection: true)) == "#112233")
-        let heading = SortableHeaderCell(textCell: "name")
-        #expect(ThemeTestFixture.hex(heading.foregroundColor(emphasized: true, scope: header.themeScope)) == "#112233")
-
-        let raster = try Raster.row(rowView)
-        let fill = try raster.hex(at: backgroundPoint(of: rowView))
-        #expect(isNear(fill, "#EEE8D5"), "drew \(fill)")
-        let selectionLuminance = try #require(ThemeColor(hex: fill)).relativeLuminance
-        let firstCell = rowView.convert(tableView.rect(ofColumn: try #require(coordinator.tableColumnIndex(forDisplayPosition: 0))), from: tableView)
-        let range = try raster.luminanceRange(in: firstCell.intersection(rowView.bounds).insetBy(dx: 2, dy: 2))
-        #expect(range.upperBound <= selectionLuminance + 0.03, "a pixel lighter than the selection is white text: \(range)")
-        #expect(range.lowerBound < 0.2, "the cell drew no dark text: \(range)")
-    }
-
-    @Test("A selection text with no themed selection leaves AppKit's own selection and its white text")
-    func selectionTextAloneStaysNative() async throws {
-        let grid = await ScopedGrid(scope: try scope(.light, [.gridSelectionText: "#00FF00", .gridText: "#112233"]))
-        defer { grid.close() }
-        let coordinator = try #require(grid.coordinator)
-
-        let cell = try #require(coordinator.cellAppearance(row: 0, columnIndex: 0, onEmphasizedSelection: true))
-        #expect(cell.textColor === NSColor.alternateSelectedControlTextColor)
-        #expect(DataGridBodyChrome.themedSelectionColor(emphasized: true, scope: coordinator.themeScope) == nil)
-    }
-
-    // MARK: - Translucent selection
-
-    /// The row used to replace its stripe with the translucent color, the heading replaced the
-    /// header's band, and the gutter blended over the stripe: three colors for one selection.
-    @Test("A translucent selection draws one color on the row, the gutter and a selected heading")
-    func translucentSelectionAgrees() async throws {
-        let scope = try scope(.dark, [
-            .gridBackground: "#282A36",
-            .gridAlternateRow: "#21222C",
-            .gridHeaderBackground: "#21222C",
-            .gridInactiveSelection: "#44475A80",
-        ])
-        let selection = try #require(ThemeColor(hex: "#44475A80"))
-        let expected = selection.composited(over: try #require(ThemeColor(hex: "#282A36"))).hex
-        let grid = await ScopedGrid(scope: scope, appearance: .darkAqua)
-        defer { grid.close() }
-        let tableView = try #require(grid.tableView)
-        let coordinator = try #require(grid.coordinator)
-        let gutter = try #require(coordinator.rowGutter)
-        let header = try #require(grid.header)
-        tableView.selectRowIndexes(IndexSet(integer: 1), byExtendingSelection: false)
-        let rowView = try grid.rowView(1)
-        rowView.isEmphasized = false
-
-        let fill = try #require(DataGridBodyChrome.themedSelectionColor(emphasized: false, scope: scope))
-        #expect(ThemeTestFixture.hex(fill, in: .darkAqua) == expected)
-        #expect(fill.alphaComponent == 1)
-
-        let row = try Raster.row(rowView).hex(at: backgroundPoint(of: rowView))
-        #expect(isNear(row, expected), "the row drew \(row), expected \(expected)")
-
-        let band = gutter.convert(tableView.rect(ofRow: 1), from: tableView)
-        let strip = try Raster.view(gutter).hex(at: NSPoint(x: 2, y: band.midY))
-        #expect(isNear(strip, expected), "the gutter drew \(strip), expected \(expected)")
-
-        let column = try #require(coordinator.tableColumnIndex(forDisplayPosition: 0))
-        let cell = try #require(tableView.tableColumns[column].headerCell as? SortableHeaderCell)
-        cell.isColumnSelected = true
-        cell.isEmphasized = false
-        defer { cell.isColumnSelected = false }
-        let heading = header.headerRect(ofColumn: column)
-        let headingFill = try Raster.view(header).hex(at: NSPoint(x: heading.minX + 3, y: heading.minY + 3))
-        #expect(isNear(headingFill, expected), "the heading drew \(headingFill), expected \(expected)")
-    }
-
-    // MARK: - Range outline
-
-    @Test("Under the default theme a cell range keeps the selection at 70% as its outline")
-    func defaultRangeBorderIsNative() throws {
-        let aqua = try #require(NSAppearance(named: .aqua))
-        let resolved = ThemeScope.fixed(BuiltInThemes.light).resolved
-        let drawn = ThemeTestFixture.baked(GridSelectionOverlay.rangeBorderColor(resolved), in: aqua)
-        let native = ThemeTestFixture.resolved(in: aqua) {
-            NSColor.selectedContentBackgroundColor.withAlphaComponent(0.7).cgColor
-        }
-
-        #expect(ThemeTestFixture.hex(drawn) == ThemeTestFixture.hex(native))
-        #expect(abs(drawn.alpha - 0.7) < 0.001)
-    }
-
-    /// The theme's selection fills the range opaque, so the selection itself at 70% drew no edge.
-    @Test("Under a theme's selection the range outline is the active cell's border and stands apart from the fill")
-    func themedRangeBorderStandsApart() throws {
-        let aqua = try #require(NSAppearance(named: .aqua))
-        let withFocus = try scope(.dark, [.gridSelection: "#44475A", .gridFocusBorder: "#BD93F9"]).resolved
-        let border = ThemeTestFixture.baked(GridSelectionOverlay.rangeBorderColor(withFocus), in: aqua)
-        #expect(rgb(border) == "#BD93F9")
-        #expect(abs(border.alpha - 0.7) < 0.001)
-
-        let fill = try #require(ThemeColor(hex: "#44475A"))
-        let stroke = try #require(ThemeColor(hex: "#BD93F9B3")).composited(over: fill)
-        #expect(stroke.contrastRatio(with: fill) > 2)
-
-        let withoutFocus = try scope(.dark, [.gridSelection: "#44475A"]).resolved
-        let accent = ThemeTestFixture.baked(GridSelectionOverlay.rangeBorderColor(withoutFocus), in: aqua)
-        #expect(rgb(accent) == rgb(ThemeTestFixture.baked(.controlAccentColor, in: aqua)))
-    }
-
-    // MARK: - Accessory glyphs
-
-    @Test("An accessory glyph is drawn again for another color, and reused for the same one")
-    func accessoryGlyphFollowsItsColor() throws {
-        let red = NSColor(srgbRed: 1, green: 0, blue: 0, alpha: 1)
-        let blue = NSColor(srgbRed: 0, green: 0, blue: 1, alpha: 1)
-
-        let first = try #require(DataGridCellAccessoryGlyph.image(for: .foreignKeyEmphasized, color: red))
-        let again = try #require(DataGridCellAccessoryGlyph.image(for: .foreignKeyEmphasized, color: red))
-        let other = try #require(DataGridCellAccessoryGlyph.image(for: .foreignKeyEmphasized, color: blue))
-
-        #expect(first.image === again.image)
-        #expect(other.image !== first.image)
-    }
-
-    @Test("An emphasized accessory takes the paired selection text, a plain one the secondary label")
-    func accessoryColorFollowsTheSelectionPair() throws {
-        let aqua = try #require(NSAppearance(named: .aqua))
-        let scope = try scope(.light, [.gridSelection: "#EEE8D5", .gridText: "#112233"])
-        let palette = scope.dataGridCellPalette(in: aqua)
-        func appearance(emphasized: Bool) -> DataGridCellAppearance {
-            DataGridCellAppearance.resolve(
-                kind: .foreignKey,
-                content: DataGridCellContent(displayText: "7", rawValue: "7", placeholder: nil),
-                state: DataGridCellState(
-                    visualState: .empty,
-                    isFocused: false,
-                    isEditable: true,
-                    isLargeDataset: false,
-                    isCurrentFindMatch: false,
-                    row: 0,
-                    columnIndex: 0
-                ),
-                palette: palette,
-                nullDisplayString: "NULL",
-                onEmphasizedSelection: emphasized,
-                hasOverlay: false
-            )
-        }
-
-        #expect(ThemeTestFixture.hex(appearance(emphasized: true).accessoryColor) == "#112233")
-        #expect(appearance(emphasized: false).accessoryColor === NSColor.secondaryLabelColor)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridTrailingSpaceTests.swift b/apple/TableProTests/Views/Results/DataGridTrailingSpaceTests.swift
deleted file mode 100644
index 1c000f6a1f..0000000000
--- a/apple/TableProTests/Views/Results/DataGridTrailingSpaceTests.swift
+++ /dev/null
@@ -1,388 +0,0 @@
-//
-//  DataGridTrailingSpaceTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class TrailingSpaceLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// AppKit sizes the table to its columns, so scrolled fully right the last column's divider sat on the
-/// viewport's last point, where a resizable window takes the press for its own edge resize. Revealing
-/// the last column from the keyboard, Find or Jump to Column put the divider back there.
-@MainActor
-struct DataGridTrailingSpaceTests {
-    @MainActor
-    private struct Grid {
-        let window: NSWindow
-        let scrollView: NSScrollView
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-        let header: SortableHeaderView
-
-        var clipView: NSClipView { scrollView.contentView }
-
-        var bodyTrailingGap: CGFloat? {
-            guard let last = coordinator.lastPresentedColumnIndex() else { return nil }
-            let column = clipView.convert(tableView.rect(ofColumn: last), from: tableView)
-            return clipView.bounds.maxX - column.maxX
-        }
-
-        var headerTrailingGap: CGFloat? {
-            guard let last = coordinator.lastPresentedColumnIndex(),
-                  let headerClip = header.superview as? NSClipView else { return nil }
-            let heading = headerClip.convert(header.headerRect(ofColumn: last), from: header)
-            return headerClip.bounds.maxX - heading.maxX
-        }
-
-        var documentTrailingRoom: CGFloat? {
-            guard let last = coordinator.lastPresentedColumnIndex() else { return nil }
-            return tableView.bounds.maxX - tableView.rect(ofColumn: last).maxX
-        }
-
-        func layout() {
-            scrollView.tile()
-            window.layoutIfNeeded()
-        }
-
-        func scrollFarRight() {
-            tableView.scroll(NSPoint(x: .greatestFiniteMagnitude, y: clipView.bounds.minY))
-            layout()
-        }
-
-        func scrollToLeadingEdge() {
-            tableView.scroll(NSPoint(x: 0, y: clipView.bounds.minY))
-            layout()
-        }
-    }
-
-    private static func tableRows(columnCount: Int) -> TableRows {
-        let columns = (0 ..< columnCount).map { "c\($0)" }
-        let queryRows = (0 ..< 3).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } }
-        return TableRows.from(
-            queryRows: queryRows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columnCount)
-        )
-    }
-
-    private static func present(
-        _ tableRows: TableRows,
-        in tableView: NSTableView,
-        coordinator: TableViewCoordinator,
-        hidden: Set<String> = [],
-        columnWidth: CGFloat = 150
-    ) {
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: tableRows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: hidden,
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in columnWidth }
-        )
-    }
-
-    private func makeGrid(
-        columnCount: Int = 12,
-        columnWidth: CGFloat = 150,
-        viewportWidth: CGFloat = 800,
-        hidden: Set<String> = []
-    ) -> Grid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: TrailingSpaceLayoutPersister()
-        )
-
-        let tableView = KeyHandlingTableView()
-        tableView.style = .plain
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.gridStyleMask = []
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.rowHeight = 24
-        tableView.usesAutomaticRowHeights = false
-        tableView.allowsColumnResizing = true
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-
-        let header = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: viewportWidth, height: 28))
-        header.coordinator = coordinator
-        tableView.headerView = header
-
-        Self.present(
-            Self.tableRows(columnCount: columnCount),
-            in: tableView,
-            coordinator: coordinator,
-            hidden: hidden,
-            columnWidth: columnWidth
-        )
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: viewportWidth, height: 240))
-        scrollView.hasVerticalScroller = true
-        scrollView.hasHorizontalScroller = true
-        scrollView.autohidesScrollers = true
-        scrollView.borderType = .noBorder
-        /// A legacy scroller narrows the clip view, and which style applies is a per-machine setting.
-        scrollView.scrollerStyle = .overlay
-        scrollView.documentView = tableView
-
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: viewportWidth, height: 240),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.contentView = scrollView
-
-        tableView.reloadData()
-        let grid = Grid(
-            window: window,
-            scrollView: scrollView,
-            tableView: tableView,
-            coordinator: coordinator,
-            header: header
-        )
-        grid.layout()
-        return grid
-    }
-
-    // MARK: - Scrolled fully right
-
-    @Test("Scrolled fully right, the body and the header end the trailing space past the last column")
-    func farRightShowsTheTrailingSpace() throws {
-        let grid = makeGrid()
-
-        grid.scrollFarRight()
-
-        try #require(grid.clipView.bounds.minX > 0)
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-    }
-
-    /// An inset on the clip view scrolls just as far, but leaves the space outside the table and the
-    /// header, where no row paints its stripe, selection or tint and no heading paints its chrome.
-    @Test("The trailing space is part of the table and the header, not a clip view inset")
-    func trailingSpaceIsCoveredByTheTableAndHeader() throws {
-        let grid = makeGrid()
-
-        grid.scrollFarRight()
-
-        let headerClip = try #require(grid.header.superview as? NSClipView)
-        #expect(grid.documentTrailingRoom == DataGridMetrics.trailingSpace)
-        #expect(grid.tableView.frame.maxX == grid.clipView.bounds.maxX)
-        #expect(grid.header.frame.maxX == headerClip.bounds.maxX)
-    }
-
-    /// AppKit resizes a column from 3pt before its trailing edge to 1pt after it. Flush with the
-    /// viewport, only the points before the edge were on screen, and the window's edge resize claims
-    /// the last of them.
-    @Test("Scrolled fully right, the last column's whole resize band is inside the header")
-    func lastDividerResizeBandIsInsideTheHeader() throws {
-        let grid = makeGrid()
-        grid.scrollFarRight()
-        let last = try #require(grid.coordinator.lastPresentedColumnIndex())
-        let edge = grid.header.headerRect(ofColumn: last).maxX
-        let visible = grid.header.visibleRect
-
-        let divider = NSPoint(x: edge - 1, y: visible.midY)
-        #expect(visible.contains(divider))
-        #expect(grid.header.isInResizeZone(point: divider))
-        for offset: CGFloat in [-3, -2, -1, 0, 1] {
-            let point = NSPoint(x: edge + offset, y: visible.midY)
-            #expect(visible.contains(point), "\(offset)pt from the last column's trailing edge")
-            #expect(grid.header.isInResizeZone(point: point), "\(offset)pt from the last column's trailing edge")
-        }
-        #expect(visible.maxX - edge == DataGridMetrics.trailingSpace)
-    }
-
-    // MARK: - Holding through changes
-
-    @Test("The trailing space survives a reload without moving the viewport")
-    func trailingSpaceSurvivesReload() {
-        let grid = makeGrid()
-        grid.scrollFarRight()
-
-        grid.tableView.reloadData()
-        grid.layout()
-
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-    }
-
-    /// Measured off-screen on macOS 27, the content clip keeps its old origin after the document
-    /// narrows until something scrolls it, while the header clip is clamped at once. Scrolling again
-    /// measures the room the reader can reach.
-    @Test("The trailing space follows the last column as it widens and narrows")
-    func trailingSpaceFollowsTheLastColumnWidth() throws {
-        let grid = makeGrid()
-        let last = try #require(grid.coordinator.lastPresentedColumnIndex())
-        let column = grid.tableView.tableColumns[last]
-        grid.scrollFarRight()
-
-        column.width += 60
-        grid.layout()
-        grid.scrollFarRight()
-
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-
-        column.width -= 120
-        grid.layout()
-        grid.scrollFarRight()
-
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-    }
-
-    @Test("The trailing space survives the viewport growing wider")
-    func trailingSpaceSurvivesAWiderViewport() throws {
-        let grid = makeGrid(viewportWidth: 800)
-        grid.scrollFarRight()
-
-        grid.window.setContentSize(NSSize(width: 1_100, height: 240))
-        grid.layout()
-
-        try #require(grid.clipView.bounds.width > 800)
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-    }
-
-    /// The pool keeps a wider result's surplus slots attached and hidden after the presented columns,
-    /// so the last attached column is not the last one the reader sees, and a hidden column's rect is
-    /// zero.
-    @Test("After a narrower result, the trailing space follows its last presented column")
-    func trailingSpaceFollowsANarrowerResult() throws {
-        let grid = makeGrid(columnCount: 12)
-        grid.scrollFarRight()
-
-        Self.present(Self.tableRows(columnCount: 8), in: grid.tableView, coordinator: grid.coordinator)
-        grid.tableView.reloadData()
-        grid.layout()
-        grid.scrollFarRight()
-
-        let lastAttached = try #require(grid.tableView.tableColumns.last)
-        try #require(!grid.coordinator.presentsColumn(lastAttached))
-        let lastSlot = grid.tableView.column(withIdentifier: ColumnIdentitySchema.slotIdentifier(7))
-        #expect(grid.coordinator.lastPresentedColumnIndex() == lastSlot)
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-    }
-
-    @Test("Columns the user hid at the end leave the trailing space after the last shown column")
-    func userHiddenTrailingColumnsMeasureFromTheLastShownColumn() throws {
-        let grid = makeGrid(columnCount: 12, hidden: ["c10", "c11"])
-        let last = try #require(grid.coordinator.lastPresentedColumnIndex())
-        #expect(last == grid.tableView.column(withIdentifier: ColumnIdentitySchema.slotIdentifier(9)))
-
-        grid.scrollFarRight()
-
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-    }
-
-    // MARK: - Revealing a column
-
-    @Test("Revealing the last column shows the trailing space and stays put when repeated")
-    func revealingTheLastColumnShowsTheTrailingSpace() throws {
-        let grid = makeGrid()
-        let last = try #require(grid.coordinator.lastPresentedColumnIndex())
-        try #require(grid.clipView.bounds.minX == 0)
-
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: last)
-        grid.layout()
-
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-
-        /// Every arrow key press on the last column reveals it again, so a correction that fought
-        /// AppKit would move the viewport on each press.
-        let settled = grid.clipView.bounds
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: last)
-        grid.layout()
-
-        #expect(grid.clipView.bounds == settled)
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-    }
-
-    /// The trailing space exists after the last column only. A middle column revealed short of the
-    /// edge would land unlike every other reveal AppKit makes.
-    @Test("Revealing a column before the last one stops where AppKit puts it")
-    func revealingAMiddleColumnKeepsAppKitPlacement() throws {
-        let grid = makeGrid()
-        let last = try #require(grid.coordinator.lastPresentedColumnIndex())
-        try #require(grid.documentTrailingRoom == DataGridMetrics.trailingSpace)
-        let middle = last - 4
-        try #require(grid.coordinator.presentsColumn(atTableColumnIndex: middle))
-        try #require(grid.tableView.rect(ofColumn: middle).minX > grid.clipView.bounds.maxX)
-
-        grid.tableView.scrollColumnToVisible(middle)
-        grid.layout()
-        let appKitPlacement = grid.clipView.bounds
-        grid.scrollToLeadingEdge()
-
-        grid.coordinator.scrollColumnToVisible(tableColumnIndex: middle)
-        grid.layout()
-
-        let visible = grid.clipView.bounds
-        let column = grid.tableView.rect(ofColumn: middle)
-        #expect(visible == appKitPlacement)
-        #expect(column.maxX <= visible.maxX)
-        #expect(column.minX >= visible.minX + DataGridRowGutterView.width(of: grid.tableView))
-    }
-
-    // MARK: - Columns that fit
-
-    @Test("Columns that fit with the trailing space to spare leave the grid unscrollable")
-    func columnsWithRoomToSpareDoNotScroll() throws {
-        let grid = makeGrid(columnCount: 3, columnWidth: 120, viewportWidth: 900)
-        let last = try #require(grid.coordinator.lastPresentedColumnIndex())
-        let spare = grid.clipView.bounds.width - grid.tableView.rect(ofColumn: last).maxX
-        try #require(spare >= DataGridMetrics.trailingSpace)
-
-        #expect(grid.tableView.frame.width == grid.clipView.bounds.width)
-
-        grid.scrollFarRight()
-
-        #expect(grid.clipView.bounds.minX == 0)
-    }
-
-    /// One rule for every width: a run that ends just short of the viewport would otherwise leave its
-    /// last divider at the window's edge with nothing to scroll.
-    @Test("Columns that end inside the trailing space scroll just far enough to show it")
-    func columnsEndingNearTheEdgeScrollToTheTrailingSpace() throws {
-        let grid = makeGrid(columnCount: 3, columnWidth: 120, viewportWidth: 900)
-        let last = try #require(grid.coordinator.lastPresentedColumnIndex())
-        let spare = grid.clipView.bounds.width - grid.tableView.rect(ofColumn: last).maxX
-        grid.tableView.tableColumns[last].width += spare - 10
-        grid.layout()
-        try #require(grid.clipView.bounds.width - grid.tableView.rect(ofColumn: last).maxX == 10)
-
-        grid.scrollFarRight()
-
-        #expect(grid.clipView.bounds.minX == DataGridMetrics.trailingSpace - 10)
-        #expect(grid.bodyTrailingGap == DataGridMetrics.trailingSpace)
-        #expect(grid.headerTrailingGap == DataGridMetrics.trailingSpace)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridUpdateSnapshotTests.swift b/apple/TableProTests/Views/Results/DataGridUpdateSnapshotTests.swift
deleted file mode 100644
index 5bfe4cc041..0000000000
--- a/apple/TableProTests/Views/Results/DataGridUpdateSnapshotTests.swift
+++ /dev/null
@@ -1,122 +0,0 @@
-//
-//  DataGridUpdateSnapshotTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Testing
-
-@testable import TablePro
-
-struct DataGridUpdateSnapshotTests {
-    private func makeSnapshot(
-        rowDisplayCount: Int = 3,
-        columns: [String] = ["name", "type"],
-        reloadVersion: Int = 0,
-        contentRevision: Int = 0,
-        displayFormats: [ValueDisplayFormat?] = [],
-        highlightRules: [HighlightRule] = [],
-        columnComments: [String: String] = [:]
-    ) -> DataGridUpdateSnapshot {
-        DataGridUpdateSnapshot(
-            rowDisplayCount: rowDisplayCount,
-            columnCount: columns.count,
-            columns: columns,
-            valueFilteredIDsCount: nil,
-            displayFormats: displayFormats,
-            highlightRules: highlightRules,
-            configuration: DataGridConfiguration(),
-            isEditable: true,
-            rowReorder: .disabled,
-            rowHeight: 24,
-            alternatingRows: true,
-            reloadVersion: reloadVersion,
-            contentRevision: contentRevision,
-            columnComments: columnComments
-        )
-    }
-
-    @Test("A filter/sort change at the same row count still changes the snapshot")
-    func contentRevisionBumpChangesSnapshot() {
-        let before = makeSnapshot(rowDisplayCount: 3, contentRevision: 0)
-        let after = makeSnapshot(rowDisplayCount: 3, contentRevision: 1)
-        #expect(before != after)
-    }
-
-    @Test("Nothing changing leaves the snapshot equal so the grid does not reload")
-    func identicalSnapshotsAreEqual() {
-        let first = makeSnapshot()
-        let second = makeSnapshot()
-        #expect(first == second)
-    }
-
-    @Test("contentRevision is independent of reloadVersion and row count")
-    func contentRevisionIsIndependentSignal() {
-        let base = makeSnapshot(rowDisplayCount: 5, reloadVersion: 2, contentRevision: 4)
-        #expect(base != makeSnapshot(rowDisplayCount: 5, reloadVersion: 2, contentRevision: 5))
-        #expect(base != makeSnapshot(rowDisplayCount: 6, reloadVersion: 2, contentRevision: 4))
-        #expect(base != makeSnapshot(rowDisplayCount: 5, reloadVersion: 3, contentRevision: 4))
-    }
-
-    @Test("Column comments arriving after the rows still change the snapshot")
-    func columnCommentsArrivingLaterChangeSnapshot() {
-        let beforeMetadata = makeSnapshot(columnComments: [:])
-        let afterMetadata = makeSnapshot(columnComments: ["name": "Display name"])
-        #expect(beforeMetadata != afterMetadata)
-    }
-
-    @Test("An edited column comment changes the snapshot at the same row and column count")
-    func editedColumnCommentChangesSnapshot() {
-        let before = makeSnapshot(columnComments: ["name": "Display name"])
-        let after = makeSnapshot(columnComments: ["name": "Full name"])
-        #expect(before != after)
-    }
-
-    @Test("Display format changes invalidate the update snapshot")
-    func displayFormatChangesSnapshot() {
-        let raw = makeSnapshot(displayFormats: [.raw])
-        let uuid = makeSnapshot(displayFormats: [.uuid])
-
-        #expect(raw != uuid)
-    }
-
-    @Test("A highlight rule change invalidates the update snapshot")
-    func highlightRuleChangesSnapshot() {
-        let rule = HighlightRule(columnName: "type", value: "admin", color: .green)
-        var recolored = rule
-        recolored.color = .red
-
-        let highlighted = makeSnapshot(highlightRules: [rule])
-        let rebuilt = makeSnapshot(highlightRules: [rule])
-
-        #expect(makeSnapshot() != highlighted)
-        #expect(highlighted != makeSnapshot(highlightRules: [recolored]))
-        #expect(highlighted == rebuilt)
-    }
-
-    @Test("Display format cache entries are scoped to a pinned result set")
-    func displayFormatCacheUsesResultSetIdentity() {
-        let firstResult = UUID()
-        let secondResult = UUID()
-        let entry = DisplayFormatsCacheEntry(
-            schemaVersion: 4,
-            resultSetId: firstResult,
-            smartDetectionEnabled: true,
-            overridesVersion: 2,
-            formats: [.uuid]
-        )
-
-        #expect(entry.matches(
-            schemaVersion: 4,
-            resultSetId: firstResult,
-            smartDetectionEnabled: true,
-            overridesVersion: 2
-        ))
-        #expect(!entry.matches(
-            schemaVersion: 4,
-            resultSetId: secondResult,
-            smartDetectionEnabled: true,
-            overridesVersion: 2
-        ))
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridViewportPlacementTests.swift b/apple/TableProTests/Views/Results/DataGridViewportPlacementTests.swift
deleted file mode 100644
index fad613d16f..0000000000
--- a/apple/TableProTests/Views/Results/DataGridViewportPlacementTests.swift
+++ /dev/null
@@ -1,201 +0,0 @@
-//
-//  DataGridViewportPlacementTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class NoopViewportLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct DataGridViewportPlacementTests {
-    private struct Grid {
-        let window: NSWindow
-        let scrollView: NSScrollView
-        let tableView: KeyHandlingTableView
-        let coordinator: TableViewCoordinator
-
-        var headerInset: CGFloat { scrollView.contentView.contentInsets.top }
-    }
-
-    private static let rowCount = 300
-
-    private static func rows() -> TableRows {
-        TableRows.from(
-            queryRows: (0 ..< rowCount).map { [.text("\($0)"), .text("name-\($0)")] },
-            columns: ["id", "name"],
-            columnTypes: [.text(rawType: "INTEGER"), .text(rawType: "TEXT")]
-        )
-    }
-
-    private func makeGrid() -> Grid {
-        let tableRows = Self.rows()
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopViewportLayoutPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 900, height: 300))
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: tableRows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 400 }
-        )
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 300, height: 300))
-        scrollView.hasVerticalScroller = true
-        scrollView.hasHorizontalScroller = true
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 300, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.contentView = scrollView
-        tableView.reloadData()
-        window.layoutIfNeeded()
-        return Grid(window: window, scrollView: scrollView, tableView: tableView, coordinator: coordinator)
-    }
-
-    private func scroll(_ grid: Grid, toRow row: Int, offset: CGFloat = 0, horizontal: CGFloat = 0) {
-        let rowOrigin = grid.tableView.rect(ofRow: row).minY
-        grid.tableView.scroll(NSPoint(x: horizontal, y: rowOrigin + offset - grid.headerInset))
-    }
-
-    @Test("The grid under test carries the header inset AppKit puts on the clip view")
-    func harnessHasAHeaderInset() {
-        let grid = makeGrid()
-
-        #expect(grid.tableView.headerView != nil)
-        #expect(grid.headerInset > 0)
-    }
-
-    @Test("The sample names the first row the header does not cover and how far it is scrolled past")
-    func sampleReadsTheFirstVisibleRow() throws {
-        let grid = makeGrid()
-        scroll(grid, toRow: 50, offset: 5)
-
-        let sample = try #require(grid.coordinator.viewportSample())
-
-        #expect(sample.firstVisibleRow == 50)
-        #expect(sample.offset == 5)
-    }
-
-    @Test("The first row placement puts row 0 below the header and keeps the horizontal position")
-    func firstRowSitsBelowTheHeader() throws {
-        let grid = makeGrid()
-        scroll(grid, toRow: 80, horizontal: 120)
-        let horizontal = grid.scrollView.contentView.bounds.origin.x
-        #expect(horizontal > 0)
-
-        grid.coordinator.applyViewportPlacement(.firstRow)
-
-        #expect(grid.scrollView.contentView.bounds.origin.y == -grid.headerInset)
-        #expect(try #require(grid.coordinator.viewportSample()).firstVisibleRow == 0)
-        #expect(grid.scrollView.contentView.bounds.origin.x == horizontal)
-    }
-
-    @Test("An anchored placement puts its row back where the reader had it")
-    func anchoredPlacementRestoresTheRowAndOffset() throws {
-        let grid = makeGrid()
-
-        grid.coordinator.applyViewportPlacement(
-            GridViewportPlacement(
-                firstVisibleRow: .existing(120),
-                firstVisibleOffset: 4,
-                selectedRows: [],
-                revealsSelection: false
-            )
-        )
-
-        let sample = try #require(grid.coordinator.viewportSample())
-        #expect(sample.firstVisibleRow == 120)
-        #expect(sample.offset == 4)
-    }
-
-    @Test("A taller inset, as a header with column comments has, is honoured the same way")
-    func tallerInsetIsHonoured() throws {
-        let grid = makeGrid()
-        grid.scrollView.automaticallyAdjustsContentInsets = false
-        grid.scrollView.contentInsets = NSEdgeInsets(top: 14, left: 0, bottom: 0, right: 0)
-        grid.window.layoutIfNeeded()
-        let inset = grid.headerInset
-        #expect(inset > 0)
-
-        grid.coordinator.applyViewportPlacement(
-            GridViewportPlacement(firstVisibleRow: .existing(60), firstVisibleOffset: 0, selectedRows: [], revealsSelection: false)
-        )
-        #expect(try #require(grid.coordinator.viewportSample()).firstVisibleRow == 60)
-
-        grid.coordinator.applyViewportPlacement(.firstRow)
-        #expect(grid.scrollView.contentView.bounds.origin.y == -inset)
-    }
-
-    @Test("A revealed row is selected and scrolled into view")
-    func revealedRowIsSelectedAndVisible() {
-        let grid = makeGrid()
-
-        grid.coordinator.applyViewportPlacement(
-            GridViewportPlacement(firstVisibleRow: nil, firstVisibleOffset: 0, selectedRows: [.existing(250)], revealsSelection: true)
-        )
-
-        #expect(grid.tableView.selectedRowIndexes == IndexSet(integer: 250))
-        #expect(NSLocationInRange(250, grid.tableView.rows(in: grid.tableView.visibleRect)))
-    }
-
-    @Test("Reselecting by row identity puts back a selection a reload dropped")
-    func reselectRestoresTheSelectionAfterAReload() {
-        let grid = makeGrid()
-        grid.coordinator.selectRowsProgrammatically(IndexSet([3, 7]), in: grid.tableView)
-        let kept = grid.coordinator.selectedRowIDs()
-
-        grid.tableView.reloadData()
-        #expect(grid.tableView.selectedRowIndexes.isEmpty)
-
-        grid.coordinator.reselectRows(kept)
-        #expect(grid.tableView.selectedRowIndexes == IndexSet([3, 7]))
-    }
-
-    @Test("Replacing the rows closes an inline editor instead of leaving it over another record")
-    func fullReplaceDismissesTheInlineEditor() {
-        let grid = makeGrid()
-        let editor = CellOverlayEditor()
-        grid.coordinator.overlayEditor = editor
-        editor.show(in: grid.tableView, row: 0, column: 1, columnIndex: 0, value: "0")
-        #expect(editor.isActive)
-
-        grid.coordinator.applyFullReplace()
-
-        #expect(!editor.isActive)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DataGridZoomCommandTests.swift b/apple/TableProTests/Views/Results/DataGridZoomCommandTests.swift
deleted file mode 100644
index 019d4cc92c..0000000000
--- a/apple/TableProTests/Views/Results/DataGridZoomCommandTests.swift
+++ /dev/null
@@ -1,292 +0,0 @@
-//
-//  DataGridZoomCommandTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import TableProTestSupport
-import Testing
-
-@MainActor
-private final class ZoomLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-// Stands in for the connection window, whose controller zooms the editor when nothing nearer does.
-@MainActor
-private final class WindowZoomFallback: NSViewController, ZoomCommandResponding {
-    @objc func zoomIn(_ sender: Any?) {}
-    @objc func zoomOut(_ sender: Any?) {}
-}
-
-@MainActor
-private final class MountedGrid {
-    let window: NSWindow
-    private let host: NSHostingView<DataGridView>
-
-    init(rowCount: Int = 2) async {
-        let rows = TableRows.from(
-            queryRows: (0 ..< rowCount).map { [PluginCellValue.text("value \($0)")] },
-            columns: ["name"],
-            columnTypes: [ColumnType.text(rawType: "TEXT")]
-        )
-        host = NSHostingView(rootView: DataGridView(
-            tableRowsProvider: { rows },
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            configuration: DataGridConfiguration(tabType: .query),
-            layoutPersister: ZoomLayoutPersister(),
-            selectedRowIndices: .constant([]),
-            sortState: .constant(SortState()),
-            columnLayout: .constant(ColumnLayoutState())
-        ))
-        let fallback = WindowZoomFallback()
-        fallback.view = host
-        window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.isReleasedWhenClosed = false
-        window.contentViewController = fallback
-        // A content view controller sizes the window to its view's fitting size, which for a grid is tiny.
-        window.setContentSize(NSSize(width: 600, height: 300))
-        await settle()
-    }
-
-    var tableView: KeyHandlingTableView? {
-        Self.first(KeyHandlingTableView.self, in: host)
-    }
-
-    var scrollView: DataGridScrollView? {
-        tableView?.enclosingScrollView as? DataGridScrollView
-    }
-
-    func close() {
-        window.orderOut(nil)
-    }
-
-    func scroll(toRow row: Int) {
-        guard let tableView else { return }
-        let inset = tableView.enclosingScrollView?.contentView.contentInsets.top ?? 0
-        tableView.scroll(NSPoint(x: 0, y: tableView.rect(ofRow: row).minY - inset))
-    }
-
-    // SwiftUI applies a change on a later run-loop turn, so each pass lays out and waits for one.
-    private func settle() async {
-        for _ in 0 ..< 10 {
-            host.layoutSubtreeIfNeeded()
-            await withCheckedContinuation { continuation in
-                DispatchQueue.main.async { continuation.resume() }
-            }
-        }
-    }
-
-    private static func first<View: NSView>(_ type: View.Type, in view: NSView) -> View? {
-        if let match = view as? View { return match }
-        for subview in view.subviews {
-            if let found = first(type, in: subview) { return found }
-        }
-        return nil
-    }
-}
-
-@MainActor
-private func zoomResponder(from responder: NSResponder?) -> NSResponder? {
-    var responder = responder
-    while let current = responder, !current.responds(to: #selector(ZoomCommandResponding.zoomIn(_:))) {
-        responder = current.nextResponder
-    }
-    return responder
-}
-
-@MainActor
-private func item(_ action: Selector) -> NSMenuItem {
-    NSMenuItem(title: "", action: action, keyEquivalent: "")
-}
-
-extension GlobalStateSuites {
-    @Suite(.appSettings {
-        $0.typography = TypographySettings(editorFontSize: 13, dataGridFontSize: 13)
-        $0.dataGrid.rowHeight = .normal
-    })
-    @MainActor
-    struct DataGridZoomCommandTests {
-        @Test("From a focused grid the command reaches the grid's scroll view before the window")
-        func focusedGridClaimsTheCommand() async throws {
-            let grid = await MountedGrid()
-            defer { grid.close() }
-            let tableView = try #require(grid.tableView)
-            let scrollView = try #require(grid.scrollView)
-
-            #expect(grid.window.makeFirstResponder(tableView))
-
-            #expect(zoomResponder(from: grid.window.firstResponder) === scrollView)
-        }
-
-        @Test("From a cell being edited the command reaches the grid, not the window")
-        func cellEditorClaimsTheCommand() async throws {
-            let grid = await MountedGrid()
-            defer { grid.close() }
-            let tableView = try #require(grid.tableView)
-            let scrollView = try #require(grid.scrollView)
-            let coordinator = try #require(tableView.coordinator)
-            let column = try #require(coordinator.tableColumnIndex(forDisplayPosition: 0))
-
-            coordinator.showOverlayEditor(tableView: tableView, row: 0, column: column, columnIndex: 0, value: "value")
-            defer { coordinator.overlayEditor?.dismiss(commit: false) }
-
-            #expect(grid.window.firstResponder is NSTextView)
-            #expect(zoomResponder(from: grid.window.firstResponder) === scrollView)
-        }
-
-        @Test("Zoom In and Zoom Out change the Data Grid font and leave the editor font")
-        func zoomChangesTheGridFontOnly() {
-            let scrollView = DataGridScrollView()
-
-            scrollView.zoomIn(nil)
-            #expect(AppSettingsManager.shared.typography.dataGridFontSize == 14)
-            #expect(AppSettingsManager.shared.typography.editorFontSize == 13)
-
-            scrollView.zoomOut(nil)
-            scrollView.zoomOut(nil)
-            #expect(AppSettingsManager.shared.typography.dataGridFontSize == 12)
-            #expect(AppSettingsManager.shared.typography.editorFontSize == 13)
-        }
-
-        @Test(
-            "Zoom In dims at the largest size instead of falling through to the editor",
-            .appSettings { $0.typography.dataGridFontSize = TypographySettings.sizeRange.upperBound }
-        )
-        func zoomInDimsAtTheLargestSize() {
-            let scrollView = DataGridScrollView()
-
-            #expect(!scrollView.validateMenuItem(item(#selector(ZoomCommandResponding.zoomIn(_:)))))
-            #expect(scrollView.validateMenuItem(item(#selector(ZoomCommandResponding.zoomOut(_:)))))
-
-            scrollView.zoomIn(nil)
-            #expect(AppSettingsManager.shared.typography.dataGridFontSize == TypographySettings.sizeRange.upperBound)
-            #expect(AppSettingsManager.shared.typography.editorFontSize == 13)
-        }
-
-        @Test(
-            "Zoom Out dims at the smallest size",
-            .appSettings { $0.typography.dataGridFontSize = TypographySettings.sizeRange.lowerBound }
-        )
-        func zoomOutDimsAtTheSmallestSize() {
-            let scrollView = DataGridScrollView()
-
-            #expect(scrollView.validateMenuItem(item(#selector(ZoomCommandResponding.zoomIn(_:)))))
-            #expect(!scrollView.validateMenuItem(item(#selector(ZoomCommandResponding.zoomOut(_:)))))
-        }
-
-        @Test(
-            "A font taller than the chosen row height grows the rows of an open grid",
-            .appSettings {
-                $0.typography.dataGridFontSize = TypographySettings.sizeRange.upperBound - 1
-                $0.dataGrid.rowHeight = .compact
-            }
-        )
-        func rowsGrowWithTheFont() async throws {
-            let grid = await MountedGrid()
-            defer { grid.close() }
-            let tableView = try #require(grid.tableView)
-            let scrollView = try #require(grid.scrollView)
-            let before = tableView.rowHeight
-            #expect(before > CGFloat(DataGridRowHeight.compact.rawValue))
-
-            scrollView.zoomIn(nil)
-
-            let font = ThemeEngine.shared.dataGridFonts.regular
-            try await waitUntil { tableView.rowHeight == DataGridMetrics.rowHeight(.compact, font: font) }
-            #expect(tableView.rowHeight > before)
-            #expect(tableView.rowHeight >= font.ascender - font.descender + font.leading)
-        }
-
-        @Test(
-            "Rows that grow with a zoom keep the first visible row in place",
-            .appSettings { $0.typography.dataGridFontSize = 20 }
-        )
-        func zoomKeepsTheFirstVisibleRow() async throws {
-            let grid = await MountedGrid(rowCount: 10_000)
-            defer { grid.close() }
-            let tableView = try #require(grid.tableView)
-            let scrollView = try #require(grid.scrollView)
-            let coordinator = try #require(tableView.coordinator)
-            grid.scroll(toRow: 5_000)
-            let before = try #require(coordinator.viewportSample())
-            try #require(before.firstVisibleRow > 4_000)
-            let rowHeight = tableView.rowHeight
-
-            scrollView.zoomIn(nil)
-
-            try await waitUntil { tableView.rowHeight != rowHeight }
-            let after = try #require(coordinator.viewportSample())
-            #expect(after.firstVisibleRow == before.firstVisibleRow)
-        }
-
-        // Enough rows that the row-number column widens with the font, and a size where the rows grow:
-        // both are geometry changes that otherwise end the edit.
-        @Test(
-            "An open cell editor keeps its text and focus through a zoom, at the new size and on its cell",
-            .appSettings { $0.typography.dataGridFontSize = 20 }
-        )
-        func openEditorFollowsTheFont() async throws {
-            let grid = await MountedGrid(rowCount: 10_000)
-            defer { grid.close() }
-            let tableView = try #require(grid.tableView)
-            let scrollView = try #require(grid.scrollView)
-            let coordinator = try #require(tableView.coordinator)
-            let column = try #require(coordinator.tableColumnIndex(forDisplayPosition: 0))
-            let rowNumbers = try #require(tableView.tableColumns.first { $0.identifier == ColumnIdentitySchema.rowNumberIdentifier })
-            let rowNumberWidth = rowNumbers.width
-            let rowHeight = tableView.rowHeight
-            grid.scroll(toRow: 5_000)
-            let editedRow = 5_005
-            try #require(NSLocationInRange(editedRow, tableView.rows(in: tableView.visibleRect)))
-            coordinator.showOverlayEditor(tableView: tableView, row: editedRow, column: column, columnIndex: 0, value: "value")
-            let editor = try #require(coordinator.overlayEditor)
-            defer { editor.dismiss(commit: false) }
-            let textView = try #require(grid.window.firstResponder as? NSTextView)
-            let container = try #require(editor.containerView)
-            textView.string = "edited"
-
-            scrollView.zoomIn(nil)
-
-            try await waitUntil { textView.font == ThemeEngine.shared.valueFont }
-            try #require(rowNumbers.width != rowNumberWidth)
-            try #require(tableView.rowHeight != rowHeight)
-            #expect(editor.isActive)
-            #expect(textView.string == "edited")
-            #expect(grid.window.firstResponder === textView)
-            #expect(NSLocationInRange(editedRow, tableView.rows(in: tableView.visibleRect)))
-            let cellFrame = CellOverlayBase.displayedCellFrame(in: tableView, column: column, row: editedRow)
-            let expected = scrollView.convert(CellOverlayBase.overlayFrame(for: cellFrame, value: "edited"), from: tableView)
-            #expect(container.frame == expected)
-        }
-    }
-}
-
-struct DataGridRowHeightTests {
-    @Test("The row height setting stands while the font fits in it")
-    func settingStandsForAFittingFont() {
-        let font = NSFont.monospacedSystemFont(ofSize: 13, weight: .regular)
-        #expect(DataGridMetrics.rowHeight(.normal, font: font) == CGFloat(DataGridRowHeight.normal.rawValue))
-        #expect(DataGridMetrics.rowHeight(.compact, font: font) == CGFloat(DataGridRowHeight.compact.rawValue))
-    }
-
-    @Test("A font taller than the row raises the row to hold the whole line")
-    func tallFontRaisesTheRow() {
-        let font = NSFont.monospacedSystemFont(ofSize: 24, weight: .regular)
-        let height = DataGridMetrics.rowHeight(.normal, font: font)
-        #expect(height > CGFloat(DataGridRowHeight.normal.rawValue))
-        #expect(height >= font.ascender - font.descender + font.leading)
-        #expect(height == height.rounded())
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DisplayRowMappingTests.swift b/apple/TableProTests/Views/Results/DisplayRowMappingTests.swift
deleted file mode 100644
index b4c08f1202..0000000000
--- a/apple/TableProTests/Views/Results/DisplayRowMappingTests.swift
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-//  DisplayRowMappingTests.swift
-//  TableProTests
-//
-
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-struct DisplayRowMappingTests {
-    private func makeTableRows() -> TableRows {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("active"), .text("a")]),
-            Row(id: .existing(1), values: [.text("inactive"), .text("b")]),
-            Row(id: .existing(2), values: [.text("active"), .text("c")]),
-            Row(id: .existing(3), values: [.null, .text("d")]),
-        ]
-        return TableRows(
-            rows: rows,
-            columns: ["status", "name"],
-            columnTypes: [.text(rawType: nil), .text(rawType: nil)]
-        )
-    }
-
-    @Test("with no display filter, a display index maps to the same array index")
-    func identityMappingWithoutFilter() {
-        let tableRows = makeTableRows()
-        #expect(DisplayRowMapping.rowIndex(forDisplay: 0, displayIDs: nil, in: tableRows) == 0)
-        #expect(DisplayRowMapping.rowIndex(forDisplay: 2, displayIDs: nil, in: tableRows) == 2)
-        #expect(DisplayRowMapping.row(forDisplay: 3, displayIDs: nil, in: tableRows)?.id == .existing(3))
-    }
-
-    @Test("out-of-range display index returns nil without a filter")
-    func outOfRangeWithoutFilter() {
-        let tableRows = makeTableRows()
-        #expect(DisplayRowMapping.rowIndex(forDisplay: 4, displayIDs: nil, in: tableRows) == nil)
-        #expect(DisplayRowMapping.rowIndex(forDisplay: -1, displayIDs: nil, in: tableRows) == nil)
-    }
-
-    @Test("a filtered display position resolves to the underlying array row, not the raw position")
-    func filteredMappingResolvesUnderlyingRow() {
-        let tableRows = makeTableRows()
-        let displayIDs: [RowID] = [.existing(0), .existing(2)]
-
-        #expect(DisplayRowMapping.rowIndex(forDisplay: 0, displayIDs: displayIDs, in: tableRows) == 0)
-        #expect(DisplayRowMapping.rowIndex(forDisplay: 1, displayIDs: displayIDs, in: tableRows) == 2)
-
-        let resolved = DisplayRowMapping.row(forDisplay: 1, displayIDs: displayIDs, in: tableRows)
-        #expect(resolved?.id == .existing(2))
-        #expect(resolved?.values == tableRows.rows[2].values)
-    }
-
-    @Test("out-of-range display index returns nil with a filter")
-    func outOfRangeWithFilter() {
-        let tableRows = makeTableRows()
-        let displayIDs: [RowID] = [.existing(0), .existing(2)]
-        #expect(DisplayRowMapping.row(forDisplay: 2, displayIDs: displayIDs, in: tableRows) == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/DrawnCellReachabilityTests.swift b/apple/TableProTests/Views/Results/DrawnCellReachabilityTests.swift
deleted file mode 100644
index 877a2e2e5d..0000000000
--- a/apple/TableProTests/Views/Results/DrawnCellReachabilityTests.swift
+++ /dev/null
@@ -1,265 +0,0 @@
-//
-//  DrawnCellReachabilityTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class ReachabilityLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// A data cell is drawn rather than mounted, so `view(atColumn:row:makeIfNecessary:false)` is always
-/// nil. Twelve guards still asked it before opening an editor or a popover, and every one of them
-/// returned early: the JSON, blob, PHP, date, enum, set, array, dropdown and type-picker editors
-/// were all unreachable. `presentsCell(row:tableColumnIndex:)` is the single replacement (#2381).
-@MainActor
-struct DrawnCellReachabilityTests {
-    /// Holds the window: `TableViewCoordinator.tableView` is weak both ways, so a suite that
-    /// dropped the hierarchy would only survive on `NSApplication` incidentally retaining it.
-    private struct Grid {
-        let window: NSWindow
-        let coordinator: TableViewCoordinator
-    }
-
-    private func makeGrid(columns: [String], rows: Int = 3) -> Grid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: ReachabilityLayoutPersister()
-        )
-        let queryRows = (0 ..< rows).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } }
-        let tableRows = TableRows.from(
-            queryRows: queryRows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 120 }
-        )
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 600, height: 200))
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView = scrollView
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        window.layoutIfNeeded()
-        return Grid(window: window, coordinator: coordinator)
-    }
-
-    /// The regression itself: the question the guards used to ask now answers nil for every data
-    /// cell, so anything still asking it is dead code.
-    @Test("No data cell mounts a view any more")
-    func dataCellsMountNoView() throws {
-        DataGridAccessibility.isActive = false
-        let coordinator = makeGrid(columns: ["id", "name"]).coordinator
-        let tableView = try #require(coordinator.tableView)
-        let dataColumn = try #require(coordinator.firstPresentedColumnIndex())
-
-        #expect(tableView.view(atColumn: dataColumn, row: 0, makeIfNecessary: false) == nil)
-        #expect(tableView.view(atColumn: dataColumn, row: 0, makeIfNecessary: true) == nil)
-    }
-
-    @Test("An on-screen data cell is reachable")
-    func onScreenCellIsReachable() throws {
-        let coordinator = makeGrid(columns: ["id", "name"]).coordinator
-        let dataColumn = try #require(coordinator.firstPresentedColumnIndex())
-
-        #expect(coordinator.presentsCell(row: 0, tableColumnIndex: dataColumn))
-    }
-
-    @Test("A row outside the result is not reachable")
-    func rowOutOfRangeIsNotReachable() throws {
-        let coordinator = makeGrid(columns: ["id", "name"]).coordinator
-        let dataColumn = try #require(coordinator.firstPresentedColumnIndex())
-
-        #expect(!coordinator.presentsCell(row: -1, tableColumnIndex: dataColumn))
-        #expect(!coordinator.presentsCell(row: 99, tableColumnIndex: dataColumn))
-    }
-
-    @Test("The row-number column is not a cell anything opens on")
-    func rowNumberColumnIsNotReachable() throws {
-        let coordinator = makeGrid(columns: ["id", "name"]).coordinator
-        let tableView = try #require(coordinator.tableView)
-        let rowNumber = tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-
-        #expect(rowNumber >= 0)
-        #expect(!coordinator.presentsCell(row: 0, tableColumnIndex: rowNumber))
-    }
-
-    /// `reloadData(forRowIndexes:columnIndexes:)` raises `NSRangeException` for a row past the end,
-    /// and a row view can outlive a result that shrank under it, so undoing a delete on a stale row
-    /// used to crash rather than no-op.
-    @Test("Repainting a row past the end of the result is a no-op")
-    func repaintingAnOutOfRangeRowIsANoOp() throws {
-        let coordinator = makeGrid(columns: ["id", "name"], rows: 2).coordinator
-
-        coordinator.repaintRows(IndexSet(integer: 99))
-        coordinator.repaintRows(IndexSet(integer: -1))
-    }
-
-    // MARK: - Accessibility
-
-    private func mountedCell(
-        in grid: Grid,
-        row: Int = 0
-    ) throws -> DataGridCellAccessibilityView? {
-        let tableView = try #require(grid.coordinator.tableView)
-        let column = try #require(grid.coordinator.firstPresentedColumnIndex())
-        return tableView.view(atColumn: column, row: row, makeIfNecessary: true) as? DataGridCellAccessibilityView
-    }
-
-    /// The whole point of drawing the cells: a result with hundreds of columns builds no view for
-    /// any of them. Nothing has asked this grid an accessibility question, so nothing mounts.
-    @Test("A data cell mounts no view until something reads the grid")
-    func noCellViewIsMountedWhileAccessibilityIsIdle() throws {
-        DataGridAccessibility.isActive = false
-        let grid = makeGrid(columns: ["id", "name"])
-
-        #expect(try mountedCell(in: grid) == nil)
-    }
-
-    /// `NSTableView` builds its `AXCell` tree from cell views and from nothing else, so a drawn cell
-    /// can only speak through one. Measured: an `NSAccessibilityElement` published by the row never
-    /// reaches the tree, whichever attribute carries the text and however it is parented, and AppKit
-    /// puts its own blank placeholder there instead.
-    @Test("A cell mounts a view carrying its value once accessibility is active")
-    func anActiveClientGetsACellItCanRead() throws {
-        DataGridAccessibility.isActive = true
-        defer { DataGridAccessibility.isActive = false }
-        let grid = makeGrid(columns: ["id", "name"])
-
-        let cell = try #require(try mountedCell(in: grid))
-
-        #expect(cell.accessibilityValue() as? String == "id-0")
-        #expect(cell.accessibilityRole() == .staticText)
-    }
-
-    /// Walking the tree makes `NSTableView` prepare every row of the page and ask for a view for
-    /// each one, so mounting on preparation alone put 9,000 views and a 21,000 element tree behind a
-    /// 1,000-row page and starved the app of the main thread.
-    @Test("A row below the viewport mounts no cell")
-    func aRowBelowTheViewportMountsNothing() throws {
-        DataGridAccessibility.isActive = true
-        defer { DataGridAccessibility.isActive = false }
-        let grid = makeGrid(columns: ["id"], rows: 200)
-        let tableView = try #require(grid.coordinator.tableView)
-        let column = try #require(grid.coordinator.firstPresentedColumnIndex())
-
-        #expect(tableView.view(atColumn: column, row: 0, makeIfNecessary: true) is DataGridCellAccessibilityView)
-        #expect(tableView.view(atColumn: column, row: 199, makeIfNecessary: true) == nil)
-    }
-
-    /// The value is read through rather than stored, so an edit is spoken without anything having to
-    /// remember to stand the cell down first. A committed cell edit takes this exact path.
-    @Test("An edited cell is read back without any invalidation")
-    func anEditedCellReadsItsNewValue() throws {
-        DataGridAccessibility.isActive = true
-        defer { DataGridAccessibility.isActive = false }
-        let columns = ["id"]
-        var current = TableRows.from(
-            queryRows: [[PluginCellValue.text("before")]],
-            columns: columns,
-            columnTypes: [ColumnType.text(rawType: "TEXT")]
-        )
-        let grid = makeGrid(columns: columns, rows: 1)
-        grid.coordinator.tableRowsProvider = { current }
-        grid.coordinator.updateCache()
-        let cell = try #require(try mountedCell(in: grid))
-        #expect(cell.accessibilityValue() as? String == "before")
-
-        current = TableRows.from(
-            queryRows: [[PluginCellValue.text("after")]],
-            columns: columns,
-            columnTypes: [ColumnType.text(rawType: "TEXT")]
-        )
-        grid.coordinator.invalidateDisplayCache()
-
-        #expect(cell.accessibilityValue() as? String == "after")
-    }
-
-    /// The row still draws every cell and still handles every click, so the view mounted over it
-    /// must be transparent to the mouse or the in-cell accessories and the double click to edit go
-    /// to a view that does nothing with them.
-    @Test("The mounted cell takes no clicks")
-    func theMountedCellIsTransparentToTheMouse() throws {
-        DataGridAccessibility.isActive = true
-        defer { DataGridAccessibility.isActive = false }
-        let grid = makeGrid(columns: ["id"])
-        let cell = try #require(try mountedCell(in: grid))
-
-        #expect(cell.hitTest(NSPoint(x: cell.bounds.midX, y: cell.bounds.midY)) == nil)
-    }
-
-    @Test("The view that draws the cells stays out of the accessibility tree")
-    func theDrawingViewIsNotAnAccessibilityElement() throws {
-        let rowView = DataGridRowView()
-        let content = try #require(rowView.subviews.first as? DataGridRowContentView)
-
-        #expect(content.isAccessibilityElement() == false)
-    }
-
-    /// The row covers more than its cells do: the row-number column at one end and, on a result
-    /// narrower than the grid, the empty width past the last column at the other. AppKit's own hit
-    /// test descends into subviews and the view that draws the cells covers the whole row, so a
-    /// point outside every cell resolved to a view that is not in the tree at all.
-    @Test("An accessibility hit test past the last column lands on the row itself")
-    func aHitTestPastTheLastColumnReturnsTheRow() throws {
-        let grid = makeGrid(columns: ["id", "name"], rows: 1)
-        let tableView = try #require(grid.coordinator.tableView)
-        let rowView = try #require(tableView.rowView(atRow: 0, makeIfNecessary: true) as? DataGridRowView)
-        let lastColumn = try #require(grid.coordinator.lastPresentedColumnIndex())
-        let pastEverything = tableView.rect(ofColumn: lastColumn).maxX + 20
-
-        let hit = rowView.accessibilityHitTest(
-            screenPoint(x: pastEverything, in: rowView, of: tableView, window: grid.window)
-        )
-
-        #expect(hit as? NSView === rowView)
-    }
-
-    private func screenPoint(
-        x horizontal: CGFloat,
-        in rowView: DataGridRowView,
-        of tableView: NSTableView,
-        window: NSWindow
-    ) -> NSPoint {
-        let inRow = rowView.convert(NSPoint(x: horizontal, y: 0), from: tableView)
-        let centred = NSPoint(x: inRow.x, y: rowView.bounds.midY)
-        return window.convertPoint(toScreen: rowView.convert(centred, to: nil))
-    }
-}
diff --git a/apple/TableProTests/Views/Results/Extensions/CellPasteRoutingTests.swift b/apple/TableProTests/Views/Results/Extensions/CellPasteRoutingTests.swift
index e73b5d188a..e77bbacc6c 100644
--- a/apple/TableProTests/Views/Results/Extensions/CellPasteRoutingTests.swift
+++ b/apple/TableProTests/Views/Results/Extensions/CellPasteRoutingTests.swift
@@ -1,163 +1,210 @@
-// Locks the contract that pasteCellsFromClipboard defers to row paste
-// when the clipboard carries the in-app gridRows tag or has a row-shaped
-// TSV. Without these checks, Cmd+V on a focused cell after Cmd+C on a row
-// silently overwrites the row's tail columns.
+// Paste leaves a clipboard holding whole rows to row paste: with the grid's row tag, or TSV as wide as the result.
+// Without that, Command-V on a cell after copying a row would overwrite the row's tail columns.
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class NoopColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
     struct CellPasteRoutingTests {
         private static let gridRowsTag = GridRowsClipboardPayload(columns: ["a"], rows: [[.text("anything")]])
 
-        private func makeCoordinator(columns: [String], rowCount: Int) -> TableViewCoordinator {
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: true,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: NoopColumnLayoutPersister()
+        private func makeGrid(columns: [String], rowCount: Int, isEditable: Bool = true) -> CommandGrid {
+            let rows = (0..<rowCount).map { row in (0..<columns.count).map { PluginCellValue.text("r\(row)c\($0)") } }
+            let grid = CommandGrid(
+                TableRows.from(
+                    queryRows: rows,
+                    columns: columns,
+                    columnTypes: Array(repeating: .text(rawType: nil), count: columns.count)
+                ),
+                configuration: isEditable ? CommandGrid.editable() : CommandGrid.readOnly()
             )
-            let columnTypes: [ColumnType] = Array(repeating: .text(rawType: nil), count: columns.count)
-            let rows = (0..<rowCount).map { i in (0..<columns.count).map { c in "r\(i)c\(c)" } }
-            let tableRows = TableRows.from(queryRows: rows.map { row in row.map { PluginCellValue.text($0) } }, columns: columns, columnTypes: columnTypes)
-            coordinator.tableRowsProvider = { tableRows }
-            coordinator.updateCache()
-            return coordinator
+            grid.owner.pastesRows = true
+            return grid
         }
 
-        @Test("Defers to row paste when clipboard has gridRows tag")
+        private func paste(into grid: CommandGrid, row: Int, column: Int) {
+            grid.selectCell(row, column)
+            grid.controller.paste(nil)
+        }
+
+        @Test("Defers to row paste when the clipboard carries the grid's row tag")
         func defersOnGridRowsTag() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "anything\twith\ttabs"
-            stub.gridRows = Self.gridRowsTag
+            let clipboard = try #require(RecordingClipboard.current)
+            clipboard.text = "anything\twith\ttabs"
+            clipboard.gridRows = Self.gridRowsTag
+            let grid = makeGrid(columns: ["a", "b", "c"], rowCount: 5)
 
-            let coordinator = makeCoordinator(columns: ["a", "b", "c"], rowCount: 5)
-            let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+            paste(into: grid, row: 0, column: 0)
 
-            #expect(result == false)
+            #expect(grid.owner.commits.isEmpty)
+            #expect(grid.owner.rowPastes == 1)
         }
 
-        @Test("Defers to row paste when every TSV line matches column count")
+        @Test("Defers to row paste when every TSV line matches the column count")
         func defersOnRowShapedTSV() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "x\ty\tz\nq\tw\te"
+            try #require(RecordingClipboard.current).text = "x\ty\tz\nq\tw\te"
+            let grid = makeGrid(columns: ["a", "b", "c"], rowCount: 5)
 
-            let coordinator = makeCoordinator(columns: ["a", "b", "c"], rowCount: 5)
-            let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+            paste(into: grid, row: 0, column: 0)
 
-            #expect(result == false)
+            #expect(grid.owner.commits.isEmpty)
+            #expect(grid.owner.rowPastes == 1)
         }
 
-        @Test("Cell pastes shape-mismatched TSV into focused range")
+        @Test("A block narrower than the result fills rightwards from the cursor in one step")
         func cellPastesShapeMismatchedTSV() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "x\ty"
+            try #require(RecordingClipboard.current).text = "x\ty"
+            let grid = makeGrid(columns: ["a", "b", "c", "d", "e"], rowCount: 5)
 
-            let coordinator = makeCoordinator(columns: ["a", "b", "c", "d", "e"], rowCount: 5)
-            let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+            paste(into: grid, row: 0, column: 1)
 
-            #expect(result == true)
+            #expect(grid.owner.commits.count == 1)
+            #expect(grid.owner.commits.first?.actionName == String(localized: "Paste Cells"))
+            #expect(grid.owner.staged(0, 1)?.value == .text("x"))
+            #expect(grid.owner.staged(0, 2)?.value == .text("y"))
+            #expect(grid.owner.rowPastes == 0)
         }
 
-        /// #2172: a one-value clipboard used to be refused here and fall through to row paste, which
-        /// appended a row and left the focused cell untouched. Copying a cell and pasting it into
-        /// another cell has to fill that cell.
-        @Test("Cell pastes a single copied value into the focused cell")
+        // #2172: a one-value clipboard has to fill the cell rather than append a row.
+        @Test("A single copied value pastes into the cursor's cell")
         func cellPastesSingleValue() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "hello"
+            try #require(RecordingClipboard.current).text = "hello"
+            let grid = makeGrid(columns: ["a", "b", "c"], rowCount: 5)
+            grid.selectCell(2, 1)
 
-            let coordinator = makeCoordinator(columns: ["a", "b", "c"], rowCount: 5)
+            #expect(grid.commands.canPaste(.current(grid.model.selection)))
+            grid.controller.paste(nil)
 
-            #expect(coordinator.canPasteCellsFromClipboard(anchorRow: 2, anchorColumn: 1))
-            #expect(coordinator.pasteCellsFromClipboard(anchorRow: 2, anchorColumn: 1))
+            #expect(grid.owner.staged(2, 1)?.value == .text("hello"))
         }
 
-        @Test("A single value still defers to row paste when the clipboard carries the gridRows tag")
+        @Test("A single value still defers to row paste when the clipboard carries the row tag")
         func singleValueDefersOnGridRowsTag() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "hello"
-            stub.gridRows = Self.gridRowsTag
+            let clipboard = try #require(RecordingClipboard.current)
+            clipboard.text = "hello"
+            clipboard.gridRows = Self.gridRowsTag
+            let grid = makeGrid(columns: ["a", "b", "c"], rowCount: 5)
 
-            let coordinator = makeCoordinator(columns: ["a", "b", "c"], rowCount: 5)
+            paste(into: grid, row: 2, column: 1)
 
-            #expect(coordinator.canPasteCellsFromClipboard(anchorRow: 2, anchorColumn: 1) == false)
-            #expect(coordinator.pasteCellsFromClipboard(anchorRow: 2, anchorColumn: 1) == false)
+            #expect(grid.owner.commits.isEmpty)
+            #expect(grid.owner.rowPastes == 1)
         }
 
         @Test("A single value fills the cell even in a one-column table, where it looks row-shaped")
         func singleValueInSingleColumnTable() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "hello"
+            try #require(RecordingClipboard.current).text = "hello"
+            let grid = makeGrid(columns: ["a"], rowCount: 3)
 
-            let coordinator = makeCoordinator(columns: ["a"], rowCount: 3)
+            paste(into: grid, row: 1, column: 0)
 
-            #expect(coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: 0))
+            #expect(grid.owner.staged(1, 0)?.value == .text("hello"))
         }
 
-        @Test("canPasteCellsFromClipboard agrees with pasteCellsFromClipboard and mutates nothing")
+        @Test("Validation agrees with the paste and writes nothing")
         func canPasteAgreesAndDoesNotMutate() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "x\ty"
-
-            let coordinator = makeCoordinator(columns: ["a", "b", "c", "d", "e"], rowCount: 5)
-            let before = Array(coordinator.tableRowsProvider().rows)
-
-            #expect(coordinator.canPasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0))
-            #expect(Array(coordinator.tableRowsProvider().rows) == before)
-            #expect(coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0))
+            try #require(RecordingClipboard.current).text = "x\ty"
+            let grid = makeGrid(columns: ["a", "b", "c", "d", "e"], rowCount: 5)
+            grid.owner.pastesRows = false
+            grid.selectCell(0, 0)
+            let before = Array(grid.owner.tableRows.rows)
+
+            #expect(grid.isEnabled(#selector(DataGridViewController.paste(_:))))
+            #expect(Array(grid.owner.tableRows.rows) == before)
+            #expect(grid.owner.commits.isEmpty)
         }
 
         @Test("Whole rows with an empty line between them still go to row paste")
         func defersOnRowShapedTSVWithEmptyLine() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "x\ty\tz\n\nq\tw\te\n\n"
+            try #require(RecordingClipboard.current).text = "x\ty\tz\n\nq\tw\te\n\n"
+            let grid = makeGrid(columns: ["a", "b", "c"], rowCount: 5)
 
-            let coordinator = makeCoordinator(columns: ["a", "b", "c"], rowCount: 5)
+            paste(into: grid, row: 0, column: 0)
 
-            #expect(coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0) == false)
+            #expect(grid.owner.commits.isEmpty)
+            #expect(grid.owner.rowPastes == 1)
         }
 
-        @Test("A value with trailing line breaks still fills only the focused cell in a one-column table")
+        @Test("A value with trailing line breaks still fills only the cursor's cell in a one-column table")
         func singleValueWithTrailingBreaksInSingleColumnTable() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "hello\n\n"
+            try #require(RecordingClipboard.current).text = "hello\n\n"
+            let grid = makeGrid(columns: ["a"], rowCount: 3)
 
-            let coordinator = makeCoordinator(columns: ["a"], rowCount: 3)
+            paste(into: grid, row: 1, column: 0)
 
-            #expect(coordinator.canPasteCellsFromClipboard(anchorRow: 1, anchorColumn: 0))
+            #expect(grid.owner.staged(1, 0)?.value == .text("hello"))
+            #expect(grid.owner.editCount == 1)
         }
 
-        @Test("Returns false when not editable")
+        @Test("A read-only grid pastes nothing and dims Paste")
         func refusesWhenReadOnly() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "x\ty"
-
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: false,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: NoopColumnLayoutPersister()
-            )
+            try #require(RecordingClipboard.current).text = "x\ty"
+            let grid = makeGrid(columns: ["a", "b"], rowCount: 2, isEditable: false)
+
+            paste(into: grid, row: 0, column: 0)
+
+            #expect(grid.owner.commits.isEmpty)
+            #expect(grid.owner.rowPastes == 0)
+            #expect(!grid.isEnabled(#selector(DataGridViewController.paste(_:))))
+        }
+
+        @Test("The context menu's Paste on a cell outside the selection fills the clicked cell (interaction 4)")
+        func contextMenuPasteTakesTheClickedCell() throws {
+            try #require(RecordingClipboard.current).text = "hello"
+            let grid = makeGrid(columns: ["a", "b", "c"], rowCount: 5)
+            grid.select(rows: 0...1, columns: 0...0)
+
+            grid.controller.paste(grid.contextItem(row: 3, displayColumn: 2))
+
+            #expect(grid.owner.staged(3, 2)?.value == .text("hello"))
+            #expect(grid.owner.editCount == 1)
+            #expect(grid.owner.rowPastes == 0)
+        }
+
+        // A filter applied while the values load must not move the paste onto other records.
+        @Test("A paste that waits for values writes the records it was pasted onto", arguments: ["x", "x\ny"])
+        func pasteKeepsItsRecordsAcrossALoad(clipboardText: String) throws {
+            try #require(RecordingClipboard.current).text = clipboardText
+            let grid = CommandGrid(TableRows.from(
+                queryRows: [[.text("1"), .null], [.text("2"), .null], [.text("3"), .text("c")]],
+                columns: ["id", "body"],
+                columnTypes: [.text(rawType: nil), .text(rawType: nil)],
+                unloadedCells: [0: [1: 2_000_000], 1: [1: 2_000_000]]
+            ))
+            grid.owner.loadableValues = [.existing(0): [1: .text("a")], .existing(1): [1: .text("b")]]
+            grid.owner.defersLoads = true
+            if clipboardText == "x" {
+                grid.select(rows: 0...1, columns: 1...1)
+            } else {
+                grid.selectCell(0, 1)
+            }
+
+            grid.controller.paste(nil)
+            try #require(grid.owner.commits.isEmpty)
+            var filter = GridValueFilterState()
+            filter.set(ColumnValueFilter(selectedValues: ["2", "3"], includesNull: false), columnName: "id", forColumn: 0)
+            grid.model.setValueFilter(filter)
+            grid.owner.finishLoads()
+
+            #expect(grid.owner.staged(0, 1)?.value == .text("x"))
+            #expect(grid.owner.staged(1, 1)?.value == .text(clipboardText == "x" ? "x" : "y"))
+            #expect(grid.owner.staged(2, 1) == nil)
+        }
+
+        @Test("The row-number menu's Paste goes to row paste")
+        func rowNumberPasteIsRowPaste() throws {
+            try #require(RecordingClipboard.current).text = "hello"
+            let grid = makeGrid(columns: ["a", "b", "c"], rowCount: 5)
 
-            let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+            grid.controller.paste(grid.contextItem(row: 1, displayColumn: nil))
 
-            #expect(result == false)
+            #expect(grid.owner.commits.isEmpty)
+            #expect(grid.owner.rowPastes == 1)
         }
     }
 }
diff --git a/apple/TableProTests/Views/Results/Extensions/ClearedCellCommitTests.swift b/apple/TableProTests/Views/Results/Extensions/ClearedCellCommitTests.swift
index f1d77c3d05..4105b1b241 100644
--- a/apple/TableProTests/Views/Results/Extensions/ClearedCellCommitTests.swift
+++ b/apple/TableProTests/Views/Results/Extensions/ClearedCellCommitTests.swift
@@ -2,49 +2,24 @@
 //  ClearedCellCommitTests.swift
 //  TableProTests
 //
-//  An emptied cell in a column whose type has no empty value is staged as NULL, so a cleared
-//  MySQL `deleted_at` is written as NULL rather than the server's zero date. A NOT NULL column of
-//  such a type refuses the edit, since it holds neither value.
+//  An emptied cell in a column whose type has no empty value is staged as NULL, so a cleared MySQL `deleted_at` is
+//  written as NULL rather than the server's zero date. A NOT NULL column of such a type refuses the edit.
 //
 
 import AppKit
-import SwiftUI
 import TableProPluginKit
 import Testing
 
 @testable import TablePro
 
 @MainActor
-private final class NoopClearedCellLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class ClearedCellRowStore {
+private final class ClearedCellOwner: DataGridDataSource, DataGridActions {
     var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
-@MainActor
-private struct ClearedCellFixture {
-    static let columns = ["id", "deleted_at", "name", "visits", "created_at", "doc"]
-    static let deletedAt = 1
-    static let name = 2
-    static let visits = 3
-    static let createdAt = 4
-    static let doc = 5
-
     let manager: DataChangeManager
-    let coordinator: TableViewCoordinator
-    let store: ClearedCellRowStore
+    let changeState: AnyChangeManager
 
-    init(tableRows: TableRows = Self.usersRows) {
-        manager = DataChangeManager()
+    init(_ tableRows: TableRows) {
+        let manager = DataChangeManager()
         manager.configureForTable(
             tableName: "users",
             columns: tableRows.columns,
@@ -52,55 +27,86 @@ private struct ClearedCellFixture {
             databaseType: .mysql,
             generatedColumns: []
         )
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(manager),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopClearedCellLayoutPersister()
-        )
-        coordinator.databaseType = .mysql
-        store = ClearedCellRowStore(tableRows)
-        let store = store
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-        coordinator.updateCache()
+        self.tableRows = tableRows
+        self.manager = manager
+        changeState = AnyChangeManager(manager)
+    }
+
+    var gridRows: TableRows { tableRows }
+    var gridChangeState: AnyChangeManager { changeState }
+
+    func gridCommit(_ edits: [DataGridResolvedEdit], actionName: String) -> Bool {
+        for edit in edits {
+            changeState.recordCellChange(
+                rowID: edit.rowID,
+                columnIndex: edit.dataIndex,
+                columnName: edit.columnName,
+                oldValue: edit.oldValue,
+                newValue: edit.newValue,
+                originalRow: edit.originalRow,
+                absence: edit.absence,
+                isExpression: edit.isExpression
+            )
+            if let index = tableRows.index(of: edit.rowID) {
+                _ = tableRows.edit(row: index, column: edit.dataIndex, value: edit.newValue)
+            }
+        }
+        return true
     }
+}
+
+@MainActor
+private struct ClearedCellFixture {
+    static let columns = ["id", "deleted_at", "name", "visits", "created_at", "doc"]
+
+    let owner: ClearedCellOwner
+    let model: DataGridModel
 
-    static var usersRows: TableRows {
+    init() {
         let created: PluginCellValue = .text("2023-12-01 09:00:00")
         let doc: PluginCellValue = .text("{\"a\":1}")
-        return TableRows.from(
+        let rows = TableRows.from(
             queryRows: [
                 [.text("1"), .text("2024-01-01 10:00:00"), .text("Alice"), .text("3"), created, doc],
                 [.text("2"), .text("2024-02-02 10:00:00"), .text("Bob"), .text("4"), created, doc],
-                [.text("3"), .text("2024-03-03 10:00:00"), .text("Carol"), .text("5"), created, doc]
+                [.text("3"), .text("2024-03-03 10:00:00"), .text("Carol"), .text("5"), created, doc],
             ],
-            columns: columns,
+            columns: Self.columns,
             columnTypes: [
                 .integer(rawType: "INT"),
                 .datetime(rawType: "DATETIME"),
                 .text(rawType: "VARCHAR(255)"),
                 .integer(rawType: "INT"),
                 .timestamp(rawType: "TIMESTAMP"),
-                .json(rawType: "JSON")
+                .json(rawType: "JSON"),
             ],
             columnNullable: ["deleted_at": true, "name": true, "created_at": false]
         )
+        owner = ClearedCellOwner(rows)
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        configuration.traits = DataGridEngineTraits(databaseType: .mysql, cellWriterSupport: owner.manager.cellWriterSupport)
+        model = DataGridModel(configuration: configuration)
+        model.dataSource = owner
+        model.actions = owner
+        model.reloadRows()
     }
 
-    func setValueTitles(row: Int = 0, column: Int) -> [String] {
-        let targets = coordinator.setValueTargets(clicked: SetValueTarget(displayRow: row, columnIndex: column))
-        return coordinator.setValueCommands(for: targets).map { SetValueOptions.title(for: $0) }
+    @discardableResult
+    func enter(_ text: String?, row: Int, column: String) -> Bool {
+        let target = DataGridEditTarget(rowID: .existing(row), columnID: DataGridColumnID(name: column, occurrence: 0))
+        return DataGridViewController.commitEnteredText(text, to: target, in: model)
     }
 
-    func value(row: Int, column: Int) -> PluginCellValue {
-        store.tableRows.rows[row].values[column]
+    func value(row: Int, column: String) -> PluginCellValue {
+        let index = Self.columns.firstIndex(of: column) ?? 0
+        return owner.tableRows.rows[row].values[index]
     }
 
-    func stagedValue(row: Int, column: Int) -> PluginCellValue? {
-        manager.pending.change(forRow: .existing(row), type: .update)?
-            .cellChanges.first { $0.columnIndex == column }?.newValue
+    func stagedValue(row: Int, column: String) -> PluginCellValue? {
+        let index = Self.columns.firstIndex(of: column) ?? 0
+        return owner.manager.pending.change(forRow: .existing(row), type: .update)?
+            .cellChanges.first { $0.columnIndex == index }?.newValue
     }
 }
 
@@ -110,11 +116,11 @@ struct ClearedCellCommitTests {
     func clearedDateIsNull() throws {
         let fixture = ClearedCellFixture()
 
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: ClearedCellFixture.deletedAt, newValue: "")
+        #expect(fixture.enter("", row: 0, column: "deleted_at"))
 
-        #expect(fixture.stagedValue(row: 0, column: ClearedCellFixture.deletedAt) == .null)
-        #expect(fixture.value(row: 0, column: ClearedCellFixture.deletedAt) == .null)
-        let statement = try #require(try fixture.manager.generateSQL().first)
+        #expect(fixture.stagedValue(row: 0, column: "deleted_at") == .null)
+        #expect(fixture.value(row: 0, column: "deleted_at") == .null)
+        let statement = try #require(try fixture.owner.manager.generateSQL().first)
         #expect(statement.sql.contains("`deleted_at` = ?"))
         let boundValue = try #require(statement.parameters.first)
         #expect(boundValue == nil)
@@ -124,262 +130,46 @@ struct ClearedCellCommitTests {
     func clearedTextStaysEmpty() {
         let fixture = ClearedCellFixture()
 
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: ClearedCellFixture.name, newValue: "")
+        fixture.enter("", row: 0, column: "name")
 
-        #expect(fixture.stagedValue(row: 0, column: ClearedCellFixture.name) == .text(""))
-        #expect(fixture.value(row: 0, column: ClearedCellFixture.name) == .text(""))
+        #expect(fixture.stagedValue(row: 0, column: "name") == .text(""))
+        #expect(fixture.value(row: 0, column: "name") == .text(""))
     }
 
-    @Test("Clearing a NOT NULL timestamp stages nothing and keeps the stored value")
+    @Test("Clearing a NOT NULL timestamp is refused, stages nothing and keeps the stored value")
     func clearedNotNullTimestampIsRefused() {
         let fixture = ClearedCellFixture()
 
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: ClearedCellFixture.createdAt, newValue: "")
+        #expect(!fixture.enter("", row: 0, column: "created_at"))
 
-        #expect(fixture.manager.hasChanges == false)
-        #expect(fixture.value(row: 0, column: ClearedCellFixture.createdAt) == .text("2023-12-01 09:00:00"))
+        #expect(fixture.owner.manager.hasChanges == false)
+        #expect(fixture.value(row: 0, column: "created_at") == .text("2023-12-01 09:00:00"))
     }
 
-    @Test("A detached editor's cleared number commits NULL into the row it was opened for")
+    @Test("A cleared number commits NULL into the record the editor opened on")
     func clearedNumberByRowIDIsNull() {
         let fixture = ClearedCellFixture()
 
-        fixture.coordinator.commitCellEdit(rowID: .existing(2), columnIndex: ClearedCellFixture.visits, newValue: "")
+        fixture.enter("", row: 2, column: "visits")
 
-        #expect(fixture.stagedValue(row: 2, column: ClearedCellFixture.visits) == .null)
+        #expect(fixture.stagedValue(row: 2, column: "visits") == .null)
     }
 
     @Test("The JSON editor's cleared document commits NULL, which a JSON column can hold where '' is refused")
     func clearedJSONIsNull() {
         let fixture = ClearedCellFixture()
 
-        fixture.coordinator.commitCellEdit(
-            rowID: .existing(1), fallbackDisplayRow: 1, columnIndex: ClearedCellFixture.doc, newValue: ""
-        )
-
-        #expect(fixture.stagedValue(row: 1, column: ClearedCellFixture.doc) == .null)
-    }
-
-    @Test("An empty Fill Column on a date writes NULL into every row")
-    func emptyFillOnDateIsNull() throws {
-        let fixture = ClearedCellFixture()
-        let content = try #require(
-            fixture.coordinator.fillColumnContent(choice: .value, text: "", columnIndex: ClearedCellFixture.deletedAt)
-        )
+        fixture.enter("", row: 1, column: "doc")
 
-        fixture.coordinator.applyFillColumn(columnIndex: ClearedCellFixture.deletedAt, content: content)
-
-        for row in 0..<3 {
-            #expect(fixture.stagedValue(row: row, column: ClearedCellFixture.deletedAt) == .null)
-        }
+        #expect(fixture.stagedValue(row: 1, column: "doc") == .null)
     }
 
-    @Test("An empty Fill Column on a NOT NULL timestamp has no value to write")
-    func emptyFillOnNotNullTimestampIsRefused() {
+    @Test("A NULL from a menu's Set NULL item stages NULL over text")
+    func menuNullIsNull() {
         let fixture = ClearedCellFixture()
 
-        let coordinator = fixture.coordinator
-        #expect(coordinator.fillColumnContent(choice: .value, text: "", columnIndex: ClearedCellFixture.createdAt) == nil)
-        #expect(
-            coordinator.fillColumnContent(choice: .value, text: "2024-05-05 00:00:00", columnIndex: ClearedCellFixture.createdAt)
-                == .value(.text("2024-05-05 00:00:00"))
-        )
-    }
-
-    @Test("Set Value offers Empty on a text column and not on a date or a number")
-    func setValueEmptyFollowsColumnType() {
-        let fixture = ClearedCellFixture()
-
-        let dateTitles = fixture.setValueTitles(column: ClearedCellFixture.deletedAt)
-        let numberTitles = fixture.setValueTitles(column: ClearedCellFixture.visits)
-        let textTitles = fixture.setValueTitles(column: ClearedCellFixture.name)
-
-        #expect(!dateTitles.contains("Empty"))
-        #expect(dateTitles.contains("NULL"))
-        #expect(!numberTitles.contains("Empty"))
-        #expect(textTitles.contains("Empty"))
-    }
-
-    @Test("Set Value offers Empty on an enum only when one of its labels is empty")
-    func setValueEmptyOnEnumFollowsLabels() {
-        let fixture = ClearedCellFixture(tableRows: TableRows.from(
-            queryRows: [[.text("a"), .text("x")]],
-            columns: ["plain", "withEmpty"],
-            columnTypes: [.enumType(rawType: "ENUM", values: nil), .enumType(rawType: "ENUM", values: nil)],
-            columnEnumValues: ["plain": ["a", "b"], "withEmpty": ["", "x"]]
-        ))
-
-        #expect(!fixture.setValueTitles(column: 0).contains("Empty"))
-        #expect(fixture.setValueTitles(column: 1).contains("Empty"))
-    }
-
-    @Test("A NOT NULL number with no default offers no Set Value items at all")
-    func setValueMenuEmptyForNotNullNumber() {
-        let fixture = ClearedCellFixture(tableRows: TableRows.from(
-            queryRows: [[.text("1")]],
-            columns: ["visits"],
-            columnTypes: [.integer(rawType: "INT")],
-            columnNullable: ["visits": false]
-        ))
-
-        #expect(fixture.setValueTitles(column: 0).isEmpty)
-    }
-
-    @Test("Pasted lines keep an empty line as a value and drop the closing line breaks")
-    func pastedLines() {
-        #expect(TableViewCoordinator.pastedLines("a\n\nc") == ["a", "", "c"])
-        #expect(TableViewCoordinator.pastedLines("a\nb\n") == ["a", "b"])
-        #expect(TableViewCoordinator.pastedLines("hello\n\n") == ["hello"])
-        #expect(TableViewCoordinator.pastedLines("a") == ["a"])
-    }
-
-    @Test("A CRLF copy splits into the same lines as a LF copy")
-    func pastedLinesFoldCRLF() {
-        #expect(TableViewCoordinator.pastedLines("a\r\n\r\nc\r\n") == ["a", "", "c"])
-        #expect(TableViewCoordinator.pastedLines("x\ty\r\nq\tw\r\n") == ["x\ty", "q\tw"])
-    }
-
-    @Test("A pasted NULL is NULL where the type cannot hold the text, and text everywhere else")
-    func pastedText() {
-        let datetime = ColumnType.datetime(rawType: "DATETIME")
-        let varchar = ColumnType.text(rawType: "VARCHAR(20)")
-        func pasted(_ field: String, _ columnType: ColumnType?) -> String? {
-            TableViewCoordinator.pastedText(field, columnType: columnType)
-        }
-        #expect(pasted("NULL", datetime) == nil)
-        #expect(pasted("NULL", .integer(rawType: "INT")) == nil)
-        #expect(pasted("NULL", varchar) == "NULL")
-        #expect(pasted("NULL", .enumType(rawType: "ENUM", values: ["NULL", "a"])) == "NULL")
-        #expect(pasted("NULL", nil) == "NULL")
-        #expect(pasted("", datetime) == "")
-        #expect(pasted("null", datetime) == "null")
-    }
-
-}
-
-extension GlobalStateSuites {
-    @Suite(.recordingClipboard)
-    @MainActor
-    struct ClearedCellPasteTests {
-        @Test("An empty pasted field lands as NULL in a date column and as the empty string in text")
-        func emptyPastedFieldFollowsColumnType() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "\t"
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: ClearedCellFixture.deletedAt))
-
-            #expect(fixture.value(row: 0, column: ClearedCellFixture.deletedAt) == .null)
-            #expect(fixture.value(row: 0, column: ClearedCellFixture.name) == .text(""))
-        }
-
-        @Test("A copied NULL pasted into a date cell is NULL, not the text NULL")
-        func pastedNullIsNull() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "NULL"
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: ClearedCellFixture.deletedAt))
-
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.deletedAt) == .null)
-        }
-
-        @Test("The text NULL pasted into a text cell stays text, since a stored 'NULL' copies the same way")
-        func pastedNullTextIntoTextStaysText() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "NULL"
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: ClearedCellFixture.name))
-
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.name) == .text("NULL"))
-        }
-
-        @Test("A NULL copied from the grid pastes as NULL into a text cell")
-        func copiedNullRoundTripsIntoText() throws {
-            let fixture = ClearedCellFixture()
-            fixture.coordinator.commitCellEdit(row: 0, columnIndex: ClearedCellFixture.name, newValue: nil)
-
-            fixture.coordinator.copyCellValue(at: 0, columnIndex: ClearedCellFixture.name)
-            let clipboard = try #require(RecordingClipboard.current)
-            #expect(clipboard.text == "NULL")
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: ClearedCellFixture.name))
-
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.name) == .null)
-        }
-
-        @Test("The grid's copy pastes field by field, so a line break inside a value moves nothing")
-        func gridCopyKeepsFieldBoundaries() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-            clipboard.writeCells(GridCellsClipboardPayload(text: "first\nsecond\nNULL", fields: [["first\nsecond"], [nil]]))
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: ClearedCellFixture.name))
-
-            #expect(fixture.value(row: 0, column: ClearedCellFixture.name) == .text("first\nsecond"))
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.name) == .null)
-            #expect(fixture.value(row: 2, column: ClearedCellFixture.name) == .text("Carol"))
-        }
-
-        @Test("Fields left behind by text another app wrote over the copy are not used")
-        func staleGridCopyIsIgnored() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-            clipboard.text = "NULL"
-            clipboard.gridCells = GridCellsClipboardPayload(text: "other", fields: [[nil]])
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: ClearedCellFixture.name))
-
-            #expect(fixture.value(row: 0, column: ClearedCellFixture.name) == .text("NULL"))
-        }
-
-        @Test("A stored 'NULL' copied from the grid pastes as the same text")
-        func copiedNullTextRoundTripsAsText() throws {
-            let fixture = ClearedCellFixture()
-            fixture.coordinator.commitCellEdit(row: 0, columnIndex: ClearedCellFixture.name, newValue: "NULL")
-
-            fixture.coordinator.copyCellValue(at: 0, columnIndex: ClearedCellFixture.name)
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 2, anchorColumn: ClearedCellFixture.name))
-
-            #expect(fixture.value(row: 2, column: ClearedCellFixture.name) == .text("NULL"))
-        }
+        fixture.enter(nil, row: 0, column: "name")
 
-        @Test("A copied NULL pasted into a NOT NULL column leaves the cell as it was")
-        func pastedNullIntoNotNullIsRefused() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "NULL"
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: ClearedCellFixture.createdAt))
-
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.createdAt) == .text("2023-12-01 09:00:00"))
-            #expect(fixture.manager.hasChanges == false)
-        }
-
-        @Test("A block that opens on an empty line still fills every column of the lines below it")
-        func leadingEmptyLineKeepsBlockWidth() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "\nZed\t9"
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: ClearedCellFixture.name))
-
-            #expect(fixture.value(row: 0, column: ClearedCellFixture.name) == .text(""))
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.name) == .text("Zed"))
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.visits) == .text("9"))
-        }
-
-        @Test("An empty line in a pasted column keeps the values below it on their own rows")
-        func emptyLineKeepsRowsAligned() throws {
-            let stub = try #require(RecordingClipboard.current)
-            stub.text = "Xavier\n\nZoe"
-            let fixture = ClearedCellFixture()
-
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: ClearedCellFixture.name))
-
-            #expect(fixture.value(row: 0, column: ClearedCellFixture.name) == .text("Xavier"))
-            #expect(fixture.value(row: 1, column: ClearedCellFixture.name) == .text(""))
-            #expect(fixture.value(row: 2, column: ClearedCellFixture.name) == .text("Zoe"))
-        }
+        #expect(fixture.stagedValue(row: 0, column: "name") == .null)
     }
 }
diff --git a/apple/TableProTests/Views/Results/Extensions/ColumnIndexCacheTests.swift b/apple/TableProTests/Views/Results/Extensions/ColumnIndexCacheTests.swift
deleted file mode 100644
index 1c36b94b06..0000000000
--- a/apple/TableProTests/Views/Results/Extensions/ColumnIndexCacheTests.swift
+++ /dev/null
@@ -1,148 +0,0 @@
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import Testing
-
-@MainActor
-private final class StubColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct ColumnIndexCacheTests {
-    private func makeCoordinator() -> TableViewCoordinator {
-        TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: false,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubColumnLayoutPersister()
-        )
-    }
-
-    private func attachColumns(_ tableView: NSTableView, count: Int) {
-        tableView.addTableColumn(
-            NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        )
-        for slot in 0..<count {
-            tableView.addTableColumn(
-                NSTableColumn(identifier: ColumnIdentitySchema.slotIdentifier(slot))
-            )
-        }
-    }
-
-    @Test("resolved table column index mirrors the schema-backed column order")
-    func resolvesDataColumnToTableColumnIndex() {
-        let coordinator = makeCoordinator()
-        let tableView = NSTableView()
-        attachColumns(tableView, count: 3)
-        coordinator.tableView = tableView
-        _ = coordinator.rebuildColumnMetadataCache(
-            from: TableRows.from(
-                queryRows: [],
-                columns: ["id", "name", "email"],
-                columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: 3)
-            )
-        )
-
-        #expect(coordinator.tableColumnIndex(for: 0) == 1)
-        #expect(coordinator.tableColumnIndex(for: 1) == 2)
-        #expect(coordinator.tableColumnIndex(for: 2) == 3)
-    }
-
-    @Test("repeated lookups keep returning the same value")
-    func lookupsAreStableAcrossCalls() {
-        let coordinator = makeCoordinator()
-        let tableView = NSTableView()
-        attachColumns(tableView, count: 2)
-        coordinator.tableView = tableView
-        _ = coordinator.rebuildColumnMetadataCache(
-            from: TableRows.from(
-                queryRows: [],
-                columns: ["a", "b"],
-                columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: 2)
-            )
-        )
-
-        let first = coordinator.tableColumnIndex(for: 1)
-        for _ in 0..<5 {
-            #expect(coordinator.tableColumnIndex(for: 1) == first)
-        }
-    }
-
-    @Test("invalidate after a column reorder reflects the new layout")
-    func invalidateReflectsReorderedColumns() {
-        let coordinator = makeCoordinator()
-        let tableView = NSTableView()
-        attachColumns(tableView, count: 3)
-        coordinator.tableView = tableView
-        _ = coordinator.rebuildColumnMetadataCache(
-            from: TableRows.from(
-                queryRows: [],
-                columns: ["id", "name", "email"],
-                columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: 3)
-            )
-        )
-        #expect(coordinator.tableColumnIndex(for: 0) == 1)
-
-        tableView.moveColumn(1, toColumn: 3)
-        coordinator.tableViewColumnDidMove(
-            Notification(name: NSTableView.columnDidMoveNotification, object: tableView)
-        )
-
-        #expect(coordinator.tableColumnIndex(for: 0) == 3)
-        #expect(coordinator.tableColumnIndex(for: 1) == 1)
-        #expect(coordinator.tableColumnIndex(for: 2) == 2)
-    }
-
-    @Test("schema rebuild drops stale cached indices when columns shrink")
-    func schemaRebuildInvalidatesCache() {
-        let coordinator = makeCoordinator()
-        let tableView = NSTableView()
-        attachColumns(tableView, count: 2)
-        coordinator.tableView = tableView
-        _ = coordinator.rebuildColumnMetadataCache(
-            from: TableRows.from(
-                queryRows: [],
-                columns: ["a", "b"],
-                columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: 2)
-            )
-        )
-        #expect(coordinator.tableColumnIndex(for: 1) == 2)
-
-        if let second = tableView.tableColumns.last(where: {
-            $0.identifier == ColumnIdentitySchema.slotIdentifier(1)
-        }) {
-            tableView.removeTableColumn(second)
-        }
-        _ = coordinator.rebuildColumnMetadataCache(
-            from: TableRows.from(
-                queryRows: [],
-                columns: ["a"],
-                columnTypes: [ColumnType.text(rawType: nil)]
-            )
-        )
-
-        #expect(coordinator.tableColumnIndex(for: 1) == nil)
-    }
-
-    @Test("an out-of-range data column resolves to nil")
-    func outOfRangeReturnsNil() {
-        let coordinator = makeCoordinator()
-        let tableView = NSTableView()
-        attachColumns(tableView, count: 1)
-        coordinator.tableView = tableView
-        _ = coordinator.rebuildColumnMetadataCache(
-            from: TableRows.from(
-                queryRows: [],
-                columns: ["only"],
-                columnTypes: [ColumnType.text(rawType: nil)]
-            )
-        )
-
-        #expect(coordinator.tableColumnIndex(for: 5) == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/Extensions/DataGridRowMutationSelectionTests.swift b/apple/TableProTests/Views/Results/Extensions/DataGridRowMutationSelectionTests.swift
deleted file mode 100644
index 8c713bd065..0000000000
--- a/apple/TableProTests/Views/Results/Extensions/DataGridRowMutationSelectionTests.swift
+++ /dev/null
@@ -1,196 +0,0 @@
-//
-//  DataGridRowMutationSelectionTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class RowMutationLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class RowMutationStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
-@MainActor
-private struct RowMutationGrid {
-    let coordinator: TableViewCoordinator
-    let store: RowMutationStore
-    let tableView: KeyHandlingTableView
-}
-
-@MainActor
-struct DataGridRowMutationSelectionTests {
-    private static let columns = ["id", "name"]
-    private static let columnTypes: [ColumnType] = [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-
-    private func makeGrid(rowCount: Int) -> RowMutationGrid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: RowMutationLayoutPersister()
-        )
-        let store = RowMutationStore(TableRows.from(
-            queryRows: (0..<rowCount).map { [.text("\($0)"), .text("name-\($0)")] },
-            columns: Self.columns,
-            columnTypes: Self.columnTypes
-        ))
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.rebuildColumnMetadataCache(from: store.tableRows)
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: Self.columns),
-            columnTypes: Self.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.updateCache()
-        tableView.reloadData()
-        return RowMutationGrid(coordinator: coordinator, store: store, tableView: tableView)
-    }
-
-    private static func block(rows: ClosedRange<Int>) -> GridSelection {
-        .single(
-            GridRect(rows: rows, columns: 0...1),
-            anchor: GridCoord(row: rows.lowerBound, displayColumn: 0),
-            active: GridCoord(row: rows.upperBound, displayColumn: 1)
-        )
-    }
-
-    private func selectedRecords(_ coordinator: TableViewCoordinator) -> [RowID] {
-        coordinator.selectionController.selection.affectedRows.compactMap { coordinator.displayRow(at: $0)?.id }
-    }
-
-    @Test("discarding an inserted row above the selection keeps the selection on the same records")
-    func discardingInsertedRowShiftsSelection() {
-        let grid = makeGrid(rowCount: 5)
-        let coordinator = grid.coordinator
-        let insertedID = RowID.inserted(UUID())
-        coordinator.applyDelta(coordinator.tableRowsMutator { rows in
-            rows.insertInsertedRow(at: 1, id: insertedID, values: [.text("9"), .text("new")])
-        })
-        coordinator.selectionController.update(Self.block(rows: 3...4))
-        #expect(selectedRecords(coordinator) == [.existing(2), .existing(3)])
-
-        coordinator.applyDelta(coordinator.tableRowsMutator { rows in rows.remove(rowIDs: [insertedID]) })
-
-        #expect(coordinator.selectionController.selection.rectangles == [GridRect(rows: 2...3, columns: 0...1)])
-        #expect(selectedRecords(coordinator) == [.existing(2), .existing(3)])
-        #expect(grid.tableView.numberOfRows == 5)
-    }
-
-    @Test("a row added above the selection moves the selection down with its records")
-    func insertingRowAboveShiftsSelection() {
-        let grid = makeGrid(rowCount: 5)
-        let coordinator = grid.coordinator
-        coordinator.selectionController.update(Self.block(rows: 1...2))
-
-        coordinator.applyDelta(coordinator.tableRowsMutator { rows in
-            rows.insertInsertedRow(at: 0, values: [.text("9"), .text("new")])
-        })
-
-        #expect(coordinator.selectionController.selection.rectangles == [GridRect(rows: 2...3, columns: 0...1)])
-        #expect(selectedRecords(coordinator) == [.existing(1), .existing(2)])
-        #expect(grid.tableView.numberOfRows == 6)
-    }
-
-    @Test("under a value filter a row change drops the cell selection instead of shifting it")
-    func valueFilterDropsSelection() {
-        let grid = makeGrid(rowCount: 5)
-        let coordinator = grid.coordinator
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["1", "2", "3"], includesNull: false),
-            columnName: "id",
-            forColumn: 0
-        )
-        coordinator.selectionController.update(Self.block(rows: 0...1))
-        #expect(!coordinator.selectionController.isEmpty)
-
-        coordinator.applyDelta(coordinator.tableRowsMutator { rows in rows.remove(rowIDs: [.existing(4)]) })
-
-        #expect(coordinator.selectionController.isEmpty)
-        #expect(grid.tableView.numberOfRows == coordinator.cachedRowCount)
-    }
-
-    private func focus(row: Int, dataColumn: Int, in grid: RowMutationGrid) {
-        grid.tableView.selectRowIndexes(IndexSet(integer: row), byExtendingSelection: false)
-        grid.tableView.focusedRow = row
-        grid.tableView.focusedColumn = grid.coordinator.tableColumnIndex(for: dataColumn) ?? -1
-    }
-
-    /// AppKit shifts the selected rows on an insert without posting a selection change, so the
-    /// cursor stayed on the old index: the focus ring sat on another record and Paste anchored there.
-    @Test("a row added above the cursor moves the cursor with its record")
-    func insertingRowAboveShiftsCursor() {
-        let grid = makeGrid(rowCount: 5)
-        focus(row: 2, dataColumn: 1, in: grid)
-        #expect(grid.tableView.pasteAnchorCell()?.row == 2)
-
-        grid.coordinator.applyDelta(grid.coordinator.tableRowsMutator { rows in
-            rows.insertInsertedRow(at: 0, values: [.text("9"), .text("new")])
-        })
-
-        #expect(grid.tableView.focusedRow == 3)
-        #expect(grid.tableView.focusedRow == grid.tableView.selectedRow)
-        #expect(grid.coordinator.displayRow(at: grid.tableView.focusedRow)?.id == .existing(2))
-        #expect(grid.tableView.pasteAnchorCell()?.row == 3)
-    }
-
-    @Test("a row added below the cursor leaves it where it is")
-    func insertingRowBelowKeepsCursor() {
-        let grid = makeGrid(rowCount: 5)
-        focus(row: 2, dataColumn: 1, in: grid)
-
-        grid.coordinator.applyDelta(grid.coordinator.tableRowsMutator { rows in
-            rows.insertInsertedRow(at: 4, values: [.text("9"), .text("new")])
-        })
-
-        #expect(grid.tableView.focusedRow == 2)
-        #expect(grid.coordinator.displayRow(at: grid.tableView.focusedRow)?.id == .existing(2))
-    }
-
-    @Test("removing a row above the cursor moves it up, and removing its own row clears it")
-    func removingRowsShiftsOrClearsCursor() {
-        let grid = makeGrid(rowCount: 5)
-        focus(row: 3, dataColumn: 1, in: grid)
-
-        grid.coordinator.applyDelta(grid.coordinator.tableRowsMutator { rows in rows.remove(rowIDs: [.existing(0)]) })
-
-        #expect(grid.tableView.focusedRow == 2)
-        #expect(grid.tableView.focusedRow == grid.tableView.selectedRow)
-        #expect(grid.coordinator.displayRow(at: grid.tableView.focusedRow)?.id == .existing(3))
-
-        grid.coordinator.applyDelta(grid.coordinator.tableRowsMutator { rows in rows.remove(rowIDs: [.existing(3)]) })
-
-        #expect(grid.tableView.focusedRow == -1)
-        #expect(grid.tableView.pasteAnchorCell()?.row == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/Extensions/DataGridSelectionTests.swift b/apple/TableProTests/Views/Results/Extensions/DataGridSelectionTests.swift
deleted file mode 100644
index 94c76b273c..0000000000
--- a/apple/TableProTests/Views/Results/Extensions/DataGridSelectionTests.swift
+++ /dev/null
@@ -1,207 +0,0 @@
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import Testing
-
-@MainActor
-private final class FakeColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class SelectionBox {
-    var value: Set<Int> = []
-    private(set) var writeCount = 0
-
-    func binding() -> Binding<Set<Int>> {
-        Binding(get: { self.value }, set: { newValue in
-            self.value = newValue
-            self.writeCount += 1
-        })
-    }
-}
-
-private final class StubTableView: NSTableView {
-    var stubbedSelection = IndexSet()
-    override var selectedRowIndexes: IndexSet { stubbedSelection }
-}
-
-@MainActor
-struct DataGridSelectionTests {
-    private func makeCoordinator(box: SelectionBox) -> TableViewCoordinator {
-        TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: box.binding(),
-            delegate: nil,
-            layoutPersister: FakeColumnLayoutPersister()
-        )
-    }
-
-    private func notifySelectionChange(_ coordinator: TableViewCoordinator, rows: IndexSet) {
-        let tableView = StubTableView()
-        tableView.stubbedSelection = rows
-        coordinator.tableViewSelectionDidChange(
-            Notification(name: NSTableView.selectionDidChangeNotification, object: tableView)
-        )
-    }
-
-    @Test("mouse selection updates the row binding even while a programmatic selection is in flight")
-    func mouseSelectionUpdatesBindingDuringProgrammaticSelection() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-        coordinator.isApplyingProgrammaticRowSelection = true
-
-        notifySelectionChange(coordinator, rows: IndexSet(integer: 5))
-
-        #expect(box.value == [5])
-    }
-
-    @Test("keyboard selection updates the row binding")
-    func keyboardSelectionUpdatesBinding() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-
-        notifySelectionChange(coordinator, rows: IndexSet(integer: 2))
-
-        #expect(box.value == [2])
-    }
-
-    @Test("deselecting all rows clears the row binding")
-    func emptySelectionClearsBinding() {
-        let box = SelectionBox()
-        box.value = [4]
-        let coordinator = makeCoordinator(box: box)
-
-        notifySelectionChange(coordinator, rows: IndexSet())
-
-        #expect(box.value.isEmpty)
-    }
-
-    @Test("an unchanged selection does not rewrite the row binding")
-    func unchangedSelectionDoesNotRewriteBinding() {
-        let box = SelectionBox()
-        box.value = [3]
-        let coordinator = makeCoordinator(box: box)
-
-        notifySelectionChange(coordinator, rows: IndexSet(integer: 3))
-
-        #expect(box.writeCount == 0)
-    }
-}
-
-@MainActor
-struct PublishedRowSelectionTests {
-    private func makeCoordinator(box: SelectionBox) -> TableViewCoordinator {
-        TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: box.binding(),
-            delegate: nil,
-            layoutPersister: FakeColumnLayoutPersister()
-        )
-    }
-
-    @Test("a cell range publishes every row it covers, not the anchor row")
-    func cellRangePublishesEveryCoveredRow() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-
-        coordinator.selectionController.update(
-            .single(
-                GridRect(rows: 1...6, columns: 0...0),
-                anchor: GridCoord(row: 1, displayColumn: 0),
-                active: GridCoord(row: 6, displayColumn: 0)
-            )
-        )
-        coordinator.publishRowSelection(rowSelection: [1])
-
-        #expect(box.value == [1, 2, 3, 4, 5, 6])
-        #expect(coordinator.currentRowSelection() == [1, 2, 3, 4, 5, 6])
-    }
-
-    @Test("two discontiguous cells publish both of their rows")
-    func discontiguousCellsPublishBothRows() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-
-        coordinator.selectionController.update(
-            GridSelection(
-                rectangles: [GridRect(cell: GridCoord(row: 3, displayColumn: 0)), GridRect(cell: GridCoord(row: 17, displayColumn: 2))],
-                activeCell: GridCoord(row: 17, displayColumn: 2),
-                anchor: GridCoord(row: 3, displayColumn: 0)
-            )
-        )
-        coordinator.publishRowSelection(rowSelection: [17])
-
-        #expect(box.value == [3, 17])
-    }
-
-    @Test("with no cell selection the row selection is published unchanged")
-    func rowSelectionPublishesUnchanged() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-
-        coordinator.publishRowSelection(rowSelection: [2, 3])
-
-        #expect(box.value == [2, 3])
-    }
-
-    @Test("clearing the cell selection falls back to the row selection")
-    func clearingCellSelectionFallsBack() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-
-        coordinator.selectionController.update(
-            .single(
-                GridRect(rows: 4...9, columns: 0...0),
-                anchor: GridCoord(row: 4, displayColumn: 0),
-                active: GridCoord(row: 9, displayColumn: 0)
-            )
-        )
-        coordinator.publishRowSelection(rowSelection: [4])
-        #expect(box.value == [4, 5, 6, 7, 8, 9])
-
-        coordinator.selectionController.clear()
-        coordinator.publishRowSelection(rowSelection: [4])
-
-        #expect(box.value == [4])
-    }
-
-    @Test("publishing records what it wrote so an unchanged value is not written twice")
-    func publishRecordsWhatItWrote() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-
-        #expect(coordinator.lastPublishedRowSelection == nil)
-
-        coordinator.publishRowSelection(rowSelection: [8])
-        #expect(coordinator.lastPublishedRowSelection == [8])
-        let afterFirst = box.writeCount
-
-        coordinator.publishRowSelection(rowSelection: [8])
-        #expect(box.writeCount == afterFirst)
-    }
-
-    @Test("the grid selection controller publishes through its change hook")
-    func selectionControllerHookPublishes() {
-        let box = SelectionBox()
-        let coordinator = makeCoordinator(box: box)
-        coordinator.selectionController.onSelectionChange = { [weak coordinator] _ in
-            coordinator?.publishRowSelection()
-        }
-
-        coordinator.selectionController.update(
-            .single(
-                GridRect(rows: 2...5, columns: 1...3),
-                anchor: GridCoord(row: 2, displayColumn: 1),
-                active: GridCoord(row: 5, displayColumn: 3)
-            )
-        )
-
-        #expect(box.value == [2, 3, 4, 5])
-    }
-}
diff --git a/apple/TableProTests/Views/Results/Extensions/DataGridSetCellsToValueTests.swift b/apple/TableProTests/Views/Results/Extensions/DataGridSetCellsToValueTests.swift
index 77c969e4ca..c766504cd9 100644
--- a/apple/TableProTests/Views/Results/Extensions/DataGridSetCellsToValueTests.swift
+++ b/apple/TableProTests/Views/Results/Extensions/DataGridSetCellsToValueTests.swift
@@ -5,46 +5,12 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
 @MainActor
-private final class CellsToValueLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class CellsToValueRowStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
-@MainActor
-private final class CellsToValueUndoWindow: NSWindow {
-    let undo = UndoManager()
-
-    override var undoManager: UndoManager? { undo }
-}
-
-@MainActor
-private final class OwnCommandDelegate: DataGridViewDelegate {
-    private(set) var handedTargets: [[SetValueTarget]] = []
-
-    func dataGridSetCellsToValue(_ targets: [SetValueTarget]) -> Bool {
-        handedTargets.append(targets)
-        return true
-    }
-}
-
-@MainActor
-private struct CellsToValueFixture {
+private enum CellsToValueFixture {
     static let columns = ["id", "note", "label", "seen", "born", "calc", "payload"]
     static let id = 0
     static let note = 1
@@ -54,26 +20,15 @@ private struct CellsToValueFixture {
     static let calc = 5
     static let payload = 6
 
-    let manager: DataChangeManager
-    let coordinator: TableViewCoordinator
-    let store: CellsToValueRowStore
-
-    init(rowCount: Int = 4, selectedRows: Set<Int> = []) {
-        manager = DataChangeManager()
+    static func grid(rowCount: Int = 4) -> CommandGrid {
+        let manager = DataChangeManager()
         manager.configureForTable(
             tableName: "things",
-            columns: Self.columns,
+            columns: columns,
             primaryKeyColumns: ["id"],
             databaseType: .postgresql,
             generatedColumns: ["calc"]
         )
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(manager),
-            isEditable: true,
-            selectedRowIndices: .constant(selectedRows),
-            delegate: nil,
-            layoutPersister: CellsToValueLayoutPersister()
-        )
         let rows: [[PluginCellValue]] = (0..<rowCount).map { row in
             [
                 .text("00000000-0000-0000-0000-00000000000\(row)"),
@@ -82,246 +37,200 @@ private struct CellsToValueFixture {
                 .text("2024-01-0\(row + 1) 10:00:00+00"),
                 .text("2024-01-0\(row + 1)"),
                 .text("c\(row)"),
-                .null
+                .null,
             ]
         }
-        store = CellsToValueRowStore(TableRows.from(
-            queryRows: rows,
-            columns: Self.columns,
-            columnTypes: [
-                .text(rawType: "uuid"),
-                .text(rawType: "text"),
-                .text(rawType: "text"),
-                .timestamp(rawType: "timestamptz"),
-                .date(rawType: "date"),
-                .text(rawType: "text"),
-                .blob(rawType: "bytea")
-            ],
-            columnNullable: [
-                "id": false, "note": true, "label": false, "seen": true, "born": false, "calc": true, "payload": true
-            ]
-        ))
-        let store = store
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-        coordinator.databaseType = .postgresql
-        coordinator.rebuildColumnMetadataCache(from: store.tableRows)
-        coordinator.updateCache()
-    }
-
-    func staged(row: Int, column: Int) -> PluginCellValue? {
-        manager.pending.change(forRow: .existing(row), type: .update)?
-            .cellChanges.first { $0.columnIndex == column }?.newValue
-    }
-
-    func select(rows: ClosedRange<Int>, columns: ClosedRange<Int>) {
-        coordinator.selectionController.update(.single(
-            GridRect(rows: rows, columns: columns),
-            anchor: GridCoord(row: rows.lowerBound, displayColumn: columns.lowerBound),
-            active: GridCoord(row: rows.upperBound, displayColumn: columns.upperBound)
-        ))
-    }
-
-    func cell(_ row: Int, _ column: Int) -> SetValueTarget {
-        SetValueTarget(displayRow: row, columnIndex: column)
+        return CommandGrid(
+            TableRows.from(
+                queryRows: rows,
+                columns: columns,
+                columnTypes: [
+                    .text(rawType: "uuid"),
+                    .text(rawType: "text"),
+                    .text(rawType: "text"),
+                    .timestamp(rawType: "timestamptz"),
+                    .date(rawType: "date"),
+                    .text(rawType: "text"),
+                    .blob(rawType: "bytea"),
+                ],
+                columnNullable: [
+                    "id": false, "note": true, "label": false, "seen": true, "born": false, "calc": true, "payload": true,
+                ]
+            ),
+            changeManager: manager
+        )
     }
 
-    func selectedTargets() -> [SetValueTarget] {
-        coordinator.setValueTargets(clicked: nil)
+    static func cell(_ grid: CommandGrid, _ row: Int, _ column: Int) -> DataGridCommandCell? {
+        guard let rowID = grid.model.rowID(at: row), let column = grid.model.columns.column(at: column) else { return nil }
+        return DataGridCommandCell(rowID: rowID, row: row, column: column)
     }
 
-    func setCellsToValue(_ text: String) {
-        coordinator.applyCellsToValue(text, to: coordinator.setCellsToValueCells(selectedTargets()))
+    static func selectedCells(_ grid: CommandGrid) -> [DataGridCommandCell] {
+        grid.commands.cells(.current(grid.model.selection))
     }
 
-    func deleteRow(_ row: Int) {
-        manager.recordRowDeletion(rowID: .existing(row), originalRow: Array(store.tableRows.rows[row].values))
+    static func setCellsToValue(_ text: String, in grid: CommandGrid) {
+        let commands = grid.commands
+        commands.applyEnteredText(text, to: selectedCells(grid).filter { commands.typingCanEdit($0) })
     }
 
-    func attachUndoWindow() -> CellsToValueUndoWindow {
-        let window = CellsToValueUndoWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 400, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: true
-        )
-        window.isReleasedWhenClosed = false
-        window.undo.groupsByEvent = false
-        let tableView = KeyHandlingTableView()
-        window.contentView?.addSubview(tableView)
-        tableView.coordinator = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        // Built through the column pool, so the selection's display positions resolve to the grid's own columns.
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: [],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.invalidateColumnIndexCache()
-        let undo = window.undo
-        manager.undoManagerProvider = { undo }
-        return window
+    static func deleteRow(_ row: Int, in grid: CommandGrid) {
+        grid.owner.changeManager.recordRowDeletion(rowID: .existing(row), originalRow: Array(grid.owner.tableRows.rows[row].values))
     }
 }
 
 @MainActor
 struct DataGridSetCellsToValueTests {
-    @Test("The typed value goes into every selected cell and no other")
+    private typealias Fixture = CellsToValueFixture
+
+    @Test("The typed value goes into every selected cell and no other, as one commit named Set Cells to Value")
     func writesEverySelectedCell() {
-        let fixture = CellsToValueFixture()
-        fixture.select(rows: 0...2, columns: CellsToValueFixture.note...CellsToValueFixture.note)
+        let grid = Fixture.grid()
+        grid.select(rows: 0...2, columns: Fixture.note...Fixture.note)
 
-        fixture.setCellsToValue("archived")
+        Fixture.setCellsToValue("archived", in: grid)
 
         for row in 0...2 {
-            #expect(fixture.staged(row: row, column: CellsToValueFixture.note) == .text("archived"))
-            #expect(fixture.store.tableRows.rows[row].values[CellsToValueFixture.note] == .text("archived"))
+            #expect(grid.owner.staged(row, Fixture.note)?.value == .text("archived"))
+            #expect(grid.owner.tableRows.rows[row].values[Fixture.note] == .text("archived"))
         }
-        #expect(fixture.staged(row: 3, column: CellsToValueFixture.note) == nil)
-        #expect(fixture.store.tableRows.rows[3].values[CellsToValueFixture.note] == .text("n3"))
-        #expect(fixture.staged(row: 0, column: CellsToValueFixture.label) == nil)
+        #expect(grid.owner.staged(3, Fixture.note) == nil)
+        #expect(grid.owner.staged(0, Fixture.label) == nil)
+        #expect(grid.owner.commits.map { $0.actionName } == [String(localized: "Set Cells to Value")])
     }
 
     @Test("A server-owned column, a binary column and a deleted row are left out of the cells it writes")
     func leavesOutCellsTypingCannotEdit() {
-        let fixture = CellsToValueFixture()
-        fixture.deleteRow(1)
-        fixture.select(rows: 0...1, columns: CellsToValueFixture.born...CellsToValueFixture.payload)
-        let targets = fixture.selectedTargets()
+        let grid = Fixture.grid()
+        Fixture.deleteRow(1, in: grid)
+        grid.select(rows: 0...1, columns: Fixture.born...Fixture.payload)
+        let targets = Fixture.selectedCells(grid)
 
-        let cells = fixture.coordinator.setCellsToValueCells(targets)
+        let cells = targets.filter { grid.commands.typingCanEdit($0) }
 
         #expect(targets.count == 6)
-        #expect(cells == [fixture.cell(0, CellsToValueFixture.born)])
-        #expect(fixture.coordinator.isSetCellsToValueOffered(for: targets))
+        #expect(cells == [Fixture.cell(grid, 0, Fixture.born)].compactMap { $0 })
+        #expect(grid.commands.isSetCellsToValueOffered(for: targets))
     }
 
     @Test("Nothing is offered where typing could edit no cell")
     func notOfferedWithoutAnEditableCell() {
-        let fixture = CellsToValueFixture()
-        let readOnly = [fixture.cell(0, CellsToValueFixture.calc), fixture.cell(1, CellsToValueFixture.payload)]
+        let grid = Fixture.grid()
+        let readOnly = [Fixture.cell(grid, 0, Fixture.calc), Fixture.cell(grid, 1, Fixture.payload)].compactMap { $0 }
 
-        #expect(!fixture.coordinator.isSetCellsToValueOffered(for: readOnly))
-        #expect(!fixture.coordinator.isSetCellsToValueOffered(for: []))
+        #expect(!grid.commands.isSetCellsToValueOffered(for: readOnly))
+        #expect(!grid.commands.isSetCellsToValueOffered(for: []))
 
-        fixture.coordinator.isEditable = false
-        #expect(!fixture.coordinator.isSetCellsToValueOffered(for: [fixture.cell(0, CellsToValueFixture.note)]))
+        grid.model.configuration.isEditable = false
+        #expect(!grid.commands.isSetCellsToValueOffered(for: [Fixture.cell(grid, 0, Fixture.note)].compactMap { $0 }))
     }
 
     @Test("The sheet says how many cells take the value, and how many it skips")
     func impactCountsTheCells() {
-        #expect(TableViewCoordinator.setCellsToValueImpact(cells: 1, targets: 1) == "This sets 1 cell.")
-        #expect(TableViewCoordinator.setCellsToValueImpact(cells: 40, targets: 40) == "This sets 40 cells.")
+        #expect(DataGridCommands.setCellsToValueImpact(cells: 1, targets: 1) == "This sets 1 cell.")
+        #expect(DataGridCommands.setCellsToValueImpact(cells: 40, targets: 40) == "This sets 40 cells.")
         #expect(
-            TableViewCoordinator.setCellsToValueImpact(cells: 38, targets: 40)
+            DataGridCommands.setCellsToValueImpact(cells: 38, targets: 40)
                 == "This sets 38 of 40 cells. The others cannot be edited."
         )
     }
 
-    @Test("Every cell it writes is one undo step, named Set Cells to Value")
-    func oneUndoStep() {
-        let fixture = CellsToValueFixture()
-        let window = fixture.attachUndoWindow()
-        defer { window.orderOut(nil) }
-        fixture.select(rows: 0...3, columns: CellsToValueFixture.note...CellsToValueFixture.label)
-
-        fixture.setCellsToValue("archived")
-
-        #expect(window.undo.undoActionName == "Set Cells to Value")
-        window.undo.undo()
-        #expect(!window.undo.canUndo)
-        #expect(!fixture.manager.hasChanges)
-    }
-
     @Test("A column that holds neither the text nor NULL keeps its cells, and the others take it")
     func refusingColumnKeepsItsCells() {
-        let fixture = CellsToValueFixture()
-        fixture.select(rows: 0...1, columns: CellsToValueFixture.note...CellsToValueFixture.born)
+        let grid = Fixture.grid()
+        grid.select(rows: 0...1, columns: Fixture.note...Fixture.born)
 
-        fixture.setCellsToValue("")
+        Fixture.setCellsToValue("", in: grid)
 
-        #expect(fixture.staged(row: 0, column: CellsToValueFixture.note) == .text(""))
-        #expect(fixture.staged(row: 1, column: CellsToValueFixture.seen) == .null)
-        #expect(fixture.staged(row: 0, column: CellsToValueFixture.born) == nil)
-        #expect(fixture.store.tableRows.rows[1].values[CellsToValueFixture.born] == .text("2024-01-02"))
+        #expect(grid.owner.staged(0, Fixture.note)?.value == .text(""))
+        #expect(grid.owner.staged(1, Fixture.seen)?.value == .null)
+        #expect(grid.owner.staged(0, Fixture.born) == nil)
+        #expect(grid.owner.tableRows.rows[1].values[Fixture.born] == .text("2024-01-02"))
     }
 
     @Test("A function name stages as SQL on a timestamp and as text on a text column, as typing it does")
     func functionIsReadPerColumn() {
-        let fixture = CellsToValueFixture()
-        fixture.select(rows: 0...0, columns: CellsToValueFixture.note...CellsToValueFixture.seen)
+        let grid = Fixture.grid()
+        grid.select(rows: 0...0, columns: Fixture.note...Fixture.seen)
 
-        fixture.setCellsToValue("now()")
+        Fixture.setCellsToValue("now()", in: grid)
 
-        #expect(fixture.staged(row: 0, column: CellsToValueFixture.seen) == .text("now()"))
-        #expect(fixture.manager.isExpression(rowID: .existing(0), columnIndex: CellsToValueFixture.seen))
-        #expect(fixture.staged(row: 0, column: CellsToValueFixture.note) == .text("now()"))
-        #expect(!fixture.manager.isExpression(rowID: .existing(0), columnIndex: CellsToValueFixture.note))
+        #expect(grid.owner.staged(0, Fixture.seen)?.value == .text("now()"))
+        #expect(grid.owner.staged(0, Fixture.seen)?.isExpression == true)
+        #expect(grid.owner.staged(0, Fixture.note)?.value == .text("now()"))
+        #expect(grid.owner.staged(0, Fixture.note)?.isExpression == false)
     }
 
     @Test("With whole rows selected the clicked column is written on each of them")
     func clickedColumnOnSelectedRows() {
-        let fixture = CellsToValueFixture(selectedRows: [0, 2])
-        let targets = fixture.coordinator.setValueTargets(clicked: fixture.cell(2, CellsToValueFixture.note))
+        let grid = Fixture.grid()
+        grid.model.setSelection(GridSelection(
+            rectangles: [GridRect(rows: 0...0, columns: 0...6), GridRect(rows: 2...2, columns: 0...6)],
+            activeCell: GridCoord(row: 2, displayColumn: 0),
+            anchor: GridCoord(row: 0, displayColumn: 0)
+        ))
+        let scope = DataGridCommandScope.contextMenu(selection: grid.model.selection, row: 2, displayColumn: Fixture.note, columnCount: 7)
 
-        fixture.coordinator.applyCellsToValue("archived", to: fixture.coordinator.setCellsToValueCells(targets))
+        grid.commands.applyEnteredText("archived", to: grid.commands.cells(scope))
 
-        #expect(fixture.staged(row: 0, column: CellsToValueFixture.note) == .text("archived"))
-        #expect(fixture.staged(row: 1, column: CellsToValueFixture.note) == nil)
-        #expect(fixture.staged(row: 2, column: CellsToValueFixture.note) == .text("archived"))
+        #expect(grid.owner.staged(0, Fixture.note)?.value == .text("archived"))
+        #expect(grid.owner.staged(1, Fixture.note) == nil)
+        #expect(grid.owner.staged(2, Fixture.note)?.value == .text("archived"))
     }
 
     @Test("A window with its own Set Cells to Value runs it, and the grid stages nothing")
     func windowCommandTakesOver() {
-        let fixture = CellsToValueFixture()
-        let delegate = OwnCommandDelegate()
-        fixture.coordinator.delegate = delegate
-        fixture.select(rows: 0...1, columns: CellsToValueFixture.note...CellsToValueFixture.note)
+        let grid = Fixture.grid()
+        grid.owner.runsSetCellsToValue = true
+        grid.select(rows: 0...1, columns: Fixture.note...Fixture.note)
 
-        fixture.coordinator.setCellsToValue(fixture.selectedTargets())
+        grid.controller.setCellsToValue(nil)
 
-        #expect(delegate.handedTargets == [[fixture.cell(0, CellsToValueFixture.note), fixture.cell(1, CellsToValueFixture.note)]])
-        #expect(!fixture.manager.hasChanges)
+        let handed = grid.owner.setCellsToValueRequests
+        #expect(handed.map { $0.map { $0.rowID } } == [[.existing(0), .existing(1)]])
+        #expect(handed.map { $0.map { $0.column } } == [["note", "note"]])
+        #expect(grid.owner.commits.isEmpty)
     }
 
-    @Test("The records under the sheet are found again after a sort or a value filter moves them")
+    @Test("The records under the sheet are found again after a value filter moves them")
     func recordsFollowTheirRows() throws {
-        let fixture = CellsToValueFixture()
-        let records = SetCellsToValueRecords(
-            [fixture.cell(1, CellsToValueFixture.note), fixture.cell(3, CellsToValueFixture.label)],
-            in: fixture.coordinator
+        let grid = Fixture.grid()
+        let records = DataGridCellRecords(
+            [Fixture.cell(grid, 1, Fixture.note), Fixture.cell(grid, 3, Fixture.label)].compactMap { $0 },
+            in: grid.model
         )
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["n1", "n2", "n3"], includesNull: false), columnName: "note", forColumn: Fixture.note)
+        grid.model.setValueFilter(filter)
 
-        fixture.coordinator.valueFilteredIDs = [.existing(3), .existing(2), .existing(1)]
+        let moved = try #require(records.current(in: grid.model))
 
-        let moved = try #require(records.targets(in: fixture.coordinator))
-        #expect(moved == [fixture.cell(2, CellsToValueFixture.note), fixture.cell(0, CellsToValueFixture.label)])
+        #expect(moved.map { $0.row } == [0, 2])
+        #expect(moved.map { $0.column.name } == ["note", "label"])
     }
 
     @Test("A load that replaces the records under the sheet drops the write")
     func replacedRecordsDropTheWrite() {
-        let fixture = CellsToValueFixture()
-        let records = SetCellsToValueRecords([fixture.cell(1, CellsToValueFixture.note)], in: fixture.coordinator)
+        let grid = Fixture.grid()
+        let records = DataGridCellRecords([Fixture.cell(grid, 1, Fixture.note)].compactMap { $0 }, in: grid.model)
 
-        _ = fixture.store.tableRows.edit(row: 1, column: CellsToValueFixture.label, value: .text("reloaded"))
+        _ = grid.owner.tableRows.edit(row: 1, column: Fixture.label, value: .text("reloaded"))
+        grid.model.reloadRows()
 
-        #expect(records.targets(in: fixture.coordinator) == nil)
+        #expect(records.current(in: grid.model) == nil)
     }
 
     @Test("A record a value filter now hides drops the write")
     func hiddenRecordDropsTheWrite() {
-        let fixture = CellsToValueFixture()
-        let records = SetCellsToValueRecords([fixture.cell(1, CellsToValueFixture.note)], in: fixture.coordinator)
+        let grid = Fixture.grid()
+        let records = DataGridCellRecords([Fixture.cell(grid, 1, Fixture.note)].compactMap { $0 }, in: grid.model)
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["n0", "n2"], includesNull: false), columnName: "note", forColumn: Fixture.note)
 
-        fixture.coordinator.valueFilteredIDs = [.existing(0), .existing(2)]
+        grid.model.setValueFilter(filter)
 
-        #expect(records.targets(in: fixture.coordinator) == nil)
+        #expect(records.current(in: grid.model) == nil)
     }
 }
 
@@ -329,92 +238,69 @@ extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
     struct DataGridPasteIntoSelectionTests {
-        @Test("One pasted value goes into every selected cell, as one undo step")
+        private typealias Fixture = CellsToValueFixture
+
+        @Test("One pasted value goes into every selected cell, as one commit named Paste Cells")
         func singleValueFillsTheSelection() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-            clipboard.text = "archived"
-            let fixture = CellsToValueFixture()
-            let window = fixture.attachUndoWindow()
-            defer { window.orderOut(nil) }
-            fixture.select(rows: 0...2, columns: CellsToValueFixture.note...CellsToValueFixture.label)
+            try #require(RecordingClipboard.current).text = "archived"
+            let grid = Fixture.grid()
+            grid.select(rows: 0...2, columns: Fixture.note...Fixture.label)
 
-            #expect(fixture.coordinator.pasteValueIntoSelectedCells())
+            grid.controller.paste(nil)
 
             for row in 0...2 {
-                #expect(fixture.staged(row: row, column: CellsToValueFixture.note) == .text("archived"))
-                #expect(fixture.staged(row: row, column: CellsToValueFixture.label) == .text("archived"))
+                #expect(grid.owner.staged(row, Fixture.note)?.value == .text("archived"))
+                #expect(grid.owner.staged(row, Fixture.label)?.value == .text("archived"))
             }
-            #expect(fixture.staged(row: 3, column: CellsToValueFixture.note) == nil)
-            #expect(window.undo.undoActionName == "Paste Cells")
-            window.undo.undo()
-            #expect(!fixture.manager.hasChanges)
-        }
-
-        @Test("Paste in the grid fills a cell selection rather than only the focused cell")
-        func pasteCommandFillsTheSelection() throws {
-            try #require(RecordingClipboard.current).text = "archived"
-            let fixture = CellsToValueFixture()
-            let window = fixture.attachUndoWindow()
-            defer { window.orderOut(nil) }
-            let tableView = try #require(fixture.coordinator.tableView as? KeyHandlingTableView)
-            fixture.select(rows: 1...2, columns: CellsToValueFixture.note...CellsToValueFixture.note)
-
-            tableView.paste(nil)
-
-            #expect(fixture.staged(row: 1, column: CellsToValueFixture.note) == .text("archived"))
-            #expect(fixture.staged(row: 2, column: CellsToValueFixture.note) == .text("archived"))
-            #expect(fixture.staged(row: 0, column: CellsToValueFixture.note) == nil)
+            #expect(grid.owner.staged(3, Fixture.note) == nil)
+            #expect(grid.owner.commits.map { $0.actionName } == [String(localized: "Paste Cells")])
         }
 
         @Test("A NULL copied from the grid fills nullable cells and leaves a NOT NULL column alone")
         func copiedNullFillsWhereItFits() throws {
-            let fixture = CellsToValueFixture()
-            fixture.coordinator.copyCellValue(at: 0, columnIndex: CellsToValueFixture.payload)
-            #expect(try #require(RecordingClipboard.current).gridCells?.fields == [[nil]])
-            fixture.select(rows: 1...2, columns: CellsToValueFixture.note...CellsToValueFixture.label)
-
-            #expect(fixture.coordinator.pasteValueIntoSelectedCells())
-
-            #expect(fixture.staged(row: 1, column: CellsToValueFixture.note) == .null)
-            #expect(fixture.staged(row: 2, column: CellsToValueFixture.note) == .null)
-            #expect(fixture.staged(row: 1, column: CellsToValueFixture.label) == nil)
-            #expect(fixture.store.tableRows.rows[2].values[CellsToValueFixture.label] == .text("l2"))
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = Fixture.grid()
+            grid.selectCell(0, Fixture.payload)
+            grid.controller.copy(nil)
+            #expect(clipboard.gridCells?.fields == [[nil]])
+            grid.select(rows: 1...2, columns: Fixture.note...Fixture.label)
+
+            grid.controller.paste(nil)
+
+            #expect(grid.owner.staged(1, Fixture.note)?.value == .null)
+            #expect(grid.owner.staged(2, Fixture.note)?.value == .null)
+            #expect(grid.owner.staged(1, Fixture.label) == nil)
+            #expect(grid.owner.tableRows.rows[2].values[Fixture.label] == .text("l2"))
         }
 
-        @Test("A block, or a single selected cell, keeps the paste anchored at the focused cell")
+        @Test("A block, or a single selected cell, keeps the paste anchored at the cursor")
         func blockOrOneCellKeepsTheAnchor() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let fixture = CellsToValueFixture()
+            let grid = Fixture.grid()
 
             clipboard.text = "a\tb"
-            fixture.select(rows: 0...1, columns: CellsToValueFixture.note...CellsToValueFixture.label)
-            #expect(!fixture.coordinator.canPasteValueIntoSelectedCells())
-            #expect(!fixture.coordinator.pasteValueIntoSelectedCells())
+            grid.select(rows: 0...1, columns: Fixture.note...Fixture.label, active: GridCoord(row: 0, displayColumn: Fixture.note))
+            let block = try #require(DataGridCellPasteBlock.fromClipboard())
+            #expect(grid.commands.pasteFillTargets(.current(grid.model.selection), block: block) == nil)
 
             clipboard.text = "a"
-            fixture.select(rows: 0...0, columns: CellsToValueFixture.note...CellsToValueFixture.note)
-            #expect(!fixture.coordinator.canPasteValueIntoSelectedCells())
-            #expect(!fixture.coordinator.pasteValueIntoSelectedCells())
-
-            fixture.coordinator.selectionController.clear()
-            #expect(!fixture.coordinator.pasteValueIntoSelectedCells())
-            #expect(!fixture.manager.hasChanges)
+            grid.selectCell(0, Fixture.note)
+            let single = try #require(DataGridCellPasteBlock.fromClipboard())
+            #expect(grid.commands.pasteFillTargets(.current(grid.model.selection), block: single) == nil)
+            #expect(grid.commands.pasteAnchor(.current(grid.model.selection), block: single) == GridCoord(row: 0, displayColumn: Fixture.note))
         }
 
-        @Test("Paste is enabled over a cell selection with no focused cell when one value is on the clipboard")
-        func pasteIsEnabledWithoutAFocusedCell() throws {
+        @Test("Paste is enabled over a cell selection with no cursor when one value is on the clipboard")
+        func pasteIsEnabledWithoutACursor() throws {
             try #require(RecordingClipboard.current).text = "archived"
-            let fixture = CellsToValueFixture()
-            let window = fixture.attachUndoWindow()
-            defer { window.orderOut(nil) }
-            let tableView = try #require(fixture.coordinator.tableView as? KeyHandlingTableView)
-            fixture.select(rows: 0...3, columns: CellsToValueFixture.note...CellsToValueFixture.note)
-            tableView.focusedRow = -1
-            tableView.focusedColumn = -1
-            let paste = NSMenuItem(title: "", action: #selector(KeyHandlingTableView.paste(_:)), keyEquivalent: "")
-
-            #expect(fixture.coordinator.canPasteValueIntoSelectedCells())
-            #expect(tableView.validateUserInterfaceItem(paste))
+            let grid = Fixture.grid()
+            grid.model.setSelection(GridSelection(
+                rectangles: [GridRect(rows: 0...3, columns: Fixture.note...Fixture.note)],
+                activeCell: nil,
+                anchor: nil
+            ))
+
+            #expect(grid.isEnabled(#selector(DataGridViewController.paste(_:))))
         }
     }
 }
diff --git a/apple/TableProTests/Views/Results/Extensions/DataGridSetValueTests.swift b/apple/TableProTests/Views/Results/Extensions/DataGridSetValueTests.swift
index 439c610558..2033fc161c 100644
--- a/apple/TableProTests/Views/Results/Extensions/DataGridSetValueTests.swift
+++ b/apple/TableProTests/Views/Results/Extensions/DataGridSetValueTests.swift
@@ -5,39 +5,12 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
 @MainActor
-private final class SetValueLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class SetValueRowStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
-/// The app hands the change manager the window's undo manager, so the grid's group and the cells' steps share one.
-@MainActor
-private final class SetValueUndoWindow: NSWindow {
-    let undo = UndoManager()
-
-    override var undoManager: UndoManager? { undo }
-}
-
-private final class NoCapabilityDriver: PluginDriverStub, @unchecked Sendable {}
-
-@MainActor
-private struct SetValueFixture {
+private enum SetValueFixture {
     static let columns = ["id", "ref", "note", "label", "seen"]
     static let id = 0
     static let ref = 1
@@ -45,97 +18,66 @@ private struct SetValueFixture {
     static let label = 3
     static let seen = 4
 
-    let manager: DataChangeManager
-    let coordinator: TableViewCoordinator
-    let store: SetValueRowStore
-
-    init(selectedRows: Set<Int> = [], rowCount: Int = 3) {
-        manager = DataChangeManager()
+    static func grid(rowCount: Int = 3, isEditable: Bool = true) -> CommandGrid {
+        let manager = DataChangeManager()
         manager.configureForTable(
             tableName: "things",
-            columns: Self.columns,
+            columns: columns,
             primaryKeyColumns: ["id"],
             databaseType: .postgresql,
             generatedColumns: []
         )
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(manager),
-            isEditable: true,
-            selectedRowIndices: .constant(selectedRows),
-            delegate: nil,
-            layoutPersister: SetValueLayoutPersister()
-        )
         let rows: [[PluginCellValue]] = (0..<rowCount).map { row in
             [.null, .null, .text("n\(row)"), .text("l\(row)"), .text("2024-01-0\(row + 1) 10:00:00+00")]
         }
-        store = SetValueRowStore(TableRows.from(
-            queryRows: rows,
-            columns: Self.columns,
-            columnTypes: [
-                .text(rawType: "uuid"),
-                .text(rawType: "uuid"),
-                .text(rawType: "text"),
-                .text(rawType: "text"),
-                .timestamp(rawType: "timestamptz")
-            ],
-            columnNullable: ["id": false, "ref": true, "note": true, "label": false, "seen": true]
-        ))
-        let store = store
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-        coordinator.databaseType = .postgresql
-        coordinator.updateCache()
-    }
-
-    func staged(row: Int, column: Int) -> PluginCellValue? {
-        manager.pending.change(forRow: .existing(row), type: .update)?
-            .cellChanges.first { $0.columnIndex == column }?.newValue
-    }
-
-    func select(rows: ClosedRange<Int>, columns: ClosedRange<Int>) {
-        coordinator.selectionController.update(.single(
-            GridRect(rows: rows, columns: columns),
-            anchor: GridCoord(row: rows.lowerBound, displayColumn: columns.lowerBound),
-            active: GridCoord(row: rows.upperBound, displayColumn: columns.upperBound)
-        ))
+        return CommandGrid(
+            TableRows.from(
+                queryRows: rows,
+                columns: columns,
+                columnTypes: [
+                    .text(rawType: "uuid"),
+                    .text(rawType: "uuid"),
+                    .text(rawType: "text"),
+                    .text(rawType: "text"),
+                    .timestamp(rawType: "timestamptz"),
+                ],
+                columnNullable: ["id": false, "ref": true, "note": true, "label": false, "seen": true]
+            ),
+            configuration: isEditable ? CommandGrid.editable() : CommandGrid.readOnly(),
+            changeManager: manager
+        )
     }
 
-    func cell(_ row: Int, _ column: Int) -> SetValueTarget {
-        SetValueTarget(displayRow: row, columnIndex: column)
+    static func cells(_ grid: CommandGrid, _ pairs: [(Int, Int)]) -> [DataGridCommandCell] {
+        pairs.compactMap { row, column in
+            guard let rowID = grid.model.rowID(at: row), let column = grid.model.columns.column(at: column) else { return nil }
+            return DataGridCommandCell(rowID: rowID, row: row, column: column)
+        }
     }
 
-    func attachUndoWindow() -> SetValueUndoWindow {
-        let window = SetValueUndoWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 400, height: 300),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: true
+    static func now() throws -> CellExpression {
+        try #require(
+            CellExpressionVocabulary.expressions(for: .postgresql, columnType: .timestamp(rawType: "timestamptz"))
+                .first { $0.sql == "now()" }
         )
-        window.isReleasedWhenClosed = false
-        window.undo.groupsByEvent = false
-        let tableView = KeyHandlingTableView()
-        window.contentView?.addSubview(tableView)
-        tableView.coordinator = coordinator
-        coordinator.tableView = tableView
-        let undo = window.undo
-        manager.undoManagerProvider = { undo }
-        return window
     }
 }
 
 @MainActor
 struct DataGridSetValueTests {
-    @Test("Generate UUID over a cell selection writes a different UUID into every cell")
+    private typealias Fixture = SetValueFixture
+
+    @Test("Generate UUID over a cell selection writes a different lowercase UUID into every cell")
     func uuidPerSelectedCell() throws {
-        let fixture = SetValueFixture()
-        fixture.select(rows: 0...2, columns: SetValueFixture.id...SetValueFixture.ref)
+        let grid = Fixture.grid()
+        grid.select(rows: 0...2, columns: Fixture.id...Fixture.ref)
 
-        fixture.coordinator.applySetValue(.uuid(.v4), to: fixture.coordinator.setValueTargets(clicked: nil))
+        grid.commands.applySetValue(.uuid(.v4), to: grid.commands.cells(.current(grid.model.selection)))
 
         var written: [String] = []
         for row in 0..<3 {
-            for column in [SetValueFixture.id, SetValueFixture.ref] {
-                let text = try #require(fixture.staged(row: row, column: column)?.asText)
+            for column in [Fixture.id, Fixture.ref] {
+                let text = try #require(grid.owner.staged(row, column)?.value.asText)
                 #expect(UUID(uuidString: text) != nil)
                 #expect(text == text.lowercased())
                 written.append(text)
@@ -146,146 +88,334 @@ struct DataGridSetValueTests {
 
     @Test("Generate UUID on an empty CHAR column the UUID format marks takes the length its schema declares")
     func uuidTakesTheSchemaLength() throws {
-        let fixture = SetValueFixture()
-        fixture.store.tableRows.columnTypes[SetValueFixture.ref] = .text(rawType: "CHAR")
-        fixture.store.tableRows.columnDeclaredTypes = ["ref": "CHAR(32)"]
-        fixture.coordinator.syncDisplayFormats([nil, .uuid, nil, nil, nil])
+        let grid = Fixture.grid()
+        grid.owner.tableRows.columnTypes[Fixture.ref] = .text(rawType: "CHAR")
+        grid.owner.tableRows.columnDeclaredTypes = ["ref": "CHAR(32)"]
+        grid.model.reloadRows()
+        grid.model.setDisplayFormat(.uuid, for: grid.model.columns.columns[Fixture.ref])
 
-        fixture.coordinator.applySetValue(.uuid(.v4), to: [fixture.cell(0, SetValueFixture.ref)])
+        grid.commands.applySetValue(.uuid(.v4), to: Fixture.cells(grid, [(0, Fixture.ref)]))
 
-        let text = try #require(fixture.staged(row: 0, column: SetValueFixture.ref)?.asText)
+        let text = try #require(grid.owner.staged(0, Fixture.ref)?.value.asText)
         #expect(text.count == 32)
         #expect(text.allSatisfy { $0.isHexDigit })
     }
 
-    @Test("A Set Value over many cells is one undo step, named for the command")
-    func oneUndoStep() {
-        let fixture = SetValueFixture()
-        let window = fixture.attachUndoWindow()
-        defer { window.orderOut(nil) }
-        let targets = (0..<3).map { fixture.cell($0, SetValueFixture.id) }
+    @Test("A Set Value over many cells is one commit, named for the command")
+    func oneCommit() {
+        let grid = Fixture.grid()
 
-        fixture.coordinator.applySetValue(.uuid(.v7), to: targets)
-
-        #expect(window.undo.undoActionName == "Generate UUIDv7")
-        window.undo.undo()
-        #expect(!window.undo.canUndo)
-        #expect(!fixture.manager.hasChanges)
-    }
-
-    @Test("NULL over a selection is an undo step named Set Value")
-    func nullUndoName() {
-        let fixture = SetValueFixture()
-        let window = fixture.attachUndoWindow()
-        defer { window.orderOut(nil) }
-
-        fixture.coordinator.applySetValue(
-            .null, to: [fixture.cell(0, SetValueFixture.note), fixture.cell(1, SetValueFixture.note)]
-        )
+        grid.commands.applySetValue(.uuid(.v7), to: Fixture.cells(grid, [(0, Fixture.id), (1, Fixture.id), (2, Fixture.id)]))
+        grid.commands.applySetValue(.null, to: Fixture.cells(grid, [(0, Fixture.note), (1, Fixture.note)]))
 
-        #expect(window.undo.undoActionName == "Set Value")
+        #expect(grid.owner.commits.map { $0.actionName } == [String(localized: "Generate UUIDv7"), String(localized: "Set Value")])
+        #expect(grid.owner.commits.map { $0.edits.count } == [3, 2])
     }
 
-    @Test("Without a cell selection the clicked column is written on every selected row")
+    @Test("Over whole rows the clicked column is written on every selected row; a click on another row writes that cell")
     func clickedColumnAcrossSelectedRows() {
-        let fixture = SetValueFixture(selectedRows: [0, 2])
+        let grid = Fixture.grid()
+        grid.model.setSelection(GridSelection(
+            rectangles: [GridRect(rows: 0...0, columns: 0...4), GridRect(rows: 2...2, columns: 0...4)],
+            activeCell: GridCoord(row: 2, displayColumn: 0),
+            anchor: GridCoord(row: 0, displayColumn: 0),
+            mode: .rows
+        ))
+        let selection = grid.model.selection
 
-        let onSelectedRow = fixture.coordinator.setValueTargets(clicked: fixture.cell(2, SetValueFixture.note))
-        let onOtherRow = fixture.coordinator.setValueTargets(clicked: fixture.cell(1, SetValueFixture.note))
+        let onSelectedRow = grid.commands.cells(.contextMenu(selection: selection, row: 2, displayColumn: Fixture.note, columnCount: 5))
+        let onOtherRow = grid.commands.cells(.contextMenu(selection: selection, row: 1, displayColumn: Fixture.note, columnCount: 5))
 
-        #expect(onSelectedRow == [fixture.cell(0, SetValueFixture.note), fixture.cell(2, SetValueFixture.note)])
-        #expect(onOtherRow == [fixture.cell(1, SetValueFixture.note)])
+        #expect(onSelectedRow == Fixture.cells(grid, [(0, Fixture.note), (2, Fixture.note)]))
+        #expect(onOtherRow == Fixture.cells(grid, [(1, Fixture.note)]))
     }
 
     @Test("A click inside the cell selection acts on the selection, a click outside it on the clicked cell")
     func clickInsideOrOutsideSelection() {
-        let fixture = SetValueFixture()
-        fixture.select(rows: 0...1, columns: SetValueFixture.note...SetValueFixture.note)
+        let grid = Fixture.grid()
+        grid.select(rows: 0...1, columns: Fixture.note...Fixture.note)
+        let selection = grid.model.selection
 
-        let inside = fixture.coordinator.setValueTargets(clicked: fixture.cell(1, SetValueFixture.note))
-        let outside = fixture.coordinator.setValueTargets(clicked: fixture.cell(2, SetValueFixture.label))
+        let inside = grid.commands.cells(.contextMenu(selection: selection, row: 1, displayColumn: Fixture.note, columnCount: 5))
+        let outside = grid.commands.cells(.contextMenu(selection: selection, row: 2, displayColumn: Fixture.label, columnCount: 5))
 
-        #expect(inside == [fixture.cell(0, SetValueFixture.note), fixture.cell(1, SetValueFixture.note)])
-        #expect(outside == [fixture.cell(2, SetValueFixture.label)])
+        #expect(inside == Fixture.cells(grid, [(0, Fixture.note), (1, Fixture.note)]))
+        #expect(outside == Fixture.cells(grid, [(2, Fixture.label)]))
     }
 
     @Test("Cells that do not take the command, and deleted rows, are left as they were")
     func skipsCellsTheCommandDoesNotFit() {
-        let fixture = SetValueFixture()
-        fixture.manager.recordRowDeletion(
-            rowID: .existing(1), originalRow: Array(fixture.store.tableRows.rows[1].values)
-        )
-        fixture.select(rows: 0...2, columns: SetValueFixture.note...SetValueFixture.label)
+        let grid = Fixture.grid()
+        grid.owner.changeManager.recordRowDeletion(rowID: .existing(1), originalRow: Array(grid.owner.tableRows.rows[1].values))
+        grid.select(rows: 0...2, columns: Fixture.note...Fixture.label)
 
-        fixture.coordinator.applySetValue(.null, to: fixture.coordinator.setValueTargets(clicked: nil))
+        grid.commands.applySetValue(.null, to: grid.commands.cells(.current(grid.model.selection)))
 
-        #expect(fixture.staged(row: 0, column: SetValueFixture.note) == .null)
-        #expect(fixture.staged(row: 2, column: SetValueFixture.note) == .null)
-        #expect(fixture.staged(row: 0, column: SetValueFixture.label) == nil)
-        #expect(fixture.store.tableRows.rows[1].values[SetValueFixture.note] == .text("n1"))
-        #expect(fixture.store.tableRows.rows[0].values[SetValueFixture.label] == .text("l0"))
+        #expect(grid.owner.staged(0, Fixture.note)?.value == .null)
+        #expect(grid.owner.staged(2, Fixture.note)?.value == .null)
+        #expect(grid.owner.staged(0, Fixture.label) == nil)
+        #expect(grid.owner.staged(1, Fixture.note) == nil)
     }
 
     @Test("A selection offers every command one of its cells takes, in menu order")
     func offeredCommandsAreTheUnion() {
-        let fixture = SetValueFixture()
-        fixture.select(rows: 0...0, columns: SetValueFixture.id...SetValueFixture.note)
-        let targets = fixture.coordinator.setValueTargets(clicked: nil)
+        let grid = Fixture.grid()
+        grid.select(rows: 0...0, columns: Fixture.id...Fixture.note)
+        let cells = grid.commands.cells(.current(grid.model.selection))
 
-        #expect(fixture.coordinator.setValueCommands(for: targets) == [.empty, .null, .uuid(.v4), .uuid(.v7)])
-        #expect(fixture.coordinator.isSetValueOffered(.uuid(.v4), for: targets))
-        #expect(!fixture.coordinator.isSetValueOffered(.defaultValue, for: targets))
+        #expect(grid.commands.setValueCommands(for: cells) == [.empty, .null, .uuid(.v4), .uuid(.v7)])
+        #expect(grid.commands.isSetValueOffered(.uuid(.v4), for: cells))
+        #expect(!grid.commands.isSetValueOffered(.defaultValue, for: cells))
     }
 
     @Test("A function chosen from Set Value is staged as SQL, not as text")
     func expressionIsMarked() throws {
-        let fixture = SetValueFixture()
-        let now = try #require(
-            CellExpressionVocabulary.expressions(for: .postgresql, columnType: .timestamp(rawType: "timestamptz"))
-                .first { $0.sql == "now()" }
-        )
+        let grid = Fixture.grid()
 
-        fixture.coordinator.applySetValue(.expression(now), to: [fixture.cell(0, SetValueFixture.seen)])
+        grid.commands.applySetValue(.expression(try Fixture.now()), to: Fixture.cells(grid, [(0, Fixture.seen)]))
 
-        #expect(fixture.staged(row: 0, column: SetValueFixture.seen) == .text("now()"))
-        #expect(fixture.manager.isExpression(rowID: .existing(0), columnIndex: SetValueFixture.seen))
+        #expect(grid.owner.staged(0, Fixture.seen)?.value == .text("now()"))
+        #expect(grid.owner.staged(0, Fixture.seen)?.isExpression == true)
     }
 
     @Test("Typing a function into a timestamp stages its SQL, and the same text in a text cell stays text")
     func typedFunctionIsPromotedOnlyWhereItFits() {
-        let fixture = SetValueFixture()
+        let grid = Fixture.grid()
+        let seen = grid.model.columns.columns[Fixture.seen].id
+        let note = grid.model.columns.columns[Fixture.note].id
+
+        grid.model.commit(
+            [
+                DataGridCellEdit(rowID: .existing(0), columnID: seen, value: .enteredText(" NOW() ")),
+                DataGridCellEdit(rowID: .existing(0), columnID: note, value: .enteredText("NOW()")),
+            ],
+            actionName: "Edit Cell"
+        )
+
+        #expect(grid.owner.staged(0, Fixture.seen)?.value == .text("now()"))
+        #expect(grid.owner.staged(0, Fixture.seen)?.isExpression == true)
+        #expect(grid.owner.staged(0, Fixture.note)?.value == .text("NOW()"))
+        #expect(grid.owner.staged(0, Fixture.note)?.isExpression == false)
+    }
 
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: SetValueFixture.seen, newValue: " NOW() ")
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: SetValueFixture.note, newValue: "NOW()")
+    @Test("A writer that takes no SQL in cells gets typed text as it was typed, and that literal over a staged function is an edit")
+    func typedFunctionStaysLiteralForAnOldWriter() {
+        let grid = Fixture.grid()
+        let seen = grid.model.columns.columns[Fixture.seen].id
+        grid.model.commit([DataGridCellEdit(rowID: .existing(0), columnID: seen, value: .enteredText("now()"))], actionName: "Edit Cell")
+        #expect(grid.owner.staged(0, Fixture.seen)?.isExpression == true)
 
-        #expect(fixture.staged(row: 0, column: SetValueFixture.seen) == .text("now()"))
-        #expect(fixture.manager.isExpression(rowID: .existing(0), columnIndex: SetValueFixture.seen))
-        #expect(fixture.staged(row: 0, column: SetValueFixture.note) == .text("NOW()"))
-        #expect(!fixture.manager.isExpression(rowID: .existing(0), columnIndex: SetValueFixture.note))
+        grid.model.configuration.traits.cellWriterSupport = .none
+        grid.model.commit([DataGridCellEdit(rowID: .existing(0), columnID: seen, value: .enteredText("now()"))], actionName: "Edit Cell")
+
+        #expect(grid.owner.commits.count == 2)
+        #expect(grid.owner.staged(0, Fixture.seen)?.value == .text("now()"))
+        #expect(grid.owner.staged(0, Fixture.seen)?.isExpression == false)
     }
 
-    @Test("A driver that does not write SQL into cells gets typed text as it was typed")
-    func typedFunctionStaysLiteralForAnOldDriver() {
-        let fixture = SetValueFixture()
-        fixture.manager.pluginDriver = NoCapabilityDriver()
+    // MARK: - Menu bar
 
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: SetValueFixture.seen, newValue: "NOW()")
+    private func isEnabled(_ action: Selector, in grid: CommandGrid) -> Bool {
+        grid.isEnabled(action)
+    }
 
-        #expect(fixture.staged(row: 0, column: SetValueFixture.seen) == .text("NOW()"))
-        #expect(!fixture.manager.isExpression(rowID: .existing(0), columnIndex: SetValueFixture.seen))
+    private static let empty = #selector(SetValueCommandResponding.setValueEmpty(_:))
+    private static let null = #selector(SetValueCommandResponding.setValueNull(_:))
+    private static let defaultValue = #selector(SetValueCommandResponding.setValueDefault(_:))
+    private static let uuidV4 = #selector(SetValueCommandResponding.generateUUIDv4(_:))
+    private static let uuidV7 = #selector(SetValueCommandResponding.generateUUIDv7(_:))
+    private static let cellsToValue = #selector(SetValueCommandResponding.setCellsToValue(_:))
+
+    @Test("On the cursor's uuid key only the UUID items are enabled")
+    func uuidKeyEnablesTheUUIDs() {
+        let grid = Fixture.grid()
+        grid.selectCell(0, Fixture.id)
+
+        #expect(isEnabled(Self.uuidV4, in: grid))
+        #expect(isEnabled(Self.uuidV7, in: grid))
+        #expect(!isEnabled(Self.null, in: grid))
+        #expect(!isEnabled(Self.defaultValue, in: grid))
     }
 
-    @Test("The same text as a literal over a staged function is an edit")
-    func literalOverExpressionIsAnEdit() throws {
-        let fixture = SetValueFixture()
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: SetValueFixture.seen, newValue: "now()")
-        #expect(fixture.manager.isExpression(rowID: .existing(0), columnIndex: SetValueFixture.seen))
+    @Test("On a nullable text cell Empty, NULL and Set Cells to Value are enabled and the UUIDs are not")
+    func textCellEnablesItsCommands() {
+        let grid = Fixture.grid()
+        grid.selectCell(0, Fixture.note)
+
+        #expect(isEnabled(Self.empty, in: grid))
+        #expect(isEnabled(Self.null, in: grid))
+        #expect(isEnabled(Self.cellsToValue, in: grid))
+        #expect(!isEnabled(Self.uuidV4, in: grid))
+    }
 
-        fixture.manager.pluginDriver = NoCapabilityDriver()
-        fixture.coordinator.commitCellEdit(row: 0, columnIndex: SetValueFixture.seen, newValue: "now()")
+    @Test("With nothing selected, or a read-only grid, every item is dimmed")
+    func everythingDimsWithoutATarget() {
+        let grid = Fixture.grid()
+        let readOnly = Fixture.grid(isEditable: false)
+        readOnly.selectCell(0, Fixture.note)
 
-        #expect(!fixture.manager.isExpression(rowID: .existing(0), columnIndex: SetValueFixture.seen))
-        #expect(fixture.staged(row: 0, column: SetValueFixture.seen) == .text("now()"))
+        for action in [Self.empty, Self.null, Self.defaultValue, Self.uuidV4, Self.uuidV7, Self.cellsToValue] {
+            #expect(!isEnabled(action, in: grid))
+            #expect(!isEnabled(action, in: readOnly))
+        }
+    }
+
+    @Test("A selection across both columns enables what either takes, and writes each only where it fits")
+    func mixedSelection() {
+        let grid = Fixture.grid()
+        grid.model.setSelection(GridSelection(
+            rectangles: [GridRect(cell: GridCoord(row: 0, displayColumn: Fixture.id)), GridRect(cell: GridCoord(row: 0, displayColumn: Fixture.note))],
+            activeCell: GridCoord(row: 0, displayColumn: Fixture.note),
+            anchor: GridCoord(row: 0, displayColumn: Fixture.id)
+        ))
+
+        #expect(isEnabled(Self.null, in: grid))
+        #expect(isEnabled(Self.uuidV4, in: grid))
+
+        grid.controller.setValueNull(nil)
+
+        #expect(grid.owner.staged(0, Fixture.note)?.value == .null)
+        #expect(grid.owner.staged(0, Fixture.id) == nil)
+    }
+
+    @Test("Set Value NULL from the menu bar writes the cursor's cell")
+    func menuBarWritesTheCursorCell() {
+        let grid = Fixture.grid()
+        grid.selectCell(1, Fixture.note)
+
+        grid.controller.setValueNull(nil)
+
+        #expect(grid.owner.staged(1, Fixture.note)?.value == .null)
+        #expect(grid.owner.editCount == 1)
+    }
+
+    // MARK: - Context menu
+
+    private func setValueTitles(_ grid: CommandGrid, row: Int = 0, column: Int) -> [String] {
+        let menu = grid.rowMenu(row: row, displayColumn: column)
+        return CommandRows.titles(CommandRows.item(String(localized: "Set Value"), in: menu)?.submenu)
+    }
+
+    private func menuGrid(
+        columns: [String],
+        columnTypes: [ColumnType],
+        rows: [[PluginCellValue]],
+        columnNullable: [String: Bool] = [:],
+        columnDefaults: [String: String?] = [:],
+        columnForeignKeys: [String: ForeignKeyInfo] = [:],
+        databaseType: DatabaseType = .postgresql
+    ) -> CommandGrid {
+        let manager = DataChangeManager()
+        manager.configureForTable(
+            tableName: "t",
+            columns: columns,
+            primaryKeyColumns: [columns[0]],
+            databaseType: databaseType,
+            generatedColumns: []
+        )
+        return CommandGrid(
+            TableRows.from(
+                queryRows: rows,
+                columns: columns,
+                columnTypes: columnTypes,
+                columnDefaults: columnDefaults,
+                columnForeignKeys: columnForeignKeys,
+                columnNullable: columnNullable
+            ),
+            configuration: CommandGrid.editable(databaseType: databaseType),
+            changeManager: manager
+        )
+    }
+
+    private func uuidKeyGrid() -> CommandGrid {
+        menuGrid(
+            columns: ["id", "name"],
+            columnTypes: [.text(rawType: "uuid"), .text(rawType: "text")],
+            rows: [[.null, .text("a")]],
+            columnNullable: ["id": false, "name": true]
+        )
+    }
+
+    @Test("A PostgreSQL uuid key, NOT NULL with no default, offers the two UUIDs and Set Cells to Value")
+    func uuidKeyMenu() {
+        #expect(setValueTitles(uuidKeyGrid(), column: 0) == ["Generate UUID", "Generate UUIDv7", "-", "Set Cells to Value…"])
+    }
+
+    @Test("A date column lists the engine's functions after the placeholders, behind a separator")
+    func dateColumnFunctions() {
+        let grid = menuGrid(
+            columns: ["id", "born"],
+            columnTypes: [.integer(rawType: "INT"), .date(rawType: "DATE")],
+            rows: [[.text("1"), .text("2024-01-01")]],
+            columnNullable: ["born": true],
+            databaseType: .mysql
+        )
+
+        #expect(setValueTitles(grid, column: 1) == ["NULL", "-", "CURDATE()", "UTC_DATE()", "-", "Set Cells to Value…"])
+    }
+
+    @Test("A nullable uuid column with a default keeps NULL and Default apart from the UUIDs")
+    func uuidWithDefaultGroups() {
+        let grid = menuGrid(
+            columns: ["id", "ref"],
+            columnTypes: [.integer(rawType: "int4"), .text(rawType: "uuid")],
+            rows: [[.text("1"), .null]],
+            columnNullable: ["ref": true],
+            columnDefaults: ["ref": "gen_random_uuid()"]
+        )
+
+        #expect(setValueTitles(grid, column: 1) == [
+            "NULL", "Default", "-", "Generate UUID", "Generate UUIDv7", "-", "Set Cells to Value…",
+        ])
+    }
+
+    @Test("A uuid foreign key offers no new UUID, which would point at no row")
+    func foreignKeyOffersNoUUID() {
+        let grid = menuGrid(
+            columns: ["id", "owner"],
+            columnTypes: [.integer(rawType: "int4"), .text(rawType: "uuid")],
+            rows: [[.text("1"), .null]],
+            columnNullable: ["owner": true],
+            columnForeignKeys: [
+                "owner": ForeignKeyInfo(name: "fk", column: "owner", referencedTable: "users", referencedColumn: "id")
+            ]
+        )
+
+        #expect(setValueTitles(grid, column: 1) == ["NULL", "-", "Set Cells to Value…"])
+    }
+
+    @Test("Choosing Generate UUID writes a new lowercase UUID into the clicked cell")
+    func choosingGenerateUUIDWritesIt() throws {
+        let grid = uuidKeyGrid()
+        let menu = grid.rowMenu(row: 0, displayColumn: 0)
+        let submenu = try #require(CommandRows.item(String(localized: "Set Value"), in: menu)?.submenu)
+
+        grid.perform(try #require(CommandRows.item("Generate UUID", in: submenu)))
+
+        let staged = try #require(grid.owner.staged(0, 0)?.value.asText)
+        #expect(staged == staged.lowercased())
+        #expect(UUID(uuidString: staged) != nil)
+        #expect(grid.owner.tableRows.rows[0].values[0] == .text(staged))
+    }
+
+    @Test("A NOT NULL number with no default still offers Set Cells to Value, alone")
+    func typedValueIsTheOnlyItemOnANotNullNumber() {
+        let grid = menuGrid(
+            columns: ["id", "qty"],
+            columnTypes: [.integer(rawType: "int4"), .integer(rawType: "int4")],
+            rows: [[.text("1"), .text("5")]],
+            columnNullable: ["id": false, "qty": false]
+        )
+
+        #expect(setValueTitles(grid, column: 1) == ["Set Cells to Value…"])
+    }
+
+    @Test("A read-only grid has no Set Value at all")
+    func readOnlyGridOffersNothing() {
+        let grid = uuidKeyGrid()
+        grid.model.configuration.isEditable = false
+
+        #expect(CommandRows.item(String(localized: "Set Value"), in: grid.rowMenu(row: 0, displayColumn: 1)) == nil)
     }
 }
 
@@ -293,63 +423,69 @@ extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
     struct DataGridSetValuePasteTests {
+        private typealias Fixture = SetValueFixture
+
+        private func paste(into grid: CommandGrid, row: Int, column: Int) {
+            grid.selectCell(row, column)
+            grid.controller.paste(nil)
+        }
+
         @Test("A function name pasted into a timestamp cell stages its SQL")
         func pastedFunctionIsPromoted() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-            clipboard.text = "current_timestamp"
-            let fixture = SetValueFixture()
+            try #require(RecordingClipboard.current).text = "current_timestamp"
+            let grid = Fixture.grid()
 
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: SetValueFixture.seen))
+            paste(into: grid, row: 1, column: Fixture.seen)
 
-            #expect(fixture.staged(row: 1, column: SetValueFixture.seen) == .text("CURRENT_TIMESTAMP"))
-            #expect(fixture.manager.isExpression(rowID: .existing(1), columnIndex: SetValueFixture.seen))
+            #expect(grid.owner.staged(1, Fixture.seen)?.value == .text("CURRENT_TIMESTAMP"))
+            #expect(grid.owner.staged(1, Fixture.seen)?.isExpression == true)
         }
 
         @Test("A staged function copied from the grid pastes as SQL, whichever column it lands in")
         func copiedExpressionPastesAsSQL() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let fixture = SetValueFixture()
-            let now = try #require(
-                CellExpressionVocabulary.expressions(for: .postgresql, columnType: .timestamp(rawType: "timestamptz"))
-                    .first { $0.sql == "now()" }
-            )
-            fixture.coordinator.applySetValue(.expression(now), to: [fixture.cell(0, SetValueFixture.seen)])
-
-            fixture.coordinator.copyCellValue(at: 0, columnIndex: SetValueFixture.seen)
+            let grid = Fixture.grid()
+            grid.commands.applySetValue(.expression(try Fixture.now()), to: Fixture.cells(grid, [(0, Fixture.seen)]))
+
+            grid.selectCell(0, Fixture.seen)
+            grid.controller.copy(nil)
             #expect(clipboard.gridCells?.expressionFields == [0: [0]])
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: SetValueFixture.note))
+            paste(into: grid, row: 1, column: Fixture.note)
 
-            #expect(fixture.staged(row: 1, column: SetValueFixture.note) == .text("now()"))
-            #expect(fixture.manager.isExpression(rowID: .existing(1), columnIndex: SetValueFixture.note))
+            #expect(grid.owner.staged(1, Fixture.note)?.value == .text("now()"))
+            #expect(grid.owner.staged(1, Fixture.note)?.isExpression == true)
         }
 
         @Test("Stored text that spells a function, copied from the grid, pastes as the same text")
         func copiedLiteralIsNotPromoted() throws {
-            let fixture = SetValueFixture()
-            _ = fixture.store.tableRows.edit(row: 0, column: SetValueFixture.seen, value: .text("CURRENT_TIMESTAMP"))
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = Fixture.grid()
+            _ = grid.owner.tableRows.edit(row: 0, column: Fixture.seen, value: .text("CURRENT_TIMESTAMP"))
+            grid.model.reloadRows()
 
-            fixture.coordinator.copyCellValue(at: 0, columnIndex: SetValueFixture.seen)
-            #expect(try #require(RecordingClipboard.current).gridCells?.expressionFields == nil)
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 1, anchorColumn: SetValueFixture.seen))
+            grid.selectCell(0, Fixture.seen)
+            grid.controller.copy(nil)
+            #expect(clipboard.gridCells?.expressionFields == nil)
+            paste(into: grid, row: 1, column: Fixture.seen)
 
-            #expect(fixture.staged(row: 1, column: SetValueFixture.seen) == .text("CURRENT_TIMESTAMP"))
-            #expect(!fixture.manager.isExpression(rowID: .existing(1), columnIndex: SetValueFixture.seen))
+            #expect(grid.owner.staged(1, Fixture.seen)?.value == .text("CURRENT_TIMESTAMP"))
+            #expect(grid.owner.staged(1, Fixture.seen)?.isExpression == false)
         }
 
         @Test("A copied block marks only the fields that held staged SQL")
         func copiedBlockMarksEachField() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let fixture = SetValueFixture()
-            fixture.coordinator.commitCellEdit(row: 0, columnIndex: SetValueFixture.seen, newValue: "now()")
-            fixture.select(rows: 0...0, columns: SetValueFixture.note...SetValueFixture.seen)
+            let grid = Fixture.grid()
+            grid.commands.applySetValue(.expression(try Fixture.now()), to: Fixture.cells(grid, [(0, Fixture.seen)]))
+            grid.select(rows: 0...0, columns: Fixture.note...Fixture.seen, active: GridCoord(row: 0, displayColumn: Fixture.note))
 
-            fixture.coordinator.copyGridSelection(fixture.coordinator.selectionController.selection)
+            grid.controller.copy(nil)
             #expect(clipboard.gridCells?.fields == [["n0", "l0", "now()"]])
             #expect(clipboard.gridCells?.expressionFields == [0: [2]])
-            #expect(fixture.coordinator.pasteCellsFromClipboard(anchorRow: 2, anchorColumn: SetValueFixture.note))
+            paste(into: grid, row: 2, column: Fixture.note)
 
-            #expect(fixture.manager.isExpression(rowID: .existing(2), columnIndex: SetValueFixture.seen))
-            #expect(!fixture.manager.isExpression(rowID: .existing(2), columnIndex: SetValueFixture.note))
+            #expect(grid.owner.staged(2, Fixture.seen)?.isExpression == true)
+            #expect(grid.owner.staged(2, Fixture.note)?.isExpression == false)
         }
     }
 }
diff --git a/apple/TableProTests/Views/Results/Extensions/FillColumnTests.swift b/apple/TableProTests/Views/Results/Extensions/FillColumnTests.swift
index 1960d40177..098a709eba 100644
--- a/apple/TableProTests/Views/Results/Extensions/FillColumnTests.swift
+++ b/apple/TableProTests/Views/Results/Extensions/FillColumnTests.swift
@@ -4,223 +4,167 @@
 //
 
 import Foundation
-import SwiftUI
+@testable import TablePro
 import TableProPluginKit
 import Testing
 
-@testable import TablePro
-
-@MainActor
-private final class NoopColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 @MainActor
 struct FillColumnTests {
-    private func makeCoordinator(
+    private func makeGrid(
         columns: [String],
         rowCount: Int,
         isEditable: Bool = true,
         columnTypes: [ColumnType]? = nil,
         columnNullable: [String: Bool] = [:],
-        databaseType: DatabaseType? = nil,
-        manager: DataChangeManager
-    ) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(manager),
-            isEditable: isEditable,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopColumnLayoutPersister()
-        )
+        databaseType: DatabaseType? = .postgresql
+    ) -> CommandGrid {
         let types = columnTypes ?? Array(repeating: .text(rawType: nil), count: columns.count)
-        let rows = (0..<rowCount).map { i in (0..<columns.count).map { c in "r\(i)c\(c)" } }
-        let tableRows = TableRows.from(
-            queryRows: rows.map { row in row.map { PluginCellValue.text($0) } },
-            columns: columns,
-            columnTypes: types,
-            columnNullable: columnNullable
+        let rows = (0..<rowCount).map { row in (0..<columns.count).map { PluginCellValue.text("r\(row)c\($0)") } }
+        return CommandGrid(
+            TableRows.from(queryRows: rows, columns: columns, columnTypes: types, columnNullable: columnNullable),
+            configuration: isEditable ? CommandGrid.editable(databaseType: databaseType) : CommandGrid.readOnly()
         )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.databaseType = databaseType
-        coordinator.updateCache()
-        return coordinator
     }
 
-    private func stagedValues(_ manager: DataChangeManager, column: Int, rows: Range<Int>) -> [PluginCellValue?] {
-        rows.map { row in
-            manager.pending.change(forRow: .existing(row), type: .update)?
-                .cellChanges.first { $0.columnIndex == column }?.newValue
-        }
+    private func column(_ grid: CommandGrid, _ index: Int) -> DataGridColumn {
+        grid.model.columns.columns[index]
     }
 
-    // MARK: - Target selection
+    // MARK: - Targets
 
     @Test("Targets every loaded row when editable and none are deleted")
-    func targetsAllLoadedRows() {
-        let rows = TableViewCoordinator.fillTargetRows(
-            rowCount: 5,
-            isEditable: true,
-            isRowDeleted: { _ in false }
-        )
-        #expect(rows == [0, 1, 2, 3, 4])
+    func targetsEveryRow() {
+        let grid = makeGrid(columns: ["a"], rowCount: 3)
+        #expect(grid.commands.fillTargetRowIDs() == [.existing(0), .existing(1), .existing(2)])
     }
 
     @Test("Excludes rows marked for deletion")
     func excludesDeletedRows() {
-        let rows = TableViewCoordinator.fillTargetRows(
-            rowCount: 5,
-            isEditable: true,
-            isRowDeleted: { $0 == 2 }
-        )
-        #expect(rows == [0, 1, 3, 4])
-    }
+        let grid = makeGrid(columns: ["a"], rowCount: 3)
+        grid.owner.changeManager.recordRowDeletion(rowID: .existing(1), originalRow: [.text("r1c0")])
 
-    @Test("Targets nothing on a read-only result set")
-    func noTargetsWhenReadOnly() {
-        let rows = TableViewCoordinator.fillTargetRows(
-            rowCount: 5,
-            isEditable: false,
-            isRowDeleted: { _ in false }
-        )
-        #expect(rows.isEmpty)
+        #expect(grid.commands.fillTargetRowIDs() == [.existing(0), .existing(2)])
     }
 
-    @Test("Targets nothing when no rows are loaded")
-    func noTargetsWhenEmpty() {
-        let rows = TableViewCoordinator.fillTargetRows(
-            rowCount: 0,
-            isEditable: true,
-            isRowDeleted: { _ in false }
-        )
-        #expect(rows.isEmpty)
+    @Test("Targets nothing on a read-only result, and is not offered there or without rows")
+    func targetsNothingWhenReadOnly() {
+        let readOnly = makeGrid(columns: ["a"], rowCount: 3, isEditable: false)
+        #expect(readOnly.commands.fillTargetRowIDs().isEmpty)
+        #expect(!readOnly.commands.canFillColumn(column(readOnly, 0)))
+
+        let empty = makeGrid(columns: ["a"], rowCount: 0)
+        #expect(!empty.commands.canFillColumn(column(empty, 0)))
     }
 
     // MARK: - Value resolution
 
     @Test("Resolves NULL distinctly from an empty string")
     func resolvesNullDistinctFromEmpty() {
-        let coordinator = makeCoordinator(columns: ["a"], rowCount: 1, manager: DataChangeManager())
-        #expect(coordinator.fillColumnContent(choice: .null, text: "ignored", columnIndex: 0) == .value(.null))
-        #expect(coordinator.fillColumnContent(choice: .value, text: "", columnIndex: 0) == .value(.text("")))
-        #expect(coordinator.fillColumnContent(choice: .value, text: "active", columnIndex: 0) == .value(.text("active")))
+        let grid = makeGrid(columns: ["a"], rowCount: 1)
+        let target = column(grid, 0)
+
+        #expect(grid.commands.fillColumnContent(choice: .null, text: "ignored", column: target) == .value(.null))
+        #expect(grid.commands.fillColumnContent(choice: .value, text: "", column: target) == .value(.text("")))
+        #expect(grid.commands.fillColumnContent(choice: .value, text: "active", column: target) == .value(.text("active")))
     }
 
     @Test("Offers NULL where the column takes it, and the UUIDs only on a column that holds them")
     func choicesFollowTheColumn() {
-        let coordinator = makeCoordinator(
+        let grid = makeGrid(
             columns: ["id", "name", "code"],
             rowCount: 1,
             columnTypes: [.text(rawType: "uuid"), .text(rawType: "text"), .text(rawType: "text")],
-            columnNullable: ["id": false, "name": true, "code": false],
-            databaseType: .postgresql,
-            manager: DataChangeManager()
+            columnNullable: ["id": false, "name": true, "code": false]
         )
 
-        #expect(coordinator.fillColumnChoices(columnIndex: 0) == [.value, .uuid(.v4), .uuid(.v7)])
-        #expect(coordinator.fillColumnChoices(columnIndex: 1) == [.value, .null])
-        #expect(coordinator.fillColumnChoices(columnIndex: 2) == [.value])
+        #expect(grid.commands.fillColumnChoices(for: column(grid, 0)) == [.value, .uuid(.v4), .uuid(.v7)])
+        #expect(grid.commands.fillColumnChoices(for: column(grid, 1)) == [.value, .null])
+        #expect(grid.commands.fillColumnChoices(for: column(grid, 2)) == [.value])
     }
 
     @Test("A typed function on a date column fills as SQL, and the same text on a text column as text")
     func typedFunctionFillsAsExpression() {
-        let coordinator = makeCoordinator(
+        let grid = makeGrid(
             columns: ["seen", "note"],
             rowCount: 1,
-            columnTypes: [.timestamp(rawType: "timestamptz"), .text(rawType: "text")],
-            databaseType: .postgresql,
-            manager: DataChangeManager()
+            columnTypes: [.timestamp(rawType: "timestamptz"), .text(rawType: "text")]
         )
 
         #expect(
-            coordinator.fillColumnContent(choice: .value, text: " NOW() ", columnIndex: 0)
+            grid.commands.fillColumnContent(choice: .value, text: " NOW() ", column: column(grid, 0))
                 == .value(.text("now()"), isExpression: true)
         )
-        #expect(coordinator.fillColumnContent(choice: .value, text: "NOW()", columnIndex: 1) == .value(.text("NOW()")))
+        #expect(grid.commands.fillColumnContent(choice: .value, text: "NOW()", column: column(grid, 1)) == .value(.text("NOW()")))
     }
 
     @Test("Impact description reflects singular and plural counts")
     func impactDescriptionSingularAndPlural() {
-        #expect(TableViewCoordinator.fillImpactDescription(rowCount: 1).contains("1 loaded row"))
-        #expect(TableViewCoordinator.fillImpactDescription(rowCount: 42).contains("42 loaded rows"))
+        #expect(DataGridCommands.fillImpactDescription(rowCount: 1).contains("1 loaded row"))
+        #expect(DataGridCommands.fillImpactDescription(rowCount: 42).contains("42 loaded rows"))
     }
 
-    // MARK: - Apply (staged effect)
+    // MARK: - Apply
 
-    @Test("Records one staged change per loaded row, leaving other columns untouched")
+    @Test("One commit named Fill Column with a change per loaded row, other columns untouched")
     func appliesToEveryLoadedRow() {
-        let manager = DataChangeManager()
-        let coordinator = makeCoordinator(columns: ["a", "b"], rowCount: 4, manager: manager)
+        let grid = makeGrid(columns: ["a", "b"], rowCount: 4)
 
-        coordinator.applyFillColumn(columnIndex: 0, content: .value(.text("X")))
+        grid.commands.applyFillColumn(column(grid, 0), content: .value(.text("X")))
 
+        #expect(grid.owner.commits.map { $0.actionName } == [String(localized: "Fill Column")])
         for row in 0..<4 {
-            #expect(manager.pending.isCellModified(rowID: .existing(row), columnIndex: 0))
+            #expect(grid.owner.staged(row, 0)?.value == .text("X"))
+            #expect(grid.owner.staged(row, 1) == nil)
         }
-        #expect(manager.pending.isCellModified(rowID: .existing(0), columnIndex: 1) == false)
     }
 
     @Test("Does not touch rows marked for deletion")
     func skipsDeletedRowsOnApply() {
-        let manager = DataChangeManager()
-        let coordinator = makeCoordinator(columns: ["a"], rowCount: 4, manager: manager)
-        manager.recordRowDeletion(rowID: .existing(2), originalRow: [.text("r2c0")])
+        let grid = makeGrid(columns: ["a"], rowCount: 4)
+        grid.owner.changeManager.recordRowDeletion(rowID: .existing(2), originalRow: [.text("r2c0")])
 
-        coordinator.applyFillColumn(columnIndex: 0, content: .value(.text("X")))
+        grid.commands.applyFillColumn(column(grid, 0), content: .value(.text("X")))
 
-        #expect(manager.pending.isCellModified(rowID: .existing(0), columnIndex: 0))
-        #expect(manager.pending.isCellModified(rowID: .existing(2), columnIndex: 0) == false)
+        #expect(grid.owner.staged(0, 0)?.value == .text("X"))
+        #expect(grid.owner.staged(2, 0) == nil)
     }
 
-    @Test("Records nothing on a read-only result set")
+    @Test("Records nothing on a read-only result")
     func recordsNothingWhenReadOnly() {
-        let manager = DataChangeManager()
-        let coordinator = makeCoordinator(columns: ["a"], rowCount: 4, isEditable: false, manager: manager)
+        let grid = makeGrid(columns: ["a"], rowCount: 4, isEditable: false)
 
-        coordinator.applyFillColumn(columnIndex: 0, content: .value(.text("X")))
+        grid.commands.applyFillColumn(column(grid, 0), content: .value(.text("X")))
 
-        #expect(manager.hasChanges == false)
+        #expect(grid.owner.commits.isEmpty)
     }
 
     @Test("Writes NULL as a null change, not an empty string")
     func appliesNull() {
-        let manager = DataChangeManager()
-        let coordinator = makeCoordinator(columns: ["a"], rowCount: 2, manager: manager)
+        let grid = makeGrid(columns: ["a"], rowCount: 2)
 
-        coordinator.applyFillColumn(columnIndex: 0, content: .value(.null))
+        grid.commands.applyFillColumn(column(grid, 0), content: .value(.null))
 
-        let change = manager.pending.change(forRow: .existing(0), type: .update)
-        #expect(change?.cellChanges.first?.newValue == .null)
+        #expect(grid.owner.staged(0, 0)?.value == .null)
     }
 
     @Test("Skips rows whose value already equals the fill value")
     func skipsRowsAlreadyEqual() {
-        let manager = DataChangeManager()
-        let coordinator = makeCoordinator(columns: ["a"], rowCount: 2, manager: manager)
+        let grid = makeGrid(columns: ["a"], rowCount: 2)
 
-        coordinator.applyFillColumn(columnIndex: 0, content: .value(.text("r0c0")))
+        grid.commands.applyFillColumn(column(grid, 0), content: .value(.text("r0c0")))
 
-        #expect(manager.pending.isCellModified(rowID: .existing(0), columnIndex: 0) == false)
-        #expect(manager.pending.isCellModified(rowID: .existing(1), columnIndex: 0))
+        #expect(grid.owner.staged(0, 0) == nil)
+        #expect(grid.owner.staged(1, 0)?.value == .text("r0c0"))
     }
 
-    @Test("New UUID writes a different UUID into every row")
+    @Test("New UUID writes a different UUID into every row, in row order")
     func uuidFillDrawsOnePerRow() throws {
-        let manager = DataChangeManager()
-        let coordinator = makeCoordinator(
-            columns: ["id"],
-            rowCount: 3,
-            columnTypes: [.text(rawType: "uuid")],
-            databaseType: .postgresql,
-            manager: manager
-        )
-        let content = try #require(coordinator.fillColumnContent(choice: .uuid(.v7), text: "", columnIndex: 0))
+        let grid = makeGrid(columns: ["id"], rowCount: 3, columnTypes: [.text(rawType: "uuid")])
+        let content = try #require(grid.commands.fillColumnContent(choice: .uuid(.v7), text: "", column: column(grid, 0)))
 
-        coordinator.applyFillColumn(columnIndex: 0, content: content)
+        grid.commands.applyFillColumn(column(grid, 0), content: content)
 
-        let staged = stagedValues(manager, column: 0, rows: 0..<3).compactMap { $0?.asText }
+        let staged = (0..<3).compactMap { grid.owner.staged($0, 0)?.value.asText }
         #expect(staged.count == 3)
         #expect(Set(staged).count == 3)
         #expect(staged.allSatisfy { UUID(uuidString: $0) != nil && $0 == $0.lowercased() })
@@ -229,31 +173,18 @@ struct FillColumnTests {
 
     @Test("A fill function is staged as SQL on every row")
     func expressionFillIsMarked() {
-        let manager = DataChangeManager()
-        let coordinator = makeCoordinator(
-            columns: ["seen"],
-            rowCount: 2,
-            columnTypes: [.timestamp(rawType: "timestamptz")],
-            databaseType: .postgresql,
-            manager: manager
-        )
+        let grid = makeGrid(columns: ["seen"], rowCount: 2, columnTypes: [.timestamp(rawType: "timestamptz")])
 
-        coordinator.applyFillColumn(columnIndex: 0, content: .value(.text("now()"), isExpression: true))
+        grid.commands.applyFillColumn(column(grid, 0), content: .value(.text("now()"), isExpression: true))
 
-        #expect(manager.isExpression(rowID: .existing(0), columnIndex: 0))
-        #expect(manager.isExpression(rowID: .existing(1), columnIndex: 0))
+        #expect(grid.owner.staged(0, 0)?.isExpression == true)
+        #expect(grid.owner.staged(1, 0)?.isExpression == true)
     }
 
     @Test("No UUID content on a column that holds none")
     func uuidFillRefusedOnText() {
-        let coordinator = makeCoordinator(
-            columns: ["name"],
-            rowCount: 1,
-            columnTypes: [.text(rawType: "text")],
-            databaseType: .postgresql,
-            manager: DataChangeManager()
-        )
+        let grid = makeGrid(columns: ["name"], rowCount: 1, columnTypes: [.text(rawType: "text")])
 
-        #expect(coordinator.fillColumnContent(choice: .uuid(.v4), text: "", columnIndex: 0) == nil)
+        #expect(grid.commands.fillColumnContent(choice: .uuid(.v4), text: "", column: column(grid, 0)) == nil)
     }
 }
diff --git a/apple/TableProTests/Views/Results/Extensions/InlineEditEligibilityTests.swift b/apple/TableProTests/Views/Results/Extensions/InlineEditEligibilityTests.swift
index 6cda37d347..b9070379ad 100644
--- a/apple/TableProTests/Views/Results/Extensions/InlineEditEligibilityTests.swift
+++ b/apple/TableProTests/Views/Results/Extensions/InlineEditEligibilityTests.swift
@@ -5,85 +5,87 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class StubColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
+// Which cells take the text editor: the gate every way into editing (Return, a click, Tab, an owner) goes through.
 @MainActor
 struct InlineEditEligibilityTests {
-    private func makeCoordinator(columnType: ColumnType, value: String) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubColumnLayoutPersister()
-        )
-        let tableRows = TableRows.from(
-            queryRows: [[PluginCellValue.text(value)]],
+    private func makeGrid(
+        columnType: ColumnType,
+        value: PluginCellValue,
+        configure: (inout DataGridConfiguration) -> Void = { _ in },
+        unloaded: Bool = false
+    ) -> EditingGrid {
+        var configuration = EditingGrid.editable
+        configure(&configuration)
+        let rows = TableRows.from(
+            queryRows: [[value]],
             columns: ["col"],
-            columnTypes: [columnType]
+            columnTypes: [columnType],
+            unloadedCells: unloaded ? [0: [0: 1_024]] : [:]
         )
-        coordinator.tableRowsProvider = { tableRows }
-        return coordinator
+        return EditingGrid(rows: rows, configuration: configuration)
+    }
+
+    private func editableText(_ grid: EditingGrid) -> String? {
+        guard let cell = grid.controller.editCell(at: GridCoord(row: 0, displayColumn: 0)) else { return nil }
+        return grid.controller.textEditableValue(of: cell)
     }
 
-    @Test("JSON column is eligible for inline editing")
-    func jsonColumnIsInlineEditable() {
-        let coordinator = makeCoordinator(columnType: .json(rawType: "JSON"), value: #"{"k":1}"#)
-        #expect(coordinator.canStartInlineEdit(row: 0, columnIndex: 0))
+    @Test("A JSON column takes the text editor")
+    func jsonColumnIsEditable() {
+        let grid = makeGrid(columnType: .json(rawType: "JSON"), value: .text(#"{"k":1}"#))
+        defer { grid.tearDown() }
+
+        #expect(editableText(grid) == #"{"k":1}"#)
     }
 
-    @Test("BLOB column is not eligible for inline editing")
-    func blobColumnIsNotInlineEditable() {
-        let coordinator = makeCoordinator(columnType: .blob(rawType: "BLOB"), value: "x")
-        #expect(!coordinator.canStartInlineEdit(row: 0, columnIndex: 0))
+    @Test("A BLOB column does not; its editor is the hex popover")
+    func blobColumnIsNotEditable() {
+        let grid = makeGrid(columnType: .blob(rawType: "BLOB"), value: .text("x"))
+        defer { grid.tearDown() }
+
+        #expect(editableText(grid) == nil)
     }
 
-    @Test("plain text column is eligible for inline editing")
-    func textColumnIsInlineEditable() {
-        let coordinator = makeCoordinator(columnType: .text(rawType: "TEXT"), value: "hello")
-        #expect(coordinator.canStartInlineEdit(row: 0, columnIndex: 0))
+    @Test("Bytes in a text column do not either")
+    func bytesAreNotEditable() {
+        let grid = makeGrid(columnType: .text(rawType: "TEXT"), value: .bytes(Data([0xDE, 0xAD])))
+        defer { grid.tearDown() }
+
+        #expect(editableText(grid) == nil)
     }
 
-    private func makeNewRowCoordinator() -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StubColumnLayoutPersister()
-        )
-        let tableRows = TableRows.from(
-            queryRows: [[.text("0b8f6c1e-4a7e-4d43-9d0c-2f4c5b6a7e81"), .bytes(Data([1])), .null, .null]],
-            columns: ["id", "photo", "name", "note"],
-            columnTypes: [.text(rawType: "uuid"), .blob(rawType: "bytea"), .text(rawType: "text"), .text(rawType: "text")]
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        return coordinator
+    @Test("A plain text column takes it, and a NULL opens as empty text")
+    func textColumnIsEditable() {
+        let text = makeGrid(columnType: .text(rawType: "TEXT"), value: .text("hello"))
+        defer { text.tearDown() }
+        let null = makeGrid(columnType: .text(rawType: "TEXT"), value: .null)
+        defer { null.tearDown() }
+
+        #expect(editableText(text) == "hello")
+        #expect(editableText(null) == "")
     }
 
-    @Test("The caret on a new row passes over the columns it was given a value for")
-    func caretSkipsPrefilledColumns() {
-        let coordinator = makeNewRowCoordinator()
+    @Test("A read-only grid and a locked column take no text")
+    func readOnlyAndLockedAreNotEditable() {
+        let readOnly = makeGrid(columnType: .text(rawType: "TEXT"), value: .text("a")) { $0.isEditable = false }
+        defer { readOnly.tearDown() }
+        let locked = makeGrid(columnType: .text(rawType: "TEXT"), value: .text("a")) { $0.lockedColumns = ["col"] }
+        defer { locked.tearDown() }
 
-        #expect(coordinator.firstEditableColumn(displayRow: 0) == 0)
-        #expect(coordinator.firstEditableColumn(displayRow: 0, skipping: [0]) == 2)
-        #expect(coordinator.firstEditableColumn(displayRow: 0, skipping: [0, 2]) == 3)
+        #expect(editableText(readOnly) == nil)
+        #expect(editableText(locked) == nil)
     }
 
-    @Test("When every editable column was given a value the caret still opens on the first of them")
-    func caretFallsBackToAPrefilledColumn() {
-        let coordinator = makeNewRowCoordinator()
+    // Its NULL stands for a value still on the server, which no edit may replace unread (#3758).
+    @Test("A value the page left on the server takes no text until it loads")
+    func unloadedValueIsNotEditable() {
+        let grid = makeGrid(columnType: .text(rawType: "TEXT"), value: .null, unloaded: true)
+        defer { grid.tearDown() }
 
-        #expect(coordinator.firstEditableColumn(displayRow: 0, skipping: [0, 2, 3]) == 0)
+        #expect(editableText(grid) == nil)
     }
 }
diff --git a/apple/TableProTests/Views/Results/FocusedColumnResolutionTests.swift b/apple/TableProTests/Views/Results/FocusedColumnResolutionTests.swift
deleted file mode 100644
index 96256efd18..0000000000
--- a/apple/TableProTests/Views/Results/FocusedColumnResolutionTests.swift
+++ /dev/null
@@ -1,197 +0,0 @@
-//
-//  FocusedColumnResolutionTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class FocusedColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// `focusedColumn` is a position in `tableView.tableColumns`, which carries the row-number column
-/// ahead of the data and which the reader can reorder. Preview FK Reference used to turn it into a
-/// data index by subtracting 1, so the menu command previewed the wrong column or silently nothing
-/// while the key-equivalent path on the same cell worked.
-@MainActor
-struct FocusedColumnResolutionTests {
-    private func makeGrid(columns: [String]) -> (tableView: NSTableView, schema: ColumnIdentitySchema) {
-        let tableView = NSTableView()
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        let rowNumberColumn = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        rowNumberColumn.width = 40
-        tableView.addTableColumn(rowNumberColumn)
-
-        let schema = ColumnIdentitySchema(columns: columns)
-        DataGridColumnPool().reconcile(
-            tableView: tableView,
-            schema: schema,
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        return (tableView, schema)
-    }
-
-    private func makeCoordinator(columns: [String]) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FocusedColumnLayoutPersister()
-        )
-        let rows = columns.map { PluginCellValue.text($0) }
-        let tableRows = TableRows.from(
-            queryRows: [rows],
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: [],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        tableView.reloadData()
-        return coordinator
-    }
-
-    private func tableColumnIndex(of name: String, in grid: (tableView: NSTableView, schema: ColumnIdentitySchema)) -> Int? {
-        guard let identifier = grid.schema.identifier(for: grid.schema.dataIndex(forColumnName: name) ?? -1) else {
-            return nil
-        }
-        let index = grid.tableView.column(withIdentifier: identifier)
-        return index >= 0 ? index : nil
-    }
-
-    /// Moving the selection with the keyboard leaves no cell cursor behind, so the grid seeds one
-    /// from the selection change. Seeding it with a fixed position landed on chrome, and every
-    /// command that reads the cursor then resolved it to no column at all: Return opened no editor
-    /// while the menu item still validated as enabled (#2381).
-    @Test("A selection with no cell cursor seeds one on a data column, not chrome")
-    func selectionSeedsTheCursorOnADataColumn() throws {
-        let coordinator = makeCoordinator(columns: ["id", "name"])
-        let tableView = try #require(coordinator.tableView as? KeyHandlingTableView)
-        tableView.focusedRow = -1
-        tableView.focusedColumn = -1
-
-        tableView.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
-        coordinator.tableViewSelectionDidChange(
-            Notification(name: NSTableView.selectionDidChangeNotification, object: tableView)
-        )
-
-        #expect(coordinator.presentsColumn(atTableColumnIndex: tableView.focusedColumn))
-        #expect(
-            DataGridView.dataColumnIndex(
-                for: tableView.focusedColumn,
-                in: tableView,
-                schema: coordinator.identitySchema
-            ) == 0
-        )
-    }
-
-    /// The whole keystroke, not just the seed: with no cell cursor, a selection change seeds one and
-    /// Return has to open the editor on it. Seeded onto chrome, every step past the seed resolved to
-    /// no column and the keystroke was swallowed (#2381).
-    @Test("Return opens the editor on the column a keyboard selection seeded")
-    func returnOpensTheEditorOnTheSeededColumn() throws {
-        let coordinator = makeCoordinator(columns: ["id", "name"])
-        let tableView = try #require(coordinator.tableView as? KeyHandlingTableView)
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 600, height: 400),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView = tableView
-        tableView.layoutSubtreeIfNeeded()
-        tableView.focusedRow = -1
-        tableView.focusedColumn = -1
-
-        tableView.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
-        coordinator.tableViewSelectionDidChange(
-            Notification(name: NSTableView.selectionDidChangeNotification, object: tableView)
-        )
-        tableView.insertNewline(nil)
-
-        #expect(coordinator.overlayEditor != nil)
-    }
-
-    /// Resolution goes through the column's own identifier. Subtracting a fixed offset from the
-    /// position happens to agree while the row-number column is the only chrome, and stops agreeing
-    /// the moment the reader reorders a column or the grid grows another chrome column.
-    @Test("A data column resolves by identity, not by its distance from the start")
-    func dataColumnsResolveByIdentity() throws {
-        let grid = makeGrid(columns: ["id", "name", "customer_id"])
-        let tableColumn = try #require(tableColumnIndex(of: "customer_id", in: grid))
-
-        #expect(DataGridView.dataColumnIndex(for: tableColumn, in: grid.tableView, schema: grid.schema) == 2)
-
-        grid.tableView.moveColumn(tableColumn, toColumn: 1)
-        let moved = try #require(tableColumnIndex(of: "customer_id", in: grid))
-        #expect(DataGridView.dataColumnIndex(for: moved, in: grid.tableView, schema: grid.schema) == 2)
-    }
-
-    @Test("Every data column resolves back to its own index")
-    func everyColumnRoundTrips() throws {
-        let names = ["id", "name", "customer_id", "total"]
-        let grid = makeGrid(columns: names)
-
-        for (dataIndex, name) in names.enumerated() {
-            let tableColumn = try #require(tableColumnIndex(of: name, in: grid))
-            #expect(DataGridView.dataColumnIndex(for: tableColumn, in: grid.tableView, schema: grid.schema) == dataIndex)
-        }
-    }
-
-    @Test("Reordering a column moves it without changing what it resolves to")
-    func reorderingKeepsTheMapping() throws {
-        let grid = makeGrid(columns: ["id", "name", "customer_id"])
-        let before = try #require(tableColumnIndex(of: "customer_id", in: grid))
-        let firstData = try #require(tableColumnIndex(of: "id", in: grid))
-
-        grid.tableView.moveColumn(before, toColumn: firstData)
-        let after = try #require(tableColumnIndex(of: "customer_id", in: grid))
-
-        #expect(after != before)
-        #expect(DataGridView.dataColumnIndex(for: after, in: grid.tableView, schema: grid.schema) == 2)
-    }
-
-    /// The row-number column sits in `tableColumns` too, so a fixed position names chrome rather
-    /// than data.
-    @Test("The row-number column is not a data column")
-    func chromeColumnsAreNotData() {
-        let grid = makeGrid(columns: ["id", "name"])
-
-        let chrome = grid.tableView.tableColumns.indices.filter {
-            DataGridView.dataColumnIndex(for: $0, in: grid.tableView, schema: grid.schema) == nil
-        }
-
-        #expect(chrome == [0])
-    }
-}
diff --git a/apple/TableProTests/Views/Results/GridColumnDisplayOrderTests.swift b/apple/TableProTests/Views/Results/GridColumnDisplayOrderTests.swift
deleted file mode 100644
index 4fc9622cc3..0000000000
--- a/apple/TableProTests/Views/Results/GridColumnDisplayOrderTests.swift
+++ /dev/null
@@ -1,212 +0,0 @@
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class DisplayOrderLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// A live grid whose on-screen column order can be made to differ from the result's own, which is
-/// the only state in which a display position and a data index disagree.
-@MainActor
-private struct ReorderableGrid {
-    let tableView: KeyHandlingTableView
-    let coordinator: TableViewCoordinator
-    let columns: [String]
-
-    init(columns: [String] = ["id", "notes", "email"], rowCount: Int = 3) {
-        self.columns = columns
-        let rows = (0..<rowCount).map { row in
-            columns.map { PluginCellValue.text("\($0)\(row)") }
-        }
-        let tableRows = TableRows.from(
-            queryRows: rows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count)
-        )
-
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: DisplayOrderLayoutPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-
-        tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.style = .plain
-        tableView.intercellSpacing = NSSize(width: 1, height: 0)
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-
-        coordinator.tableView = tableView
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        /// Through the pool, not by attaching columns directly. `presentsColumn` answers from
-        /// `activeIdentifiers`, which only `reconcile` fills, so a hand-attached column is present
-        /// on screen and invisible to every display-position lookup these tests are about.
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: columns),
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.updateCache()
-        tableView.reloadData()
-    }
-
-    /// Hides a column the way the Columns popover does.
-    func hideColumn(named name: String) {
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: ColumnIdentitySchema(columns: columns),
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [name],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.invalidateColumnIndexCache()
-    }
-
-    /// Moves an attached column, the way dragging its header does. The destination is worked out
-    /// from the presented run rather than by adding one for the row-number column: no fixed position
-    /// in `tableColumns` names a data column (#2381).
-    func moveColumn(named name: String, toDisplayPosition position: Int) {
-        guard let dataIndex = columns.firstIndex(of: name),
-              let from = coordinator.tableColumnIndex(for: dataIndex),
-              let firstPresented = coordinator.firstPresentedColumnIndex() else { return }
-        tableView.moveColumn(from, toColumn: firstPresented + position)
-        coordinator.invalidateColumnIndexCache()
-    }
-
-    var presentedNames: [String] {
-        coordinator.presentedDataColumns.map { columns[$0] }
-    }
-}
-
-extension GlobalStateSuites {
-    @Suite(.recordingClipboard)
-    @MainActor
-    struct GridColumnDisplayOrderTests {
-        @Test("a display position resolves to the data index of the column drawn there")
-        func displayPositionFollowsTheDrawnOrder() {
-            let grid = ReorderableGrid()
-            #expect(grid.presentedNames == ["id", "notes", "email"])
-
-            grid.moveColumn(named: "email", toDisplayPosition: 0)
-
-            #expect(grid.presentedNames == ["email", "id", "notes"])
-            #expect(grid.coordinator.dataColumnIndex(atDisplayPosition: 0) == 2)
-            #expect(grid.coordinator.displayPosition(ofDataColumnIndex: 2) == 0)
-        }
-
-        @Test("a swept block names the columns it crossed, not the slots between them")
-        func sweptBlockNamesTheColumnsCrossed() {
-            let grid = ReorderableGrid()
-            grid.moveColumn(named: "email", toDisplayPosition: 0)
-
-            let rect = GridRect(rows: 0...0, columns: 0...1)
-            let names = grid.coordinator.dataColumnIndices(in: rect.columns.reduce(into: IndexSet()) { $0.insert($1) })
-                .map { grid.columns[$0] }
-
-            #expect(names == ["email", "id"])
-            #expect(!names.contains("notes"))
-        }
-
-        @Test("the presented count is the run on screen, not every slot the result carries")
-        func presentedCountIsTheRunOnScreen() {
-            let grid = ReorderableGrid()
-
-            #expect(grid.coordinator.presentedColumnCount == 3)
-            #expect(grid.coordinator.presentedColumnCount == grid.coordinator.identitySchema.totalDataColumns)
-        }
-
-        @Test("a copy of a swept block writes the columns in the order they are drawn")
-        func copyWritesDisplayOrder() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-            let grid = ReorderableGrid()
-            grid.moveColumn(named: "email", toDisplayPosition: 0)
-
-            grid.coordinator.selectionController.update(
-                .single(
-                    GridRect(rows: 0...1, columns: 0...1),
-                    anchor: GridCoord(row: 0, displayColumn: 0),
-                    active: GridCoord(row: 1, displayColumn: 1)
-                )
-            )
-            grid.coordinator.copyGridSelection(grid.coordinator.selectionController.selection)
-
-            let copied = clipboard.readText() ?? ""
-            let firstRow = copied.components(separatedBy: "\n").first ?? ""
-            let fields = firstRow.components(separatedBy: "\t")
-
-            #expect(fields.count == 2)
-            #expect(fields.first == "email0")
-            #expect(fields.last == "id0")
-            #expect(!copied.contains("notes"))
-        }
-
-        @Test("a hidden column drops out of the display run and out of a copy")
-        func hiddenColumnDropsOutOfTheRun() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-            let grid = ReorderableGrid()
-            grid.hideColumn(named: "notes")
-
-            #expect(grid.presentedNames == ["id", "email"])
-            #expect(grid.coordinator.presentedColumnCount == 2)
-            #expect(grid.coordinator.dataColumnIndex(atDisplayPosition: 1) == 2)
-            #expect(grid.coordinator.displayPosition(ofDataColumnIndex: 1) == nil)
-
-            grid.coordinator.selectionController.update(
-                .single(
-                    GridRect(rows: 0...0, columns: 0...1),
-                    anchor: GridCoord(row: 0, displayColumn: 0),
-                    active: GridCoord(row: 0, displayColumn: 1)
-                )
-            )
-            grid.coordinator.copyGridSelection(grid.coordinator.selectionController.selection)
-
-            let copied = clipboard.readText() ?? ""
-            #expect(copied.components(separatedBy: "\t").count == 2)
-            #expect(!copied.contains("notes"))
-        }
-
-        @Test("a paste fills the columns beside the anchor on screen")
-        func pasteFillsTheColumnsOnScreen() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-            let grid = ReorderableGrid()
-            grid.moveColumn(named: "email", toDisplayPosition: 0)
-            #expect(grid.presentedNames == ["email", "id", "notes"])
-            clipboard.writeText("x\ty")
-
-            let emailDataIndex = 2
-            let pasted = grid.coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: emailDataIndex)
-
-            #expect(pasted)
-            /// email is the anchor and id is the column beside it on screen. Walking data indices
-            /// instead would have written email then run off the end of the result and dropped `y`.
-            let written = grid.coordinator.changeManager.rowChanges
-                .flatMap(\.cellChanges)
-                .map { ($0.columnName, $0.newValue.asText ?? "") }
-            #expect(written.count == 2)
-            #expect(written.contains { $0.0 == "email" && $0.1 == "x" })
-            #expect(written.contains { $0.0 == "id" && $0.1 == "y" })
-            #expect(!written.contains { $0.0 == "notes" })
-        }
-    }
-}
diff --git a/apple/TableProTests/Views/Results/GridDragClampTests.swift b/apple/TableProTests/Views/Results/GridDragClampTests.swift
deleted file mode 100644
index 37f8d3274b..0000000000
--- a/apple/TableProTests/Views/Results/GridDragClampTests.swift
+++ /dev/null
@@ -1,80 +0,0 @@
-import Foundation
-@testable import TablePro
-import Testing
-
-struct GridDragClampTests {
-    private let firstPresented = 1
-    private let lastPresented = 4
-    private let lastMaxX: CGFloat = 500
-
-    @Test("a drag past the trailing edge holds the last column")
-    func pastTrailingEdgeHoldsLastColumn() {
-        let resolved = GridDragClamp.column(
-            hit: -1,
-            pointX: 5_000,
-            firstPresented: firstPresented,
-            lastPresented: lastPresented,
-            lastPresentedMaxX: lastMaxX
-        )
-
-        #expect(resolved == lastPresented)
-    }
-
-    @Test("a drag past the leading edge holds the first column")
-    func pastLeadingEdgeHoldsFirstColumn() {
-        let resolved = GridDragClamp.column(
-            hit: -1,
-            pointX: -30,
-            firstPresented: firstPresented,
-            lastPresented: lastPresented,
-            lastPresentedMaxX: lastMaxX
-        )
-
-        #expect(resolved == firstPresented)
-    }
-
-    @Test("a hit inside the run is clamped into the presented range")
-    func hitInsideRunIsClamped() {
-        #expect(clampColumn(hit: 3, x: 200) == 3)
-        #expect(clampColumn(hit: 0, x: 10) == firstPresented)
-        #expect(clampColumn(hit: 9, x: 480) == lastPresented)
-    }
-
-    @Test("a grid presenting no column resolves nothing")
-    func noPresentedColumnResolvesNothing() {
-        #expect(GridDragClamp.column(
-            hit: -1, pointX: 100, firstPresented: -1, lastPresented: -1, lastPresentedMaxX: 0
-        ) == nil)
-    }
-
-    @Test("a drag below the last row holds the last row")
-    func belowLastRowHoldsLastRow() {
-        #expect(GridDragClamp.row(hit: -1, pointY: 99_999, rowCount: 40, lastRowMaxY: 880) == 39)
-    }
-
-    @Test("a drag above the first row holds the first row")
-    func aboveFirstRowHoldsFirstRow() {
-        #expect(GridDragClamp.row(hit: -1, pointY: -30, rowCount: 40, lastRowMaxY: 880) == 0)
-    }
-
-    @Test("a row hit past the end is clamped to the last row")
-    func rowHitPastEndIsClamped() {
-        #expect(GridDragClamp.row(hit: 99, pointY: 400, rowCount: 40, lastRowMaxY: 880) == 39)
-        #expect(GridDragClamp.row(hit: 7, pointY: 160, rowCount: 40, lastRowMaxY: 880) == 7)
-    }
-
-    @Test("an empty grid resolves no row")
-    func emptyGridResolvesNoRow() {
-        #expect(GridDragClamp.row(hit: -1, pointY: 10, rowCount: 0, lastRowMaxY: 0) == nil)
-    }
-
-    private func clampColumn(hit: Int, x: CGFloat) -> Int? {
-        GridDragClamp.column(
-            hit: hit,
-            pointX: x,
-            firstPresented: firstPresented,
-            lastPresented: lastPresented,
-            lastPresentedMaxX: lastMaxX
-        )
-    }
-}
diff --git a/apple/TableProTests/Views/Results/GridSelectionCopyTruncationTests.swift b/apple/TableProTests/Views/Results/GridSelectionCopyTruncationTests.swift
index 2f7886a25e..1d0e8ea8f4 100644
--- a/apple/TableProTests/Views/Results/GridSelectionCopyTruncationTests.swift
+++ b/apple/TableProTests/Views/Results/GridSelectionCopyTruncationTests.swift
@@ -1,37 +1,19 @@
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class TruncationLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
 extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
     struct GridSelectionCopyTruncationTests {
-        private func makeCoordinator(rowCount: Int) -> TableViewCoordinator {
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: true,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: TruncationLayoutPersister()
-            )
-            let tableRows = TableRows.from(
+        private func grid(rowCount: Int) -> CommandGrid {
+            CommandGrid(TableRows.from(
                 queryRows: (0..<rowCount).map { [.text("\($0)"), .text("v\($0)")] },
                 columns: ["id", "value"],
                 columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
-            )
-            coordinator.tableRowsProvider = { tableRows }
-            coordinator.updateCache()
-            return coordinator
+            ))
         }
 
         private static func block(rowCount: Int) -> GridSelection {
@@ -47,9 +29,9 @@ extension GlobalStateSuites {
             let clipboard = try #require(RecordingClipboard.current)
             let cap = RowOperationsManager.maxClipboardRows
             let rowCount = cap + 2
-            let coordinator = makeCoordinator(rowCount: rowCount)
 
-            coordinator.copyGridSelection(Self.block(rowCount: rowCount))
+            let commandGrid = grid(rowCount: rowCount)
+            commandGrid.commands.copyRange(Self.block(rowCount: rowCount))
 
             let lines = clipboard.text?.components(separatedBy: "\n") ?? []
             #expect(lines.count == cap + 1)
@@ -61,9 +43,9 @@ extension GlobalStateSuites {
         @Test("a cell copy under the cap carries no notice")
         func copyUnderTheCapHasNoNotice() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let coordinator = makeCoordinator(rowCount: 3)
 
-            coordinator.copyGridSelection(Self.block(rowCount: 3))
+            let commandGrid = grid(rowCount: 3)
+            commandGrid.commands.copyRange(Self.block(rowCount: 3))
 
             #expect(clipboard.text == "0\tv0\n1\tv1\n2\tv2")
         }
diff --git a/apple/TableProTests/Views/Results/HeaderSortCycleTests.swift b/apple/TableProTests/Views/Results/HeaderSortCycleTests.swift
deleted file mode 100644
index bfa6123d43..0000000000
--- a/apple/TableProTests/Views/Results/HeaderSortCycleTests.swift
+++ /dev/null
@@ -1,262 +0,0 @@
-//
-//  HeaderSortCycleTests.swift
-//  TableProTests
-//
-
-import Foundation
-import TableProPluginKit
-@testable import TablePro
-import Testing
-
-struct HeaderSortCycleSingleColumnTests {
-    @Test("No active sort starts ascending")
-    func noActiveSortStartsAscending() {
-        let transition = HeaderSortCycle.nextTransition(
-            state: SortState(),
-            clickedColumn: 2,
-            isMultiSort: false,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 2, direction: .ascending)])
-    }
-
-    @Test("Ascending on this column advances to descending")
-    func ascendingAdvancesToDescending() {
-        var state = SortState()
-        state.columns = [SortColumn(columnIndex: 2, direction: .ascending)]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 2,
-            isMultiSort: false,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 2, direction: .descending)])
-    }
-
-    @Test("Descending on this column clears the sort")
-    func descendingClearsSort() {
-        var state = SortState()
-        state.columns = [SortColumn(columnIndex: 2, direction: .descending)]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 2,
-            isMultiSort: false,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns.isEmpty)
-    }
-
-    @Test("Different column replaces primary with ascending")
-    func differentColumnReplacesPrimary() {
-        var state = SortState()
-        state.columns = [SortColumn(columnIndex: 1, direction: .descending)]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 4,
-            isMultiSort: false,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 4, direction: .ascending)])
-    }
-
-    @Test("Multi-column primary cycles independently of secondary")
-    func multiColumnPrimaryCyclesIndependently() {
-        var state = SortState()
-        state.columns = [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 3, direction: .descending)
-        ]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 1,
-            isMultiSort: false,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 1, direction: .descending)])
-    }
-
-    @Test("Click on secondary column without shift replaces primary")
-    func clickOnSecondaryWithoutShiftReplacesPrimary() {
-        var state = SortState()
-        state.columns = [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 3, direction: .descending)
-        ]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 3,
-            isMultiSort: false,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 3, direction: .ascending)])
-    }
-}
-
-struct HeaderSortCycleMultiColumnTests {
-    @Test("Shift-click on unsorted column adds it ascending")
-    func shiftClickUnsortedAddsAscending() {
-        var state = SortState()
-        state.columns = [SortColumn(columnIndex: 1, direction: .ascending)]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 3,
-            isMultiSort: true,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 3, direction: .ascending)
-        ])
-    }
-
-    @Test("Shift-click on existing ascending column toggles to descending")
-    func shiftClickAscendingTogglesToDescending() {
-        var state = SortState()
-        state.columns = [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 3, direction: .ascending)
-        ]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 3,
-            isMultiSort: true,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 3, direction: .descending)
-        ])
-    }
-
-    @Test("Shift-click on existing descending column removes it from sort")
-    func shiftClickDescendingRemovesColumn() {
-        var state = SortState()
-        state.columns = [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 3, direction: .descending)
-        ]
-        let transition = HeaderSortCycle.nextTransition(
-            state: state,
-            clickedColumn: 3,
-            isMultiSort: true,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 1, direction: .ascending)])
-    }
-
-    @Test("Shift-click on empty state adds ascending")
-    func shiftClickEmptyAddsAscending() {
-        let transition = HeaderSortCycle.nextTransition(
-            state: SortState(),
-            clickedColumn: 0,
-            isMultiSort: true,
-            firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 0, direction: .ascending)])
-    }
-
-    @Test("Shift-click cycle: add then toggle then remove preserves siblings")
-    func shiftClickFullCyclePreservesSiblings() {
-        var state = SortState()
-        state.columns = [SortColumn(columnIndex: 1, direction: .ascending)]
-
-        let added = HeaderSortCycle.nextTransition(
-            state: state, clickedColumn: 5, isMultiSort: true, firstClickDirection: .ascending
-        )
-        #expect(added.newState.columns == [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 5, direction: .ascending)
-        ])
-
-        let toggled = HeaderSortCycle.nextTransition(
-            state: added.newState, clickedColumn: 5, isMultiSort: true, firstClickDirection: .ascending
-        )
-        #expect(toggled.newState.columns == [
-            SortColumn(columnIndex: 1, direction: .ascending),
-            SortColumn(columnIndex: 5, direction: .descending)
-        ])
-
-        let removed = HeaderSortCycle.nextTransition(
-            state: toggled.newState, clickedColumn: 5, isMultiSort: true, firstClickDirection: .ascending
-        )
-        #expect(removed.newState.columns == [SortColumn(columnIndex: 1, direction: .ascending)])
-    }
-}
-
-struct HeaderSortCycleSourceTests {
-    @Test("A default sort's first click reverses it, and the result is the user's")
-    func defaultSortFirstClickReverses() {
-        let state = SortState(
-            columns: [SortColumn(columnIndex: 0, direction: .ascending)],
-            source: .defaultSort
-        )
-        let transition = HeaderSortCycle.nextTransition(
-            state: state, clickedColumn: 0, isMultiSort: false, firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns == [SortColumn(columnIndex: 0, direction: .descending)])
-        #expect(transition.newState.source == .user)
-    }
-
-    @Test("Clearing a sort by clicking is the user's empty state, never unset")
-    func clearingStampsUser() {
-        let state = SortState(
-            columns: [SortColumn(columnIndex: 2, direction: .descending)],
-            source: .user
-        )
-        let transition = HeaderSortCycle.nextTransition(
-            state: state, clickedColumn: 2, isMultiSort: false, firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns.isEmpty)
-        #expect(transition.newState.source == .user)
-    }
-
-    @Test("A shift-click on a default sort becomes the user's, so the tab stops being reusable")
-    func shiftClickPromotesDefaultToUser() {
-        let state = SortState(
-            columns: [SortColumn(columnIndex: 0, direction: .ascending)],
-            source: .defaultSort
-        )
-        let transition = HeaderSortCycle.nextTransition(
-            state: state, clickedColumn: 3, isMultiSort: true, firstClickDirection: .ascending
-        )
-        #expect(transition.newState.columns.map(\.columnIndex) == [0, 3])
-        #expect(transition.newState.source == .user)
-    }
-
-    @Test("A descending first-click direction reverses the whole cycle")
-    func descendingFirstClickDirection() {
-        let first = HeaderSortCycle.nextTransition(
-            state: SortState(), clickedColumn: 1, isMultiSort: false, firstClickDirection: .descending
-        )
-        #expect(first.newState.columns == [SortColumn(columnIndex: 1, direction: .descending)])
-
-        let second = HeaderSortCycle.nextTransition(
-            state: first.newState, clickedColumn: 1, isMultiSort: false, firstClickDirection: .descending
-        )
-        #expect(second.newState.columns == [SortColumn(columnIndex: 1, direction: .ascending)])
-
-        let third = HeaderSortCycle.nextTransition(
-            state: second.newState, clickedColumn: 1, isMultiSort: false, firstClickDirection: .descending
-        )
-        #expect(third.newState.columns.isEmpty)
-    }
-
-    @Test("A descending shift-click adds, toggles, then removes")
-    func descendingMultiSortCycle() {
-        let base = SortState(columns: [SortColumn(columnIndex: 0, direction: .descending)], source: .user)
-        let added = HeaderSortCycle.nextTransition(
-            state: base, clickedColumn: 2, isMultiSort: true, firstClickDirection: .descending
-        )
-        #expect(added.newState.columns.map(\.direction) == [.descending, .descending])
-
-        let toggled = HeaderSortCycle.nextTransition(
-            state: added.newState, clickedColumn: 2, isMultiSort: true, firstClickDirection: .descending
-        )
-        #expect(toggled.newState.columns.map(\.direction) == [.descending, .ascending])
-
-        let removed = HeaderSortCycle.nextTransition(
-            state: toggled.newState, clickedColumn: 2, isMultiSort: true, firstClickDirection: .descending
-        )
-        #expect(removed.newState.columns.map(\.columnIndex) == [0])
-    }
-}
diff --git a/apple/TableProTests/Views/Results/InvisibleCharacterSettingTests.swift b/apple/TableProTests/Views/Results/InvisibleCharacterSettingTests.swift
index 82d07fa546..511e3343f5 100644
--- a/apple/TableProTests/Views/Results/InvisibleCharacterSettingTests.swift
+++ b/apple/TableProTests/Views/Results/InvisibleCharacterSettingTests.swift
@@ -4,7 +4,6 @@
 //
 
 import AppKit
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import TableProTestSupport
@@ -20,7 +19,7 @@ extension GlobalStateSuites {
         func editorFollowsTheSetting() async throws {
             let state = MultiRowEditState()
             state.configure(
-                selectedRowIndices: [0],
+                rowIDs: [.existing(0)],
                 allRows: [["abc\u{200B}", "plain"]],
                 columns: ["marked", "plain"],
                 columnTypes: [.text(rawType: "VARCHAR(20)"), .text(rawType: "VARCHAR(20)")]
@@ -41,9 +40,10 @@ extension GlobalStateSuites {
             .appSettings { $0.dataGrid.showInvisibleCharacters = false }
         )
         func findReadsTheUnmarkedText() {
-            let coordinator = makeCoordinator(values: ["a\rb"])
+            let (model, owner) = makeModel(values: ["a\rb"])
+            defer { withExtendedLifetime(owner) {} }
 
-            #expect(coordinator.runFind(term: "a b").count == 1)
+            #expect(find("a b", in: model).count == 1)
         }
 
         @Test(
@@ -51,28 +51,34 @@ extension GlobalStateSuites {
             .appSettings { $0.dataGrid.showInvisibleCharacters = true }
         )
         func findReadsTheMarkedText() {
-            let coordinator = makeCoordinator(values: ["a\rb"])
+            let (model, owner) = makeModel(values: ["a\rb"])
+            defer { withExtendedLifetime(owner) {} }
 
-            #expect(coordinator.runFind(term: "a b").isEmpty)
-            #expect(coordinator.runFind(term: "b").count == 1)
+            #expect(find("a b", in: model).isEmpty)
+            #expect(find("b", in: model).count == 1)
         }
 
-        private func makeCoordinator(values: [String]) -> TableViewCoordinator {
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: true,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: InMemoryColumnLayoutStore()
+        // The model holds its owner weakly, so the caller keeps the owner alive.
+        private func makeModel(values: [String]) -> (DataGridModel, GridTestOwner) {
+            let rows = TableRows.from(
+                queryRows: values.map { [PluginCellValue.text($0)] },
+                columns: ["v"],
+                columnTypes: [.text(rawType: nil)]
             )
-            let rows = ContiguousArray(values.enumerated().map { index, value in
-                Row(id: .existing(index), values: [PluginCellValue.text(value)])
-            })
-            var captured = TableRows(rows: rows, columns: ["v"], columnTypes: [.text(rawType: nil)])
-            coordinator.tableRowsProvider = { captured }
-            coordinator.tableRowsMutator = { (mutation: (inout TableRows) -> Delta) in mutation(&captured) }
-            coordinator.updateCache()
-            return coordinator
+            let owner = GridTestOwner(rows)
+            let model = DataGridModel()
+            model.dataSource = owner
+            model.actions = owner
+            owner.model = model
+            model.reloadRows()
+            return (model, owner)
+        }
+
+        private func find(_ term: String, in model: DataGridModel) -> [GridFindState.Match] {
+            model.showFind()
+            model.find.term = term
+            model.findQueryDidChange()
+            return model.find.matches
         }
     }
 }
diff --git a/apple/TableProTests/Views/Results/KeyHandlingTableViewCopyTests.swift b/apple/TableProTests/Views/Results/KeyHandlingTableViewCopyTests.swift
deleted file mode 100644
index a3948c09de..0000000000
--- a/apple/TableProTests/Views/Results/KeyHandlingTableViewCopyTests.swift
+++ /dev/null
@@ -1,113 +0,0 @@
-//
-//  KeyHandlingTableViewCopyTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class KeyHandlingCopyLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class KeyHandlingCopyDelegateSpy: DataGridViewDelegate {
-    var copiedRows: Set<Int>?
-    var deletedRows: Set<Int>?
-
-    func dataGridCopyRows(_ indices: Set<Int>) {
-        copiedRows = indices
-    }
-
-    func dataGridDeleteRows(_ indices: Set<Int>) {
-        deletedRows = indices
-    }
-}
-
-@MainActor
-struct KeyHandlingTableViewCopyTests {
-    private func makeSUT(
-        delegate: any DataGridViewDelegate
-    ) -> (KeyHandlingTableView, TableViewCoordinator) {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: delegate,
-            layoutPersister: KeyHandlingCopyLayoutPersister()
-        )
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        coordinator.tableView = tableView
-        return (tableView, coordinator)
-    }
-
-    private func applyRangeSelection(to coordinator: TableViewCoordinator) {
-        coordinator.selectionController.update(
-            .single(
-                GridRect(rows: 0...1, columns: 0...1),
-                anchor: GridCoord(row: 0, displayColumn: 0),
-                active: GridCoord(row: 1, displayColumn: 0)
-            )
-        )
-    }
-
-    @Test("Copy Rows sends every row of the range selection")
-    func copyRowsAsTsvUsesRangeSelection() {
-        let delegate = KeyHandlingCopyDelegateSpy()
-        let (tableView, coordinator) = makeSUT(delegate: delegate)
-        applyRangeSelection(to: coordinator)
-
-        tableView.copyRowsAsTSV(nil)
-
-        #expect(delegate.copiedRows == Set([0, 1]))
-    }
-
-    @Test("Delete removes every row of the range selection")
-    func deleteUsesRangeSelection() {
-        let delegate = KeyHandlingCopyDelegateSpy()
-        let (tableView, coordinator) = makeSUT(delegate: delegate)
-        applyRangeSelection(to: coordinator)
-
-        tableView.delete(nil)
-
-        #expect(delegate.deletedRows == Set([0, 1]))
-    }
-
-    @Test("Copy Rows stays enabled when only a range selection exists")
-    func validateCopyRowsWithRangeSelectionOnly() {
-        let delegate = KeyHandlingCopyDelegateSpy()
-        let (tableView, coordinator) = makeSUT(delegate: delegate)
-        applyRangeSelection(to: coordinator)
-
-        let item = NSMenuItem(
-            title: "Copy Rows",
-            action: #selector(KeyHandlingTableView.copyRowsAsTSV(_:)),
-            keyEquivalent: ""
-        )
-
-        #expect(tableView.validateUserInterfaceItem(item))
-    }
-
-    @Test("Copy Rows stays disabled without any selection")
-    func validateCopyRowsWithoutSelection() {
-        let delegate = KeyHandlingCopyDelegateSpy()
-        let (tableView, _) = makeSUT(delegate: delegate)
-
-        let item = NSMenuItem(
-            title: "Copy Rows",
-            action: #selector(KeyHandlingTableView.copyRowsAsTSV(_:)),
-            keyEquivalent: ""
-        )
-
-        #expect(!tableView.validateUserInterfaceItem(item))
-    }
-}
diff --git a/apple/TableProTests/Views/Results/KeyHandlingTableViewOverlayTests.swift b/apple/TableProTests/Views/Results/KeyHandlingTableViewOverlayTests.swift
deleted file mode 100644
index e4f4ae1ce6..0000000000
--- a/apple/TableProTests/Views/Results/KeyHandlingTableViewOverlayTests.swift
+++ /dev/null
@@ -1,114 +0,0 @@
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import TableProTestSupport
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class StubColumnLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class OverlayCloseRecorder: DataGridViewDelegate {
-    private(set) var closedCount = 0
-
-    func dataGridDidCloseCellOverlay() {
-        closedCount += 1
-    }
-}
-
-@MainActor
-struct KeyHandlingTableViewOverlayTests {
-    private func makeCoordinator(delegate: (any DataGridViewDelegate)? = nil) -> TableViewCoordinator {
-        TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: delegate,
-            layoutPersister: StubColumnLayoutPersister()
-        )
-    }
-
-    @Test("adding a subview to the table leaves the selection overlay above it")
-    func addingSubviewKeepsSelectionOverlayOnTop() {
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        let selectionOverlay = GridSelectionOverlay(frame: tableView.bounds)
-        tableView.selectionOverlay = selectionOverlay
-        tableView.addSubview(selectionOverlay)
-
-        tableView.addSubview(NSView(frame: NSRect(x: 0, y: 0, width: 10, height: 10)))
-
-        #expect(tableView.subviews.last === selectionOverlay)
-    }
-
-    @Test("an open overlay is mounted beside the table, above the rows")
-    func openOverlayIsMountedBesideTheTable() {
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        let coordinator = makeCoordinator()
-        tableView.coordinator = coordinator
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        scrollView.documentView = tableView
-
-        let editor = CellOverlayEditor()
-        coordinator.overlayEditor = editor
-        let container = CellOverlayContainerView(frame: NSRect(x: 0, y: 0, width: 80, height: 24))
-        editor.install(in: tableView, row: 0, column: 0, columnIndex: 0, container: container)
-
-        let subviews = scrollView.subviews
-        let clipIndex = subviews.firstIndex { $0 === scrollView.contentView }
-        #expect(editor.isActive)
-        #expect(!container.isDescendant(of: tableView))
-        #expect(clipIndex.map { $0 + 1 } == subviews.firstIndex { $0 === container })
-
-        editor.removeOverlay()
-        #expect(container.superview == nil)
-    }
-
-    @Test("a table outside a scroll view opens no overlay")
-    func tableWithoutScrollViewOpensNoOverlay() {
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        let coordinator = makeCoordinator()
-        tableView.coordinator = coordinator
-
-        let editor = CellOverlayEditor()
-        coordinator.overlayEditor = editor
-        let container = CellOverlayContainerView(frame: NSRect(x: 0, y: 0, width: 80, height: 24))
-        editor.install(in: tableView, row: 0, column: 0, columnIndex: 0, container: container)
-
-        #expect(!editor.isActive)
-        #expect(container.superview == nil)
-    }
-
-    /// A reload a change put off while the overlay was open waits on this, and an editor that closes
-    /// with a commit records its edit only after removing itself, so the owner hears on the next turn.
-    @Test("closing a cell overlay tells the grid's owner on the next turn, once")
-    func closingAnOverlayTellsTheOwnerOnTheNextTurn() async throws {
-        let recorder = OverlayCloseRecorder()
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        let coordinator = makeCoordinator(delegate: recorder)
-        tableView.coordinator = coordinator
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        scrollView.documentView = tableView
-
-        for overlay in [CellOverlayViewer(), CellOverlayEditor()] as [CellOverlayBase] {
-            let before = recorder.closedCount
-            coordinator.observeRemoval(of: overlay)
-            let container = CellOverlayContainerView(frame: NSRect(x: 0, y: 0, width: 80, height: 24))
-            overlay.install(in: tableView, row: 0, column: 0, columnIndex: 0, container: container)
-            #expect(overlay.isActive)
-
-            overlay.removeOverlay()
-            overlay.removeOverlay()
-            #expect(recorder.closedCount == before)
-
-            _ = try? await waitUntil { recorder.closedCount != before }
-            #expect(recorder.closedCount == before + 1)
-        }
-    }
-}
diff --git a/apple/TableProTests/Views/Results/KeyHandlingTableViewSetValueTests.swift b/apple/TableProTests/Views/Results/KeyHandlingTableViewSetValueTests.swift
deleted file mode 100644
index ca76e067ca..0000000000
--- a/apple/TableProTests/Views/Results/KeyHandlingTableViewSetValueTests.swift
+++ /dev/null
@@ -1,178 +0,0 @@
-//
-//  KeyHandlingTableViewSetValueTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class MenuBarSetValueLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class MenuBarSetValueRowStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
-@MainActor
-struct KeyHandlingTableViewSetValueTests {
-    private static let id = 0
-    private static let note = 1
-
-    private struct SUT {
-        let manager: DataChangeManager
-        let coordinator: TableViewCoordinator
-        let tableView: KeyHandlingTableView
-        let store: MenuBarSetValueRowStore
-    }
-
-    /// Built through the column pool, so the focused positions are the ones the grid really has.
-    private func makeSUT(isEditable: Bool = true) -> SUT {
-        let manager = DataChangeManager()
-        manager.configureForTable(
-            tableName: "things",
-            columns: ["id", "note"],
-            primaryKeyColumns: ["id"],
-            databaseType: .postgresql,
-            generatedColumns: []
-        )
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(manager),
-            isEditable: isEditable,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: MenuBarSetValueLayoutPersister()
-        )
-        let store = MenuBarSetValueRowStore(TableRows.from(
-            queryRows: [[.null, .text("a")], [.null, .text("b")]],
-            columns: ["id", "note"],
-            columnTypes: [.text(rawType: "uuid"), .text(rawType: "text")],
-            columnNullable: ["id": false, "note": true]
-        ))
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-        coordinator.databaseType = .postgresql
-        coordinator.rebuildColumnMetadataCache(from: store.tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: [],
-            savedLayout: nil,
-            isEditable: isEditable,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        return SUT(manager: manager, coordinator: coordinator, tableView: tableView, store: store)
-    }
-
-    private func focus(_ sut: SUT, row: Int, dataColumn: Int) {
-        guard let identifier = sut.coordinator.identitySchema.identifier(for: dataColumn) else { return }
-        sut.tableView.focusedRow = row
-        sut.tableView.focusedColumn = sut.tableView.column(withIdentifier: identifier)
-    }
-
-    private func isEnabled(_ selector: Selector, in sut: SUT) -> Bool {
-        sut.tableView.validateUserInterfaceItem(NSMenuItem(title: "", action: selector, keyEquivalent: ""))
-    }
-
-    private static let empty = #selector(SetValueCommandResponding.setValueEmpty(_:))
-    private static let null = #selector(SetValueCommandResponding.setValueNull(_:))
-    private static let defaultValue = #selector(SetValueCommandResponding.setValueDefault(_:))
-    private static let uuidV4 = #selector(SetValueCommandResponding.generateUUIDv4(_:))
-    private static let uuidV7 = #selector(SetValueCommandResponding.generateUUIDv7(_:))
-    private static let cellsToValue = #selector(SetValueCommandResponding.setCellsToValue(_:))
-
-    @Test("On the focused uuid key only the UUID items are enabled")
-    func focusedUUIDKey() {
-        let sut = makeSUT()
-        focus(sut, row: 0, dataColumn: Self.id)
-
-        #expect(isEnabled(Self.uuidV4, in: sut))
-        #expect(isEnabled(Self.uuidV7, in: sut))
-        #expect(!isEnabled(Self.null, in: sut))
-        #expect(!isEnabled(Self.empty, in: sut))
-        #expect(!isEnabled(Self.defaultValue, in: sut))
-    }
-
-    @Test("On a focused nullable text cell Empty, NULL and Set Cells to Value are enabled and the UUIDs are not")
-    func focusedTextCell() {
-        let sut = makeSUT()
-        focus(sut, row: 0, dataColumn: Self.note)
-
-        #expect(isEnabled(Self.empty, in: sut))
-        #expect(isEnabled(Self.null, in: sut))
-        #expect(isEnabled(Self.cellsToValue, in: sut))
-        #expect(!isEnabled(Self.uuidV4, in: sut))
-    }
-
-    @Test("With no focused cell and no selection every item is dimmed")
-    func nothingFocused() {
-        let sut = makeSUT()
-
-        for selector in [Self.empty, Self.null, Self.defaultValue, Self.uuidV4, Self.uuidV7, Self.cellsToValue] {
-            #expect(!isEnabled(selector, in: sut))
-        }
-    }
-
-    @Test("A read-only grid dims every item")
-    func readOnlyGrid() {
-        let sut = makeSUT(isEditable: false)
-        focus(sut, row: 0, dataColumn: Self.note)
-
-        #expect(!isEnabled(Self.null, in: sut))
-        #expect(!isEnabled(Self.empty, in: sut))
-        #expect(!isEnabled(Self.cellsToValue, in: sut))
-    }
-
-    @Test("A selection across both columns enables what either one takes, and writes each only where it fits")
-    func selectionAcrossColumns() {
-        let sut = makeSUT()
-        sut.coordinator.selectionController.update(.single(
-            GridRect(rows: 0...1, columns: 0...1),
-            anchor: GridCoord(row: 0, displayColumn: 0),
-            active: GridCoord(row: 1, displayColumn: 1)
-        ))
-
-        #expect(isEnabled(Self.uuidV4, in: sut))
-        #expect(isEnabled(Self.null, in: sut))
-
-        sut.tableView.generateUUIDv4(nil)
-
-        let ids = (0..<2).compactMap { sut.store.tableRows.rows[$0].values[Self.id].asText }
-        #expect(ids.count == 2)
-        #expect(Set(ids).count == 2)
-        #expect(ids.allSatisfy { UUID(uuidString: $0) != nil })
-        #expect(sut.store.tableRows.rows[0].values[Self.note] == .text("a"))
-        #expect(sut.store.tableRows.rows[1].values[Self.note] == .text("b"))
-    }
-
-    @Test("Set Value NULL from the menu bar writes the focused cell")
-    func menuBarNullWritesFocusedCell() {
-        let sut = makeSUT()
-        focus(sut, row: 1, dataColumn: Self.note)
-
-        sut.tableView.setValueNull(nil)
-
-        #expect(sut.store.tableRows.rows[1].values[Self.note] == .null)
-        #expect(sut.store.tableRows.rows[0].values[Self.note] == .text("a"))
-    }
-}
diff --git a/apple/TableProTests/Views/Results/ResultComparisonGridModelTests.swift b/apple/TableProTests/Views/Results/ResultComparisonGridModelTests.swift
index 32b43e5a82..e127d28bc0 100644
--- a/apple/TableProTests/Views/Results/ResultComparisonGridModelTests.swift
+++ b/apple/TableProTests/Views/Results/ResultComparisonGridModelTests.swift
@@ -3,7 +3,7 @@
 //  TableProTests
 //
 
-import Foundation
+import AppKit
 @testable import TablePro
 import TableProPluginKit
 import Testing
@@ -84,6 +84,24 @@ struct ResultComparisonGridModelTests {
         #expect(CompareRowGridModel.displayType(source: nil, target: date) == date)
     }
 
+    @Test("The row menu offers Copy as and a column header offers Display As")
+    func offersCopyAsAndDisplayAs() throws {
+        let comparison = try Self.comparison()
+        let grid = ResultComparisonGridModel()
+        grid.ensureLoaded(
+            key: ResultComparisonGridModel.LoadKey(comparisonId: comparison.id, filter: .all),
+            comparison: comparison, left: Self.left, right: Self.right, pairing: Self.pairing
+        )
+        let controller = DataGridViewController(model: grid.model)
+        let name = try #require(grid.model.columns.columns.first { $0.name == "name" })
+
+        let rowMenu = controller.rowMenu(forRow: 0, displayColumn: 3, in: .main)
+        let headerMenu = controller.headerMenu(for: name)
+
+        #expect(rowMenu?.items.contains { $0.title == String(localized: "Copy as") } == true)
+        #expect(headerMenu?.items.contains { $0.title == String(localized: "Display As") } == true)
+    }
+
     @Test("VoiceOver names the side rather than the sync direction")
     func accessibilityWords() {
         let onlyLeft = RowVisualState(isDeleted: false, isInserted: true, modifiedColumns: [], vocabulary: .resultComparison)
diff --git a/apple/TableProTests/Views/Results/ResultsJsonViewTests.swift b/apple/TableProTests/Views/Results/ResultsJsonViewTests.swift
index 72bded5862..d64d2975d0 100644
--- a/apple/TableProTests/Views/Results/ResultsJsonViewTests.swift
+++ b/apple/TableProTests/Views/Results/ResultsJsonViewTests.swift
@@ -2,10 +2,6 @@
 //  ResultsJsonViewTests.swift
 //  TableProTests
 //
-//  The JSON results view renders the whole result set when nothing is selected, and
-//  narrows to the selected rows otherwise. Selection indices are display positions, so
-//  they are resolved through DisplayRowMapping rather than used to subscript the rows.
-//
 
 import Foundation
 import TableProPluginKit
diff --git a/apple/TableProTests/Views/Results/RowCopyFormatTests.swift b/apple/TableProTests/Views/Results/RowCopyFormatTests.swift
index 8c1c5b0cb9..72ca9d62d2 100644
--- a/apple/TableProTests/Views/Results/RowCopyFormatTests.swift
+++ b/apple/TableProTests/Views/Results/RowCopyFormatTests.swift
@@ -5,124 +5,18 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class RowCopyLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class RowCopyDelegateSpy: DataGridViewDelegate {
-    var copiedRows: Set<Int>?
-
-    func dataGridCopyRows(_ indices: Set<Int>) {
-        copiedRows = indices
-    }
-}
-
-@MainActor
-private final class RowCopySelectionBox {
-    var value: Set<Int> = []
-
-    func binding() -> Binding<Set<Int>> {
-        Binding(get: { self.value }, set: { self.value = $0 })
-    }
-}
-
-@MainActor
-private struct RowCopyGrid {
-    let tableView: KeyHandlingTableView
-    let coordinator: TableViewCoordinator
-    let selection: RowCopySelectionBox
-
-    init(
-        appliesRowCopyFormat: Bool = true,
-        delegate: (any DataGridViewDelegate)? = nil,
-        hasAuthoritativeSchema: Bool = false
-    ) {
-        let tableRows = TableRows.from(
-            queryRows: [[.text("1"), .text("Alice")], [.text("2"), .text("Bob")], [.text("3"), .text("Carol")]],
-            columns: ["id", "name"],
-            columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")],
-            hasAuthoritativeSchema: hasAuthoritativeSchema
-        )
-        let box = RowCopySelectionBox()
-        selection = box
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: box.binding(),
-            delegate: delegate,
-            layoutPersister: RowCopyLayoutPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.appliesRowCopyFormat = appliesRowCopyFormat
-
-        tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.allowsMultipleSelection = true
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-
-        coordinator.tableView = tableView
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: tableRows.columnTypes,
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.selectionController.tableView = tableView
-        coordinator.selectionController.coordinator = coordinator
-        coordinator.invalidateColumnIndexCache()
-        coordinator.updateCache()
-        tableView.reloadData()
-    }
-
-    // What a row-number click leaves behind: the rows, and a cursor seeded for the keyboard.
-    func selectRowsByNumber(_ rows: IndexSet) {
-        tableView.focusedRow = -1
-        tableView.focusedColumn = -1
-        tableView.isCursorSeededByRowSelection = true
-        tableView.selectRowIndexes(rows, byExtendingSelection: false)
-        coordinator.tableViewSelectionDidChange(
-            Notification(name: NSTableView.selectionDidChangeNotification, object: tableView)
-        )
-    }
-
-    func focusCell(row: Int, dataColumn: Int) {
-        tableView.isCursorSeededByRowSelection = false
-        tableView.focusedRow = row
-        tableView.focusedColumn = coordinator.tableColumnIndex(for: dataColumn) ?? -1
-    }
-
-    func selectCells(rows: ClosedRange<Int>, displayColumns: ClosedRange<Int>) {
-        let anchor = GridCoord(row: rows.lowerBound, displayColumn: displayColumns.lowerBound)
-        coordinator.selectionController.update(
-            .single(GridRect(rows: rows, columns: displayColumns), anchor: anchor, active: anchor)
-        )
-    }
-
-    func isEnabled(_ action: Selector) -> Bool {
-        tableView.validateUserInterfaceItem(NSMenuItem(title: "", action: action, keyEquivalent: ""))
-    }
-}
-
 extension GlobalStateSuites {
     @Suite(.recordingClipboard)
     @MainActor
     struct RowCopyFormatTests {
+        private func makeGrid(appliesRowCopyFormat: Bool = true) -> CommandGrid {
+            CommandGrid(CommandRows.people, configuration: CommandGrid.editable(appliesRowCopyFormat: appliesRowCopyFormat))
+        }
+
         // MARK: - Copy
 
         @Test(
@@ -131,41 +25,39 @@ extension GlobalStateSuites {
         )
         func copyUsesTheChosenFormat() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(0...2))
+            let grid = makeGrid()
+            grid.selectRows(0...2)
 
-            grid.tableView.copy(nil)
+            grid.controller.copy(nil)
 
             #expect(clipboard.text == "id,name\n1,Alice\n2,Bob\n3,Carol\n")
             #expect(clipboard.gridRows?.rows.count == 3)
         }
 
         @Test(
-            "One row picked by its number copies as a row, not as the cell the keyboard cursor was seeded on",
+            "One row picked by its number copies as a row, not as the cell the cursor stays on",
             .appSettings { $0.dataGrid.rowCopyFormat = .csvWithHeaders }
         )
         func rowPickedByNumberCopiesTheRow() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(integer: 1))
-            #expect(grid.tableView.focusedRow == 1)
+            let grid = makeGrid()
+            grid.selectRows(1...1, activeColumn: 1)
 
-            grid.tableView.copy(nil)
+            grid.controller.copy(nil)
 
             #expect(clipboard.text == "id,name\n2,Bob\n")
         }
 
         @Test(
-            "A cell the user put the cursor on still copies its value",
+            "A cell the user clicked still copies its value",
             .appSettings { $0.dataGrid.rowCopyFormat = .csvWithHeaders }
         )
-        func focusedCellCopiesItsValue() throws {
+        func clickedCellCopiesItsValue() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(integer: 1))
-            grid.focusCell(row: 1, dataColumn: 1)
+            let grid = makeGrid()
+            grid.selectCell(1, 1)
 
-            grid.tableView.copy(nil)
+            grid.controller.copy(nil)
 
             #expect(clipboard.text == "Bob")
         }
@@ -176,86 +68,100 @@ extension GlobalStateSuites {
         )
         func cellRangeCopiesAsCells() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectCells(rows: 0...1, displayColumns: 0...1)
+            let grid = makeGrid()
+            grid.select(rows: 0...1, columns: 0...1)
 
-            grid.tableView.copy(nil)
+            grid.controller.copy(nil)
 
             #expect(clipboard.text == "1\tAlice\n2\tBob")
             #expect(clipboard.gridCells != nil)
         }
 
         @Test(
-            "The TSV default keeps the grid's own row copy",
+            "The TSV default lets an owner that writes its own pasteboard type copy the rows",
             .appSettings { $0.dataGrid.rowCopyFormat = .rows }
         )
-        func defaultFormatKeepsTheGridsCopy() {
-            let spy = RowCopyDelegateSpy()
-            let grid = RowCopyGrid(delegate: spy)
-            grid.selectRowsByNumber(IndexSet(0...1))
+        func defaultFormatAsksTheOwnerFirst() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = makeGrid()
+            grid.owner.copiesRowsItself = true
+            grid.selectRows(0...1)
 
-            grid.tableView.copy(nil)
+            grid.controller.copy(nil)
 
-            #expect(spy.copiedRows == Set([0, 1]))
+            #expect(grid.owner.rowCopies == [[.existing(0), .existing(1)]])
+            #expect(clipboard.text == nil)
         }
 
         @Test(
-            "A grid of definitions keeps its own row copy whatever the format",
+            "A grid of definitions keeps its owner's row copy whatever the format",
             .appSettings { $0.dataGrid.rowCopyFormat = .csvWithHeaders }
         )
         func definitionsGridKeepsItsCopy() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let spy = RowCopyDelegateSpy()
-            let grid = RowCopyGrid(appliesRowCopyFormat: false, delegate: spy)
-            grid.selectRowsByNumber(IndexSet(0...1))
+            let grid = makeGrid(appliesRowCopyFormat: false)
+            grid.owner.copiesRowsItself = true
+            grid.selectRows(0...1)
 
-            grid.tableView.copy(nil)
+            grid.controller.copy(nil)
 
-            #expect(spy.copiedRows == Set([0, 1]))
+            #expect(grid.owner.rowCopies == [[.existing(0), .existing(1)]])
             #expect(clipboard.text == nil)
         }
 
         @Test(
-            "The row menu's Copy on a row number follows the format",
+            "The row menu's Copy on a row number follows the format and copies that row alone",
             .appSettings { $0.dataGrid.rowCopyFormat = .markdown }
         )
         func rowMenuCopyFollowsTheFormat() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(0...1))
-            let rowView = DataGridRowView()
-            rowView.coordinator = grid.coordinator
-            rowView.rowIndex = 0
-            let item = NSMenuItem(title: "Copy", action: nil, keyEquivalent: "")
-            item.representedObject = DataGridRowView.CopyContextTarget.row
+            let grid = makeGrid()
+            grid.selectCell(0, 0)
 
-            _ = rowView.perform(NSSelectorFromString("copyFromContextMenu:"), with: item)
+            grid.controller.copy(grid.contextItem(row: 1, displayColumn: nil))
 
             #expect(clipboard.text?.hasPrefix("| id | name |") == true)
             #expect(clipboard.text?.contains("Bob") == true)
-            #expect(clipboard.text?.contains("Carol") != true)
+            #expect(clipboard.text?.contains("Alice") != true)
         }
 
-        @Test("Rows a held result shows copy as TSV")
+        @Test("Rows a grid without its own row copy shows copy as TSV, ready to paste back as rows")
         func heldRowsCopyAsTSV() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let delegate = HeldRowsGridDelegate()
-            let grid = RowCopyGrid(delegate: delegate)
-            delegate.dataGridAttach(tableViewCoordinator: grid.coordinator)
+            let grid = CommandGrid(CommandRows.people, configuration: CommandGrid.readOnly(appliesRowCopyFormat: false))
+            grid.model.setSelection(GridSelection(
+                rectangles: [GridRect(rows: 0...0, columns: 0...1), GridRect(rows: 2...2, columns: 0...1)],
+                activeCell: GridCoord(row: 2, displayColumn: 0),
+                anchor: GridCoord(row: 2, displayColumn: 0)
+            ))
 
-            delegate.dataGridCopyRows([0, 2])
+            grid.controller.copySelectedRows(nil)
 
             #expect(clipboard.text == "1\tAlice\n3\tCarol")
             #expect(clipboard.html == nil)
             #expect(clipboard.gridRows?.rows.count == 2)
         }
 
+        @Test("Copy with Headers writes a header line, an HTML table and the rows' payload")
+        func copyWithHeaders() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = makeGrid()
+            grid.select(rows: 0...1, columns: 1...1)
+
+            grid.controller.copyRowsWithHeaders(nil)
+
+            #expect(clipboard.text == "id\tname\n1\tAlice\n2\tBob")
+            #expect(clipboard.html?.contains("Alice") == true)
+            #expect(clipboard.gridRows?.columns == ["id", "name"])
+        }
+
         @Test("Rows copied as CSV paste into a data file by column name, not as one cell per line")
         func dataFilePasteReadsTheCopiedRows() async throws {
             let clipboard = try #require(RecordingClipboard.current)
             let directory = FileManager.default.temporaryDirectory
                 .appendingPathComponent("RowCopyFormatTests-\(UUID().uuidString)")
             try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+            defer { try? FileManager.default.removeItem(at: directory) }
             let url = directory.appendingPathComponent("people.csv")
             try Data("name,city\nAlice,Lima\n".utf8).write(to: url)
             let undoManager = UndoManager()
@@ -267,12 +173,15 @@ extension GlobalStateSuites {
                 "city,name\n\"Oslo, NO\",Bob\n",
                 gridRows: GridRowsClipboardPayload(columns: ["city", "name"], rows: [[.text("Oslo, NO"), .text("Bob")]])
             )
+            let adapter = DataFileGridAdapter(model: DataGridModel())
+            adapter.controller = controller
 
-            DataFileGridDelegate(controller: controller).dataGridPasteRows()
+            adapter.gridPasteRows()
             await controller.waitForPendingWork()
 
             #expect(controller.tableRows.rows.count == 2)
             #expect(controller.tableRows.rows.last.map { Array($0.values) } == [.text("Bob"), .text("Oslo, NO")])
+            withExtendedLifetime(undoManager) {}
         }
 
         @Test("Rows from another source, or with a repeated column name, paste into a file in order")
@@ -292,22 +201,15 @@ extension GlobalStateSuites {
             let clipboard = try #require(RecordingClipboard.current)
             let cap = RowOperationsManager.maxClipboardRows
             let rowCount = cap + 2
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: true,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: RowCopyLayoutPersister()
-            )
-            let tableRows = TableRows.from(
+            let rows = TableRows.from(
                 queryRows: (0..<rowCount).map { [.text("\($0)"), .text("v\($0)")] },
                 columns: ["id", "value"],
                 columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")]
             )
-            coordinator.tableRowsProvider = { tableRows }
-            coordinator.updateCache()
+            let grid = CommandGrid(rows)
+            grid.selectRows(0...(rowCount - 1))
 
-            coordinator.copyRowsAsCsv(at: Set(0..<rowCount), includeHeaders: false)
+            grid.controller.copyRowsAsCsv(nil)
 
             let lines = clipboard.text?.split(separator: "\n") ?? []
             #expect(lines.count == cap)
@@ -317,34 +219,21 @@ extension GlobalStateSuites {
 
         // MARK: - Copy Cell Value
 
-        private func formattedCellCoordinator(
-            value: PluginCellValue,
-            columnType: ColumnType,
-            format: ValueDisplayFormat
-        ) -> TableViewCoordinator {
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: false,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: RowCopyLayoutPersister()
-            )
-            let tableRows = TableRows.from(queryRows: [[value]], columns: ["payload"], columnTypes: [columnType])
-            coordinator.tableRowsProvider = { tableRows }
-            coordinator.updateCache()
-            coordinator.updateDisplayFormats([format])
-            return coordinator
+        private func formattedCell(value: PluginCellValue, columnType: ColumnType, format: ValueDisplayFormat) -> CommandGrid {
+            let rows = TableRows.from(queryRows: [[value]], columns: ["payload"], columnTypes: [columnType])
+            let grid = CommandGrid(rows, configuration: CommandGrid.readOnly())
+            grid.model.setDisplayFormat(format, for: grid.model.columns.columns[0])
+            grid.selectCell(0, 0)
+            return grid
         }
 
         @Test("A single binary cell under a decoder format copies the decoded text")
         func decodedCellCopiesDecodedText() throws {
             let clipboard = try #require(RecordingClipboard.current)
             let bytes = Data([0x82, 0xA1, 0x61, 0x01, 0xA1, 0x62, 0xC3])
-            let coordinator = formattedCellCoordinator(
-                value: .bytes(bytes), columnType: .blob(rawType: "BLOB"), format: .messagePack
-            )
+            let grid = formattedCell(value: .bytes(bytes), columnType: .blob(rawType: "BLOB"), format: .messagePack)
 
-            coordinator.copyCellValue(at: 0, columnIndex: 0)
+            grid.controller.copyCellValue(nil)
 
             #expect(clipboard.text == #"{"a":1,"b":true}"#)
         }
@@ -352,59 +241,45 @@ extension GlobalStateSuites {
         @Test("A format saved before the column changed type copies the stored value, as the cell draws it")
         func inapplicableFormatCopiesStoredValue() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let coordinator = formattedCellCoordinator(
-                value: .text("1"), columnType: .text(rawType: "TEXT"), format: .messagePack
-            )
+            let grid = formattedCell(value: .text("1"), columnType: .text(rawType: "TEXT"), format: .messagePack)
 
-            coordinator.copyCellValue(at: 0, columnIndex: 0)
+            grid.controller.copyCellValue(nil)
 
             #expect(clipboard.text == "1")
         }
 
-        @Test("Copy Cell Value copies the focused cell with several rows selected")
+        @Test("Copy Cell Value copies the cursor's cell with several rows selected")
         func copyCellValueWithSeveralRows() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(0...2))
-            grid.focusCell(row: 1, dataColumn: 1)
+            let grid = makeGrid()
+            grid.selectRows(0...1, activeColumn: 1)
 
-            grid.tableView.copyCellValue(nil)
+            grid.controller.copyCellValue(nil)
 
             #expect(clipboard.text == "Bob")
         }
 
-        @Test("Copy Cell Value copies the focused cell inside a cell range")
+        @Test("Copy Cell Value copies the cursor's cell inside a cell range")
         func copyCellValueInsideARange() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectCells(rows: 0...2, displayColumns: 0...1)
-            grid.focusCell(row: 2, dataColumn: 0)
+            let grid = makeGrid()
+            grid.select(rows: 0...2, columns: 0...1, active: GridCoord(row: 2, displayColumn: 0))
 
-            grid.tableView.copyCellValue(nil)
+            grid.controller.copyCellValue(nil)
 
             #expect(clipboard.text == "3")
         }
 
-        @Test("Copy Cell Value is dimmed with no cell cursor")
-        func copyCellValueNeedsACursor() {
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(0...1))
-            grid.tableView.focusedRow = -1
-            grid.tableView.focusedColumn = -1
-
-            #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyCellValue(_:))))
-        }
-
         // MARK: - Copy Special formats
 
         @Test("Copy as CSV from the menu bar copies the selected rows and keeps them pasteable")
         func copyAsCsvCommand() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(0...1))
+            let grid = makeGrid()
+            grid.selectRows(0...1)
 
             #expect(grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsCsv(_:))))
-            grid.tableView.copyRowsAsCsv(nil)
+            grid.controller.copyRowsAsCsv(nil)
 
             #expect(clipboard.text == "1,Alice\n2,Bob\n")
             #expect(clipboard.gridRows?.columns == ["id", "name"])
@@ -414,67 +289,184 @@ extension GlobalStateSuites {
         @Test("Copy as Markdown from the menu bar keeps the rows pasteable")
         func copyAsMarkdownCommand() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(integer: 2))
+            let grid = makeGrid()
+            grid.selectRows(2...2)
 
-            grid.tableView.copyRowsAsMarkdown(nil)
+            grid.controller.copyRowsAsMarkdown(nil)
 
             #expect(clipboard.text?.contains("| 3 | Carol |") == true)
             #expect(clipboard.gridRows?.rows.count == 1)
         }
 
-        @Test("The row formats are dimmed on a grid of definitions")
-        func formatsDimOnADefinitionsGrid() {
-            let grid = RowCopyGrid(appliesRowCopyFormat: false)
-            grid.selectRowsByNumber(IndexSet(0...1))
+        @Test("JSON, CSV and Markdown include every row a range touches", arguments: [
+            RowCopyFormat.json, .csv, .markdown,
+        ])
+        func formatsTakeEveryRowOfTheRange(format: RowCopyFormat) throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = makeGrid()
+            grid.select(rows: 0...1, columns: 0...1, active: GridCoord(row: 1, displayColumn: 0))
+
+            grid.commands.copyRows(.current(grid.model.selection), as: format)
+
+            #expect(clipboard.text?.contains("Alice") == true)
+            #expect(clipboard.text?.contains("Bob") == true)
+            #expect(clipboard.text?.contains("Carol") != true)
+        }
+
+        @Test("JSON and CSV take only the columns a picked column or a cell selection covers")
+        func formatsTakeTheSelectedColumns() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = makeGrid()
+            grid.model.setSelection(GridSelection.column(0, totalRows: 3))
+
+            grid.controller.copyRowsAsJson(nil)
+            #expect(clipboard.text?.contains("\"id\"") == true)
+            #expect(clipboard.text?.contains("Alice") != true)
 
-            #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsCsv(_:))))
-            #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsMarkdown(_:))))
-            #expect(!grid.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
+            grid.controller.copyRowsAsCsv(nil)
+            #expect(clipboard.text?.contains("Bob") != true)
+            #expect(clipboard.gridRows?.columns == ["id"])
+        }
+
+        @Test("Copy as JSON from a row's menu with no selection copies that row")
+        func jsonFallsBackToTheClickedRow() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = makeGrid()
+
+            grid.controller.copyRowsAsJson(grid.contextItem(row: 1, displayColumn: 1))
+
+            #expect(clipboard.text?.contains("Bob") == true)
+            #expect(clipboard.text?.contains("Alice") != true)
+        }
+
+        @Test("The row formats copy nothing on a grid of definitions")
+        func formatsAreInertOnADefinitionsGrid() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = makeGrid(appliesRowCopyFormat: false)
+            grid.selectRows(0...1)
+
+            grid.controller.copyRowsAsCsv(nil)
+            grid.controller.copyRowsAsMarkdown(nil)
+
+            #expect(clipboard.text == nil)
         }
 
         @Test("Copy as IN Clause takes the one column a cell selection covers")
         func inClauseTakesTheSelectedColumn() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectCells(rows: 0...2, displayColumns: 1...1)
-            grid.focusCell(row: 0, dataColumn: 0)
+            let grid = makeGrid()
+            grid.select(rows: 0...2, columns: 1...1)
 
-            grid.tableView.copyRowsAsInClause(nil)
+            grid.controller.copyRowsAsInClause(nil)
 
             #expect(clipboard.text == "('Alice', 'Bob', 'Carol')")
         }
 
-        @Test("Copy as IN Clause takes the focused cell's column over a row selection")
-        func inClauseFallsBackToTheFocusedColumn() throws {
+        @Test("Copy as IN Clause takes the cursor's column over a row selection")
+        func inClauseFallsBackToTheCursorColumn() throws {
             let clipboard = try #require(RecordingClipboard.current)
-            let grid = RowCopyGrid()
-            grid.selectRowsByNumber(IndexSet(0...1))
-            grid.focusCell(row: 0, dataColumn: 1)
+            let grid = makeGrid()
+            grid.selectRows(0...1, activeColumn: 1)
 
-            grid.tableView.copyRowsAsInClause(nil)
+            grid.controller.copyRowsAsInClause(nil)
 
             #expect(clipboard.text == "('Alice', 'Bob')")
         }
 
-        @Test("INSERT and UPDATE are offered only where the row menu offers them")
-        func statementsFollowTheRowMenu() {
-            let noTable = RowCopyGrid(hasAuthoritativeSchema: true)
-            noTable.selectRowsByNumber(IndexSet(0...1))
-            #expect(!noTable.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
-
-            let table = RowCopyGrid(hasAuthoritativeSchema: true)
-            table.coordinator.tableName = "users"
-            table.coordinator.databaseType = .mysql
-            table.selectRowsByNumber(IndexSet(0...1))
-            #expect(table.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
-            #expect(table.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsUpdateStatements(_:))))
-
-            let schemaPending = RowCopyGrid(hasAuthoritativeSchema: false)
-            schemaPending.coordinator.tableName = "users"
-            schemaPending.coordinator.databaseType = .mysql
-            schemaPending.selectRowsByNumber(IndexSet(0...1))
-            #expect(!schemaPending.isEnabled(#selector(GridCopyCommandResponding.copyRowsAsInsertStatements(_:))))
+        // MySQL reads a backslash as an escape, so quote doubling alone would let a value close the list.
+        @Test("Copy as IN Clause without an owner's dialect escapes for the grid's engine")
+        func inClauseEscapesForTheEngine() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            var configuration = CommandGrid.editable()
+            configuration.traits = DataGridEngineTraits(databaseType: .mysql)
+            let grid = CommandGrid(
+                TableRows.from(
+                    queryRows: [[.text(#"x\') OR 1=1 -- "#)]],
+                    columns: ["ref"],
+                    columnTypes: [.text(rawType: "TEXT")]
+                ),
+                configuration: configuration
+            )
+            grid.select(rows: 0...0, columns: 0...0)
+
+            grid.controller.copyRowsAsInClause(nil)
+
+            #expect(clipboard.text == #"('x\\'') OR 1=1 -- ')"#)
+        }
+
+        @Test("Copy as IN Clause from a cell's menu inside a range takes the clicked column, through the owner's dialect")
+        func inClauseTakesTheClickedColumn() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let grid = makeGrid()
+            grid.owner.exporter = RecordingSQLExporter()
+            grid.select(rows: 0...1, columns: 0...1)
+
+            grid.controller.copyRowsAsInClause(grid.contextItem(row: 0, displayColumn: 1))
+
+            #expect(clipboard.text == "IN Alice,Bob")
+        }
+
+        // MARK: - Statements
+
+        private func statementGrid() -> (CommandGrid, RecordingSQLExporter) {
+            var configuration = CommandGrid.editable()
+            configuration.commands.insert(.copyAsSQL)
+            let grid = CommandGrid(
+                TableRows.from(
+                    queryRows: [
+                        [.text("1"), .text("Alice"), .text("NYC"), .text("x")],
+                        [.text("2"), .text("Bob"), .text("LA"), .text("y")],
+                    ],
+                    columns: ["c0", "c1", "c2", "c3"],
+                    columnTypes: Array(repeating: .text(rawType: "TEXT"), count: 4)
+                ),
+                configuration: configuration
+            )
+            let exporter = RecordingSQLExporter()
+            grid.owner.exporter = exporter
+            return (grid, exporter)
+        }
+
+        @Test("INSERT and UPDATE take every row of a range selection")
+        func statementsTakeEveryRow() throws {
+            let clipboard = try #require(RecordingClipboard.current)
+            let (grid, exporter) = statementGrid()
+            grid.select(rows: 0...1, columns: 0...3)
+
+            grid.controller.copyRowsAsInsertStatements(nil)
+            #expect(clipboard.text == "INSERT 2")
+            grid.controller.copyRowsAsUpdateStatements(nil)
+
+            #expect(exporter.requests.map { $0.rowIDs } == [[.existing(0), .existing(1)], [.existing(0), .existing(1)]])
+            #expect(exporter.requests.map { $0.update } == [false, true])
+        }
+
+        @Test("INSERT and UPDATE take only the selected columns, a discontiguous selection as its column union")
+        func statementsTakeTheSelectedColumns() {
+            let (grid, exporter) = statementGrid()
+            grid.model.setSelection(GridSelection(
+                rectangles: [GridRect(cell: GridCoord(row: 0, displayColumn: 2)), GridRect(cell: GridCoord(row: 1, displayColumn: 0))],
+                activeCell: GridCoord(row: 1, displayColumn: 0),
+                anchor: GridCoord(row: 0, displayColumn: 2)
+            ))
+
+            grid.controller.copyRowsAsInsertStatements(nil)
+            grid.controller.copyRowsAsUpdateStatements(nil)
+
+            #expect(exporter.requests.map { $0.columns } == [["c0", "c2"], ["c0", "c2"]])
+        }
+
+        @Test("Whole rows, and one clicked cell, hand every presented column")
+        func statementsOverRowsTakeEveryColumn() {
+            let (grid, exporter) = statementGrid()
+            grid.selectRows(0...0)
+            grid.controller.copyRowsAsUpdateStatements(nil)
+
+            grid.selectCell(1, 2)
+            grid.controller.copyRowsAsInsertStatements(nil)
+
+            #expect(exporter.requests.map { $0.columns } == [["c0", "c1", "c2", "c3"], ["c0", "c1", "c2", "c3"]])
+            #expect(exporter.requests.last?.rowIDs == [.existing(1)])
         }
     }
 }
diff --git a/apple/TableProTests/Views/Results/RowNumberColumnSizingTests.swift b/apple/TableProTests/Views/Results/RowNumberColumnSizingTests.swift
deleted file mode 100644
index 1ec1a932d0..0000000000
--- a/apple/TableProTests/Views/Results/RowNumberColumnSizingTests.swift
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-//  RowNumberColumnSizingTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-struct RowNumberColumnSizingTests {
-    @Test("Single-digit max number sizes to the configured floor")
-    func singleDigitHonoursFloor() {
-        let column = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        DataGridView.sizeRowNumberColumn(column, forMaxRowNumber: 1)
-        #expect(column.width == DataGridMetrics.rowNumberColumnMinWidth)
-        #expect(column.minWidth == column.width)
-        #expect(column.maxWidth == column.width)
-    }
-
-    @Test("Zero and negative inputs are clamped to the floor")
-    func zeroAndNegativeClampToFloor() {
-        let zero = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        let negative = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        DataGridView.sizeRowNumberColumn(zero, forMaxRowNumber: 0)
-        DataGridView.sizeRowNumberColumn(negative, forMaxRowNumber: -42)
-        #expect(zero.width == DataGridMetrics.rowNumberColumnMinWidth)
-        #expect(negative.width == DataGridMetrics.rowNumberColumnMinWidth)
-    }
-
-    @Test("Five-digit numbers grow past the floor")
-    func fiveDigitGrowsPastFloor() {
-        let column = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        DataGridView.sizeRowNumberColumn(column, forMaxRowNumber: 14_001)
-        #expect(column.width > DataGridMetrics.rowNumberColumnMinWidth)
-    }
-
-    @Test("Width grows monotonically with digit count")
-    func widthGrowsWithDigits() {
-        let twoDigit = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        let fourDigit = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        let sixDigit = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        DataGridView.sizeRowNumberColumn(twoDigit, forMaxRowNumber: 99)
-        DataGridView.sizeRowNumberColumn(fourDigit, forMaxRowNumber: 9_999)
-        DataGridView.sizeRowNumberColumn(sixDigit, forMaxRowNumber: 999_999)
-        #expect(fourDigit.width >= twoDigit.width)
-        #expect(sixDigit.width >= fourDigit.width)
-    }
-
-    @Test("Min, max and width stay equal so the column is pinned")
-    func widthIsPinned() {
-        let column = NSTableColumn(identifier: ColumnIdentitySchema.rowNumberIdentifier)
-        DataGridView.sizeRowNumberColumn(column, forMaxRowNumber: 1_234_567)
-        #expect(column.minWidth == column.width)
-        #expect(column.maxWidth == column.width)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/SelectAllCellSelectionTests.swift b/apple/TableProTests/Views/Results/SelectAllCellSelectionTests.swift
deleted file mode 100644
index d65599cd9e..0000000000
--- a/apple/TableProTests/Views/Results/SelectAllCellSelectionTests.swift
+++ /dev/null
@@ -1,229 +0,0 @@
-//
-//  SelectAllCellSelectionTests.swift
-//  TableProTests
-//
-//  Cmd+A selects the rows, and nothing else: no cell rectangle, no cell cursor, and no heading
-//  marked as picked. It used to build a cell rectangle over the whole grid, which is the same shape
-//  a heading click builds, so the entire heading row painted as selected and a cell cursor sat on
-//  the first cell of a selection that owns every row.
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class StubSelectAllPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class RowSelectionBox {
-    var value: Set<Int> = []
-
-    func binding() -> Binding<Set<Int>> {
-        Binding(get: { self.value }, set: { self.value = $0 })
-    }
-}
-
-@MainActor
-private struct SelectAllGrid {
-    let tableView: KeyHandlingTableView
-    let coordinator: TableViewCoordinator
-    let header: SortableHeaderView
-    let published: RowSelectionBox
-    let rowCount: Int
-    let columnCount: Int
-
-    /// What the headings actually show, which is the channel the reported defect appeared on.
-    var pickedHeadings: [Int] {
-        tableView.tableColumns.enumerated().compactMap { index, column in
-            (column.headerCell as? SortableHeaderCell)?.isColumnSelected == true ? index : nil
-        }
-    }
-
-    init(rowCount: Int = 8, dataColumns: Int = 4) {
-        self.rowCount = rowCount
-        self.columnCount = dataColumns
-        let columns = (0..<dataColumns).map { "col\($0)" }
-        let rows = (0..<rowCount).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } }
-        let tableRows = TableRows.from(
-            queryRows: rows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: dataColumns)
-        )
-
-        /// A real binding, not `.constant([])`, which swallows every write and would leave the
-        /// suite unable to see whether the row set still reaches the tab.
-        let box = RowSelectionBox()
-        published = box
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: box.binding(),
-            delegate: nil,
-            layoutPersister: StubSelectAllPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-
-        tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.delegate = coordinator
-        tableView.dataSource = coordinator
-        tableView.rowHeight = 22
-        tableView.allowsMultipleSelection = true
-
-        let rowNumberColumn = DataGridView.makeRowNumberColumn()
-        tableView.addTableColumn(rowNumberColumn)
-
-        header = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: 600, height: 28))
-        header.coordinator = coordinator
-        tableView.headerView = header
-
-        coordinator.tableView = tableView
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        /// The pool is what attaches the data columns and what `presentsColumn` answers from, so a
-        /// harness that adds columns by hand presents none of them and `selectAll` falls through to
-        /// AppKit's own path, which selects every row and builds no cell rectangle at all.
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: dataColumns),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        /// What `installSelectionOverlay` wires in the app. Without it the controller has no table
-        /// view, so `reloadColumns` reaches no heading and every assertion about the heading row
-        /// passes for the wrong reason.
-        coordinator.selectionController.tableView = tableView
-        coordinator.selectionController.coordinator = coordinator
-
-        coordinator.invalidateColumnIndexCache()
-        coordinator.updateCache()
-        tableView.reloadData()
-    }
-}
-
-@MainActor
-struct SelectAllCellSelectionTests {
-    /// `selectAll` falls through to AppKit's own when the grid presents no data columns, and that
-    /// path selects every row too, so without this the suite would pass over a harness that never
-    /// exercised the cell selection at all.
-    @Test("the harness presents its data columns, so selectAll takes the grid's own path")
-    func harnessPresentsDataColumns() {
-        let grid = SelectAllGrid()
-
-        #expect(grid.coordinator.presentedColumnCount == grid.columnCount)
-    }
-
-    @Test("Command A leaves no cell selection behind")
-    func selectAllLeavesNoCellSelection() {
-        let grid = SelectAllGrid()
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.coordinator.selectionController.isEmpty)
-    }
-
-    /// The reported defect. A whole-grid rectangle is geometrically what a heading click builds, so
-    /// every heading read as picked and the whole row painted in the selection colour.
-    @Test("Command A marks no heading as picked")
-    func selectAllPicksNoHeading() {
-        let grid = SelectAllGrid()
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.coordinator.selectionController.selectedFullColumns().isEmpty)
-        #expect(grid.pickedHeadings.isEmpty)
-    }
-
-    /// A heading picked first has to stand down, or Cmd+A leaves the old tint over a row selection.
-    @Test("Command A clears a heading picked before it")
-    func selectAllClearsAPickedHeading() {
-        let grid = SelectAllGrid()
-        grid.coordinator.selectionController.selectEntireColumn(1, totalRows: grid.rowCount)
-        #expect(!grid.pickedHeadings.isEmpty)
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.pickedHeadings.isEmpty)
-    }
-
-    /// CLAUDE.md's rule for the grid: a whole-row selection owns it, and no cell cursor survives it.
-    @Test("Command A leaves no cell cursor")
-    func selectAllLeavesNoCellCursor() {
-        let grid = SelectAllGrid()
-        grid.tableView.focusedRow = 2
-        grid.tableView.focusedColumn = 2
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.tableView.focusedRow == -1)
-        #expect(grid.tableView.focusedColumn == -1)
-    }
-
-    @Test("Command A still selects every row")
-    func selectAllSelectsEveryRow() {
-        let grid = SelectAllGrid()
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.tableView.selectedRowIndexes == IndexSet(integersIn: 0..<grid.rowCount))
-    }
-
-    /// Escape used to have a rectangle to cancel after Cmd+A. With none left it has to answer the
-    /// row selection instead, or Cmd+A becomes the one selection Escape cannot give back.
-    @Test("Escape after Command A deselects every row")
-    func escapeAfterSelectAllDeselectsEveryRow() {
-        let grid = SelectAllGrid()
-        grid.tableView.selectAll(nil)
-        #expect(!grid.tableView.selectedRowIndexes.isEmpty)
-
-        grid.tableView.cancelOperation(nil)
-
-        #expect(grid.tableView.selectedRowIndexes.isEmpty)
-    }
-
-    /// Every consumer of the published set, the status bar and the tab's stored selection included,
-    /// still sees all the rows.
-    @Test("Command A still publishes every row to the owner")
-    func selectAllStillPublishesEveryRow() {
-        let grid = SelectAllGrid()
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.published.value == Set(0..<grid.rowCount))
-    }
-
-    /// Shift+Space widens a cell selection to whole rows. It marks no heading as picked, which is
-    /// the half of it that shares the reported defect's cause.
-    @Test("Shift+Space marks no heading as picked")
-    func rowWideningPicksNoHeading() {
-        let grid = SelectAllGrid()
-        let seed = GridCoord(row: 2, displayColumn: 1)
-        grid.coordinator.selectionController.update(.single(GridRect(cell: seed), anchor: seed, active: seed))
-        grid.tableView.selectRowIndexes(IndexSet(integer: 2), byExtendingSelection: false)
-
-        grid.tableView.selectRowsIntersectingSelection()
-
-        #expect(grid.coordinator.selectionController.selectedFullColumns().isEmpty)
-        #expect(grid.pickedHeadings.isEmpty)
-    }
-
-    @Test("an empty grid falls through to the table view's own select all")
-    func emptyGridFallsThrough() {
-        let grid = SelectAllGrid(rowCount: 0)
-
-        grid.tableView.selectAll(nil)
-
-        #expect(grid.coordinator.selectionController.isEmpty)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/SelectionSummaryTrackerTests.swift b/apple/TableProTests/Views/Results/SelectionSummaryTrackerTests.swift
index 3b56b42922..26110af586 100644
--- a/apple/TableProTests/Views/Results/SelectionSummaryTrackerTests.swift
+++ b/apple/TableProTests/Views/Results/SelectionSummaryTrackerTests.swift
@@ -1,28 +1,11 @@
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProNumberFormatting
 import TableProPluginKit
 import TableProTestSupport
 import Testing
 
-@MainActor
-private final class SummaryLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class SummaryRowStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
 @MainActor
 private final class SummaryInputBox {
     var input: SelectionSummaryInput?
@@ -32,7 +15,7 @@ private final class SummaryInputBox {
     }
 }
 
-/// Holds the first computation open until the test lets it go, after it has its result.
+// Holds the first computation open until the test lets it go, after it has its result.
 private actor SummaryComputeGate {
     private var callCount = 0
     private let entered = AsyncGate()
@@ -57,37 +40,69 @@ private actor SummaryComputeGate {
     }
 }
 
+// A mounted grid whose model publishes into a summary state, which the shared fixture's model does not take.
 @MainActor
-struct SelectionSummaryTrackerTests {
-    private static let integer = ColumnType.integer(rawType: "INT")
-
-    private func makeGrid(
+private final class SummaryGrid {
+    let owner: GridTestOwner
+    let model: DataGridModel
+    let controller: DataGridViewController
+    let state: SelectionSummaryState?
+    private let window: NSWindow
+
+    init(
         _ rows: [[PluginCellValue]],
         types: [ColumnType],
-        state: SelectionSummaryState? = SelectionSummaryState(),
+        state: SelectionSummaryState?,
         changeManager: DataChangeManager = DataChangeManager()
-    ) -> (TableViewCoordinator, SummaryRowStore) {
-        let view = DataGridView(
-            changeManager: AnyChangeManager(changeManager),
-            isEditable: true,
-            layoutPersister: SummaryLayoutPersister(),
-            selectedRowIndices: .constant([]),
-            sortState: .constant(SortState()),
-            columnLayout: .constant(ColumnLayoutState()),
-            selectionSummary: state
+    ) {
+        self.state = state
+        owner = GridTestOwner(
+            TableRows.from(queryRows: rows, columns: types.indices.map { "c\($0)" }, columnTypes: types),
+            changeManager: changeManager
         )
-        let coordinator = view.makeCoordinator()
-        let store = SummaryRowStore(TableRows.from(
-            queryRows: rows,
-            columns: types.indices.map { "c\($0)" },
-            columnTypes: types
-        ))
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-        coordinator.updateCache()
-        return (coordinator, store)
+        owner.appliesCommits = true
+        var configuration = DataGridConfiguration()
+        configuration.isEditable = true
+        model = DataGridModel(configuration: configuration, selectionSummary: state)
+        model.dataSource = owner
+        model.actions = owner
+        owner.model = model
+        model.reloadRows()
+
+        controller = DataGridViewController(model: model)
+        let frame = NSRect(x: 0, y: 0, width: 600, height: 300)
+        window = NSWindow(contentRect: frame, styleMask: [.titled], backing: .buffered, defer: false)
+        window.isReleasedWhenClosed = false
+        let content = NSView(frame: frame)
+        window.contentView = content
+        controller.view.frame = content.bounds
+        content.addSubview(controller.view)
     }
 
+    var tracker: SelectionSummaryTracker { controller.selectionSummaryTracker }
+
+    // The controller attaches its tracker on the turn after it mounts.
+    func attached() async throws {
+        try await waitUntil { self.tracker.state === self.state }
+    }
+
+    func edit(row: Int, to value: DataGridEditValue) {
+        model.commit(
+            [DataGridCellEdit(rowID: .existing(row), columnID: DataGridColumnID(name: "c0", occurrence: 0), value: value)],
+            actionName: "Edit Cell"
+        )
+    }
+
+    func close() {
+        controller.dismantle()
+        window.orderOut(nil)
+    }
+}
+
+@MainActor
+struct SelectionSummaryTrackerTests {
+    private static let integer = ColumnType.integer(rawType: "INT")
+
     private static func block(rows: ClosedRange<Int>, columns: ClosedRange<Int>) -> GridSelection {
         .single(
             GridRect(rows: rows, columns: columns),
@@ -106,88 +121,113 @@ struct SelectionSummaryTrackerTests {
         )
     }
 
-    @Test("widening a selection sideways recomputes, though the selected rows stay the same")
-    func horizontalWideningRecomputes() async {
+    private func makeGrid(
+        _ rows: [[PluginCellValue]] = [[.text("1")], [.text("2")]],
+        types: [ColumnType] = [ColumnType.integer(rawType: "INT")],
+        changeManager: DataChangeManager = DataChangeManager()
+    ) async throws -> (SummaryGrid, SelectionSummaryState) {
         let state = SelectionSummaryState()
-        let (coordinator, _) = makeGrid(
+        let grid = SummaryGrid(rows, types: types, state: state, changeManager: changeManager)
+        try await grid.attached()
+        await grid.tracker.pendingTask?.value
+        return (grid, state)
+    }
+
+    @Test("Widening a selection sideways recomputes, though the selected rows stay the same")
+    func horizontalWideningRecomputes() async throws {
+        let (grid, state) = try await makeGrid(
             [[.text("1"), .text("10")], [.text("2"), .text("20")]],
-            types: [Self.integer, Self.integer],
-            state: state
+            types: [Self.integer, Self.integer]
         )
-        let tracker = coordinator.selectionSummaryTracker
+        defer { grid.close() }
 
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
-        await tracker.pendingTask?.value
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
         #expect(state.summary?.numbers?.sum.decimal == 3)
         let narrow = state.summary
 
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...1))
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...1))
         #expect(state.summary == narrow)
-        #expect(tracker.currentSummary == nil)
-        await tracker.pendingTask?.value
+        #expect(grid.tracker.currentSummary == nil)
+        await grid.tracker.pendingTask?.value
 
         #expect(state.summary?.numbers?.sum.decimal == 33)
         #expect(state.summary?.valueCount == 4)
-        #expect(tracker.currentSummary == state.summary)
+        #expect(grid.tracker.currentSummary == state.summary)
     }
 
-    @Test("an edit inside the selection recomputes the summary")
-    func editInsideSelectionRecomputes() async {
-        let state = SelectionSummaryState()
-        let (coordinator, _) = makeGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: state)
-        let tracker = coordinator.selectionSummaryTracker
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
-        await tracker.pendingTask?.value
+    @Test("An edit inside the selection recomputes the summary")
+    func editInsideSelectionRecomputes() async throws {
+        let (grid, state) = try await makeGrid()
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
         #expect(state.summary?.numbers?.sum.decimal == 3)
 
-        coordinator.commitCellEdit(row: 0, columnIndex: 0, newValue: "5")
-        await tracker.pendingTask?.value
+        grid.edit(row: 0, to: .enteredText("5"))
+        await grid.tracker.pendingTask?.value
 
         #expect(state.summary?.numbers?.sum.decimal == 7)
     }
 
-    @Test("a cell set to Default by an edit counts as empty, not as text")
-    func stagedDefaultIsEmpty() async {
-        let state = SelectionSummaryState()
-        let (coordinator, _) = makeGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: state)
-        let tracker = coordinator.selectionSummaryTracker
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
+    @Test("A cell set to Default by an edit counts as empty, not as text")
+    func stagedDefaultIsEmpty() async throws {
+        let (grid, state) = try await makeGrid()
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
 
-        coordinator.commitCellEdit(row: 1, columnIndex: 0, newValue: PluginCellValue.defaultMarkerText)
-        await tracker.pendingTask?.value
+        grid.edit(row: 1, to: .value(.text(PluginCellValue.defaultMarkerText), isExpression: false))
+        await grid.tracker.pendingTask?.value
 
         #expect(state.summary?.emptyCount == 1)
         #expect(state.summary?.notANumberCount == 0)
         #expect(state.summary?.numbers?.sum.decimal == 1)
     }
 
-    @Test("narrowing to a single cell takes the summary down")
-    func singleCellClears() async {
-        let state = SelectionSummaryState()
-        let (coordinator, _) = makeGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: state)
-        let tracker = coordinator.selectionSummaryTracker
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
-        await tracker.pendingTask?.value
+    @Test("A clicked or picked row has no summary: only a range of cells does")
+    func rowSelectionsHaveNoSummary() async throws {
+        let (grid, state) = try await makeGrid()
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
         #expect(state.summary != nil)
 
-        coordinator.selectionController.update(Self.block(rows: 1...1, columns: 0...0))
-        await tracker.pendingTask?.value
+        grid.model.selectCell(GridCoord(row: 1, displayColumn: 0))
+        await grid.tracker.pendingTask?.value
+        #expect(state.summary == nil)
+
+        grid.model.selectRows([.existing(0), .existing(1)])
+        await grid.tracker.pendingTask?.value
+        #expect(state.summary == nil)
+    }
+
+    @Test("Narrowing to a single cell takes the summary down")
+    func singleCellClears() async throws {
+        let (grid, state) = try await makeGrid()
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
+        #expect(state.summary != nil)
+
+        grid.model.setSelection(Self.block(rows: 1...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
 
         #expect(state.summary == nil)
-        #expect(tracker.currentSummary == nil)
+        #expect(grid.tracker.currentSummary == nil)
     }
 
-    @Test("a grid with no summary state computes nothing")
+    @Test("A grid with no summary state computes nothing")
     func gridWithoutStateComputesNothing() {
-        let (coordinator, _) = makeGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: nil)
+        let grid = SummaryGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: nil)
+        defer { grid.close() }
 
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
 
-        #expect(coordinator.selectionSummaryTracker.pendingTask == nil)
-        #expect(coordinator.selectionSummaryTracker.currentSummary == nil)
+        #expect(grid.tracker.pendingTask == nil)
+        #expect(grid.tracker.currentSummary == nil)
     }
 
-    @Test("a result computed for an older selection is never published")
+    @Test("A result computed for an older selection is never published")
     func staleGenerationNeverPublishes() async {
         let gate = SummaryComputeGate()
         let box = SummaryInputBox(Self.standaloneInput(["1", "2"]))
@@ -210,24 +250,22 @@ struct SelectionSummaryTrackerTests {
         #expect(tracker.currentSummary == state.summary)
     }
 
-    @Test("unmounting the grid takes its summary down and stops it publishing again")
-    func dismantleClearsAndDetaches() async {
-        let state = SelectionSummaryState()
-        let (coordinator, _) = makeGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: state)
-        let tracker = coordinator.selectionSummaryTracker
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
-        await tracker.pendingTask?.value
+    @Test("Unmounting the grid takes its summary down and stops it publishing again")
+    func dismantleClearsAndDetaches() async throws {
+        let (grid, state) = try await makeGrid()
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
         #expect(state.summary != nil)
 
-        DataGridView.dismantleNSView(NSScrollView(), coordinator: coordinator)
-        coordinator.applyDelta(.cellChanged(row: 0, column: 0))
-        await tracker.pendingTask?.value
+        grid.close()
+        grid.model.apply(.cellChanged(row: 0, column: 0))
+        await grid.tracker.pendingTask?.value
 
         #expect(state.summary == nil)
-        #expect(tracker.state == nil)
+        #expect(grid.tracker.state == nil)
     }
 
-    @Test("only the grid that attached last may write the summary")
+    @Test("Only the grid that attached last may write the summary")
     func onlyTheActiveOwnerWrites() {
         let state = SelectionSummaryState()
         let outgoing = UUID()
@@ -257,7 +295,7 @@ struct SelectionSummaryTrackerTests {
         #expect(state.summary == nil)
     }
 
-    @Test("a computation the outgoing grid finishes after the incoming grid attached is dropped")
+    @Test("A computation the outgoing grid finishes after the incoming grid attached is dropped")
     func outgoingCompletionNeverLandsOnTheIncomingGrid() async {
         let gate = SummaryComputeGate()
         let state = SelectionSummaryState()
@@ -282,67 +320,61 @@ struct SelectionSummaryTrackerTests {
         #expect(state.summary?.numbers?.sum.decimal == 30)
     }
 
-    @Test("figures being recomputed stay on screen but are not current, so Copy waits")
-    func recomputeMarksTheFiguresPending() async {
-        let state = SelectionSummaryState()
-        let (coordinator, _) = makeGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: state)
-        let tracker = coordinator.selectionSummaryTracker
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
-        await tracker.pendingTask?.value
+    @Test("Figures being recomputed stay on screen but are not current, so Copy waits")
+    func recomputeMarksTheFiguresPending() async throws {
+        let (grid, state) = try await makeGrid()
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
         #expect(state.isCurrent)
 
-        coordinator.commitCellEdit(row: 0, columnIndex: 0, newValue: "5")
+        grid.edit(row: 0, to: .enteredText("5"))
         #expect(!state.isCurrent)
         #expect(state.summary?.numbers?.sum.decimal == 3)
 
-        await tracker.pendingTask?.value
+        await grid.tracker.pendingTask?.value
         #expect(state.isCurrent)
         #expect(state.summary?.numbers?.sum.decimal == 7)
     }
 
-    @Test("a display format on a summed column leaves it counted but not summed, and taking it off sums it again")
-    func displayFormatChangeRecomputes() async {
-        let state = SelectionSummaryState()
-        let (coordinator, _) = makeGrid([[.text("1")], [.text("2")]], types: [Self.integer], state: state)
-        let tracker = coordinator.selectionSummaryTracker
-        coordinator.selectionController.update(Self.block(rows: 0...1, columns: 0...0))
-        await tracker.pendingTask?.value
+    @Test("A display format on a summed column leaves it counted but not summed, and taking it off sums it again")
+    func displayFormatChangeRecomputes() async throws {
+        let (grid, state) = try await makeGrid()
+        defer { grid.close() }
+        let column = try #require(grid.model.columns.column(at: 0))
+        grid.model.setSelection(Self.block(rows: 0...1, columns: 0...0))
+        await grid.tracker.pendingTask?.value
         #expect(state.summary?.numbers?.sum.decimal == 3)
 
-        coordinator.updateDisplayFormats([.unixTimestamp])
-        await tracker.pendingTask?.value
+        grid.model.setDisplayFormat(.unixTimestamp, for: column)
+        await grid.tracker.pendingTask?.value
         #expect(state.summary?.numbers == nil)
         #expect(state.summary?.valueCount == 2)
         #expect(state.summary?.notANumberCount == 0)
 
-        coordinator.updateDisplayFormats([nil])
-        await tracker.pendingTask?.value
+        grid.model.setDisplayFormat(nil, for: column)
+        await grid.tracker.pendingTask?.value
         #expect(state.summary?.numbers?.sum.decimal == 3)
     }
 
-    @Test("a row staged for deletion leaves the sum, and Undo Delete puts it back")
-    func stagedDeletionAndUndoDeleteRecompute() async {
-        let state = SelectionSummaryState()
+    @Test("A row staged for deletion leaves the sum, and undoing the delete puts it back")
+    func stagedDeletionAndUndoDeleteRecompute() async throws {
         let manager = DataChangeManager()
-        let (coordinator, _) = makeGrid(
-            [[.text("1")], [.text("2")], [.text("3")]],
-            types: [Self.integer],
-            state: state,
-            changeManager: manager
-        )
-        let tracker = coordinator.selectionSummaryTracker
-        coordinator.selectionController.update(Self.block(rows: 0...2, columns: 0...0))
-        await tracker.pendingTask?.value
+        let (grid, state) = try await makeGrid([[.text("1")], [.text("2")], [.text("3")]], changeManager: manager)
+        defer { grid.close() }
+        grid.model.setSelection(Self.block(rows: 0...2, columns: 0...0))
+        await grid.tracker.pendingTask?.value
         #expect(state.summary?.numbers?.sum.decimal == 6)
 
         manager.recordRowDeletion(rowID: .existing(1), originalRow: [.text("2")])
-        coordinator.invalidateCachesForUndoRedo()
-        await tracker.pendingTask?.value
+        grid.model.repaintRows([RowID.existing(1)])
+        await grid.tracker.pendingTask?.value
         #expect(state.summary?.numbers?.sum.decimal == 4)
         #expect(state.summary?.valueCount == 2)
 
-        coordinator.undoDeleteRow(at: 1)
-        await tracker.pendingTask?.value
+        manager.undoRowDeletion(rowID: .existing(1))
+        grid.model.repaintRows([RowID.existing(1)])
+        await grid.tracker.pendingTask?.value
         #expect(!manager.isRowDeleted(.existing(1)))
         #expect(state.summary?.numbers?.sum.decimal == 6)
         #expect(state.summary?.valueCount == 3)
diff --git a/apple/TableProTests/Views/Results/SizeAllColumnsToFitTests.swift b/apple/TableProTests/Views/Results/SizeAllColumnsToFitTests.swift
deleted file mode 100644
index e96d39548b..0000000000
--- a/apple/TableProTests/Views/Results/SizeAllColumnsToFitTests.swift
+++ /dev/null
@@ -1,191 +0,0 @@
-//
-//  SizeAllColumnsToFitTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class CountingLayoutPersister: ColumnLayoutPersisting {
-    private(set) var saveCount = 0
-
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) { saveCount += 1 }
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// `captureColumnLayout()` asks `tableRowsProvider` for the result exactly once, which is what
-/// these tests count. The walks are otherwise invisible from outside.
-@MainActor
-struct SizeAllColumnsToFitTests {
-    private struct Grid {
-        let window: NSWindow
-        let coordinator: TableViewCoordinator
-        let persister: CountingLayoutPersister
-        let rowsRequested: () -> Int
-    }
-
-    private func makeGrid(columns: [String], rows: Int = 3) -> Grid {
-        let persister = CountingLayoutPersister()
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: persister
-        )
-        coordinator.tabType = .table
-        coordinator.connectionId = UUID()
-        coordinator.tableName = "users"
-
-        let queryRows = (0 ..< rows).map { row in columns.map { PluginCellValue.text("\($0)-\(row)") } }
-        let tableRows = TableRows.from(
-            queryRows: queryRows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        )
-
-        let counter = RequestCounter()
-        coordinator.tableRowsProvider = {
-            counter.value += 1
-            return tableRows
-        }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 900, height: 200))
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 90 }
-        )
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 900, height: 200))
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 900, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView = scrollView
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        return Grid(
-            window: window,
-            coordinator: coordinator,
-            persister: persister,
-            rowsRequested: { counter.value }
-        )
-    }
-
-    @MainActor
-    private final class RequestCounter {
-        var value = 0
-    }
-
-    /// One read for the menu item and one for the single capture, whatever the column count.
-    @Test("Fitting every column captures the layout once")
-    func fittingEveryColumnCapturesOnce() throws {
-        let grid = makeGrid(columns: ["id", "name", "email", "city", "country"])
-        defer { grid.coordinator.layoutPersistTask?.cancel() }
-        let before = grid.rowsRequested()
-
-        grid.coordinator.sizeAllColumnsToFit(NSMenuItem())
-
-        #expect(grid.rowsRequested() - before == 2)
-    }
-
-    @Test("The capture count does not grow with the number of columns")
-    func captureCountIsIndependentOfColumnCount() throws {
-        let narrow = makeGrid(columns: ["id", "name"])
-        defer { narrow.coordinator.layoutPersistTask?.cancel() }
-        let narrowBefore = narrow.rowsRequested()
-        narrow.coordinator.sizeAllColumnsToFit(NSMenuItem())
-        let narrowCost = narrow.rowsRequested() - narrowBefore
-
-        let wide = makeGrid(columns: (0 ..< 24).map { "c\($0)" })
-        defer { wide.coordinator.layoutPersistTask?.cancel() }
-        let wideBefore = wide.rowsRequested()
-        wide.coordinator.sizeAllColumnsToFit(NSMenuItem())
-        let wideCost = wide.rowsRequested() - wideBefore
-
-        #expect(narrowCost == wideCost)
-    }
-
-    /// Without ownership the next reconcile measures every column from its content and drops the fit.
-    @Test("Every fitted column is still marked user-sized")
-    func everyFittedColumnKeepsOwnership() throws {
-        let grid = makeGrid(columns: ["id", "name", "email"])
-        defer { grid.coordinator.layoutPersistTask?.cancel() }
-
-        grid.coordinator.sizeAllColumnsToFit(NSMenuItem())
-
-        #expect(grid.coordinator.userSizedColumnNames == ["id", "name", "email"])
-    }
-
-    @Test("Every fitted column ends up in the persisted layout")
-    func everyFittedColumnIsPersisted() throws {
-        let grid = makeGrid(columns: ["id", "name", "email"])
-
-        grid.coordinator.sizeAllColumnsToFit(NSMenuItem())
-        grid.coordinator.flushPendingColumnLayoutPersistence()
-
-        #expect(grid.persister.saveCount == 1)
-    }
-
-    /// A fit inside a rebuild must leave the rebuild's own suppression intact.
-    @Test("A fit restores the rebuild flag it found")
-    func theRebuildFlagIsRestored() throws {
-        let grid = makeGrid(columns: ["id", "name"])
-        defer { grid.coordinator.layoutPersistTask?.cancel() }
-
-        grid.coordinator.sizeAllColumnsToFit(NSMenuItem())
-        #expect(!grid.coordinator.isRebuildingColumns)
-
-        grid.coordinator.isRebuildingColumns = true
-        grid.coordinator.sizeAllColumnsToFit(NSMenuItem())
-        #expect(grid.coordinator.isRebuildingColumns)
-        grid.coordinator.isRebuildingColumns = false
-    }
-
-    @Test("Fitting every column still repaints the drawn cells")
-    func fittingEveryColumnStillRepaints() throws {
-        let grid = makeGrid(columns: ["id", "name", "email"])
-        defer { grid.coordinator.layoutPersistTask?.cancel() }
-        let tableView = try #require(grid.coordinator.tableView)
-        for row in 0 ..< tableView.numberOfRows {
-            _ = tableView.rowView(atRow: row, makeIfNecessary: true)
-        }
-        tableView.display()
-
-        var contentViews: [DataGridRowContentView] = []
-        tableView.enumerateAvailableRowViews { rowView, _ in
-            guard let content = rowView.subviews.first as? DataGridRowContentView else { return }
-            contentViews.append(content)
-        }
-        #expect(!contentViews.isEmpty)
-        #expect(contentViews.allSatisfy { !$0.needsDisplay })
-
-        grid.coordinator.sizeAllColumnsToFit(NSMenuItem())
-
-        let everyRowAwaitsRepaint = contentViews.allSatisfy { $0.needsDisplay }
-        #expect(everyRowAwaitsRepaint)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/SortableHeaderCellTests.swift b/apple/TableProTests/Views/Results/SortableHeaderCellTests.swift
deleted file mode 100644
index 9efa1aa879..0000000000
--- a/apple/TableProTests/Views/Results/SortableHeaderCellTests.swift
+++ /dev/null
@@ -1,131 +0,0 @@
-import AppKit
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct SortableHeaderCellTests {
-    @Test("Title rect uses data cell horizontal padding")
-    func titleRectUsesDataCellHorizontalPadding() {
-        let cell = SortableHeaderCell(textCell: "id")
-        cell.supportsValueFilter = false
-        let titleRect = cell.titleRect(forBounds: NSRect(x: 10, y: 0, width: 100, height: 24))
-
-        #expect(titleRect.minX == 14)
-        #expect(titleRect.width == 92)
-    }
-
-    @Test("Narrow title rect does not produce negative width")
-    func narrowTitleRectDoesNotProduceNegativeWidth() {
-        let cell = SortableHeaderCell(textCell: "id")
-        let titleRect = cell.titleRect(forBounds: NSRect(x: 0, y: 0, width: 6, height: 24))
-
-        #expect(titleRect.minX == 3)
-        #expect(titleRect.width == 0)
-    }
-
-    @Test("Sorted title rect reserves trailing space for the indicator")
-    func sortedTitleRectReservesTrailingSpaceForIndicator() {
-        let bounds = NSRect(x: 0, y: 0, width: 100, height: 24)
-
-        let unsorted = SortableHeaderCell(textCell: "id")
-        let sorted = SortableHeaderCell(textCell: "id")
-        sorted.sortDirection = .ascending
-
-        let unsortedRect = unsorted.titleRect(forBounds: bounds)
-        let sortedRect = sorted.titleRect(forBounds: bounds)
-
-        #expect(sortedRect.minX == unsortedRect.minX)
-        #expect(sortedRect.width < unsortedRect.width)
-        #expect(sortedRect.maxX <= bounds.maxX - DataGridMetrics.cellHorizontalInset)
-    }
-
-    @Test("Priority badge shrinks the sorted title rect further")
-    func priorityBadgeShrinksSortedTitleRectFurther() {
-        let bounds = NSRect(x: 0, y: 0, width: 100, height: 24)
-
-        let sorted = SortableHeaderCell(textCell: "id")
-        sorted.sortDirection = .ascending
-
-        let prioritized = SortableHeaderCell(textCell: "id")
-        prioritized.sortDirection = .ascending
-        prioritized.sortPriority = 2
-
-        let sortedWidth = sorted.titleRect(forBounds: bounds).width
-        let prioritizedWidth = prioritized.titleRect(forBounds: bounds).width
-
-        #expect(prioritizedWidth < sortedWidth)
-    }
-
-    @Test("Accessibility label appends the sort and filter state to the column label")
-    func accessibilityLabelAppendsSortAndFilterState() {
-        let cell = SortableHeaderCell(textCell: "email")
-        cell.setAccessibilityLabel("Column: email, Primary contact address")
-        cell.sortDirection = .ascending
-        cell.isValueFiltered = true
-
-        #expect(cell.accessibilityLabel() == "Column: email, Primary contact address, Sorted ascending, Filtered")
-    }
-
-    @Test("Header comment is resolved from the header view, not stored on the cell")
-    func headerCommentIsResolvedFromHeaderView() {
-        let comment = heapAllocatedComment()
-        let header = makeHeader(comment: comment)
-
-        #expect(header.view.comment(for: header.cell) == comment)
-    }
-
-    @Test("A copied header cell resolves no comment, so the overflow filler draws none")
-    func copiedHeaderCellResolvesNoComment() throws {
-        let header = makeHeader(comment: heapAllocatedComment())
-        let copy = try #require(header.cell.copy() as? SortableHeaderCell)
-
-        #expect(header.view.comment(for: copy) == nil)
-    }
-
-    @Test("Header cell survives the shallow copies AppKit makes while drawing the header")
-    func headerCellSurvivesShallowCopies() {
-        let comment = heapAllocatedComment()
-        let header = makeHeader(comment: comment)
-
-        for _ in 0..<3 {
-            autoreleasepool {
-                _ = header.cell.copy()
-            }
-        }
-
-        #expect(header.view.comment(for: header.cell) == comment)
-    }
-
-    private func heapAllocatedComment() -> String {
-        String(repeating: "Primary contact address", count: 1)
-    }
-
-    private func makeHeader(comment: String) -> (view: SortableHeaderView, cell: SortableHeaderCell) {
-        let tableView = NSTableView()
-        let cell = SortableHeaderCell(textCell: "email")
-        let column = NSTableColumn(identifier: NSUserInterfaceItemIdentifier("email"))
-        column.headerCell = cell
-        tableView.addTableColumn(column)
-
-        let headerView = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: 200, height: 28))
-        tableView.headerView = headerView
-        headerView.updateComments([column.identifier: comment])
-
-        return (headerView, cell)
-    }
-}
-
-@MainActor
-struct DataGridRowNumberColumnTests {
-    @Test("Row-number column header uses a right-aligned SortableHeaderCell")
-    func rowNumberHeaderIsRightAlignedSortableCell() throws {
-        let column = DataGridView.makeRowNumberColumn()
-
-        let headerCell = try #require(column.headerCell as? SortableHeaderCell)
-        #expect(headerCell.alignment == .right)
-        #expect(column.identifier == ColumnIdentitySchema.rowNumberIdentifier)
-        #expect(column.title == "#")
-    }
-}
diff --git a/apple/TableProTests/Views/Results/SortableHeaderRenderingTests.swift b/apple/TableProTests/Views/Results/SortableHeaderRenderingTests.swift
deleted file mode 100644
index c2336d434c..0000000000
--- a/apple/TableProTests/Views/Results/SortableHeaderRenderingTests.swift
+++ /dev/null
@@ -1,212 +0,0 @@
-//
-//  SortableHeaderRenderingTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct SortableHeaderRenderingTests {
-    private struct Grid {
-        let window: NSWindow
-        let tableView: NSTableView
-        let headerView: SortableHeaderView
-        let headerCells: [SortableHeaderCell]
-        let schema: ColumnIdentitySchema
-
-        var headerCell: SortableHeaderCell { headerCells[0] }
-    }
-
-    private static let contentWidth: CGFloat = 400
-    private static let columnAreaWidth: CGFloat = 360
-
-    private func makeGrid(comment: String?, columns: [String] = ["code"]) -> Grid {
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: Self.contentWidth, height: 200))
-        let tableView = NSTableView(frame: scrollView.bounds)
-        tableView.style = .plain
-
-        let schema = ColumnIdentitySchema(columns: columns)
-        var cells: [SortableHeaderCell] = []
-        var comments: [NSUserInterfaceItemIdentifier: String] = [:]
-        for (index, name) in columns.enumerated() {
-            let column = NSTableColumn(identifier: ColumnIdentitySchema.slotIdentifier(index))
-            column.width = Self.columnAreaWidth / CGFloat(columns.count)
-            let headerCell = SortableHeaderCell(textCell: name)
-            headerCell.font = column.headerCell.font
-            column.headerCell = headerCell
-            cells.append(headerCell)
-            if let comment {
-                comments[column.identifier] = comment
-            }
-            tableView.addTableColumn(column)
-        }
-
-        let headerView = SortableHeaderView(frame: tableView.headerView?.frame ?? .zero)
-        tableView.headerView = headerView
-        scrollView.documentView = tableView
-
-        let window = makeWindow(content: scrollView)
-
-        if comment != nil {
-            headerView.updateComments(comments)
-            headerView.showsComments = true
-        }
-
-        scrollView.tile()
-        window.layoutIfNeeded()
-        return Grid(
-            window: window,
-            tableView: tableView,
-            headerView: headerView,
-            headerCells: cells,
-            schema: schema
-        )
-    }
-
-    private func makeWindow(content: NSView) -> NSWindow {
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: Self.contentWidth, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.appearance = NSAppearance(named: .darkAqua)
-        window.contentView = content
-        window.layoutIfNeeded()
-        return window
-    }
-
-    private func sortState(column: Int, direction: SortDirection = .ascending) -> SortState {
-        var state = SortState()
-        state.columns = [SortColumn(columnIndex: column, direction: direction)]
-        return state
-    }
-
-    private func brightnessColumn(of view: NSView, atX sampleX: CGFloat) -> [CGFloat] {
-        guard let rep = view.bitmapImageRepForCachingDisplay(in: view.bounds) else { return [] }
-        view.cacheDisplay(in: view.bounds, to: rep)
-        let scale = CGFloat(rep.pixelsHigh) / view.bounds.height
-        let x = min(rep.pixelsWide - 1, Int(sampleX * scale))
-        return (0 ..< rep.pixelsHigh).map { rep.colorAt(x: x, y: $0)?.brightnessComponent ?? 0 }
-    }
-
-    private func ruleOffsets(in view: NSView, atX sampleX: CGFloat = 300) -> [CGFloat] {
-        let brightness = brightnessColumn(of: view, atX: sampleX)
-        guard !brightness.isEmpty else { return [] }
-        let scale = CGFloat(brightness.count) / view.bounds.height
-        let span = max(1, Int((3 * scale).rounded()))
-        return brightness.indices.compactMap { index in
-            guard abs(brightness[index] - brightness[max(0, index - span)]) > 0.02 else { return nil }
-            return CGFloat(index) / scale
-        }
-    }
-
-    private func isAlongBottomEdge(_ offset: CGFloat, of view: NSView) -> Bool {
-        offset >= view.bounds.height - SortableHeaderChrome.separatorThickness
-    }
-
-    @Test("The comment header draws its only horizontal rule along the bottom edge")
-    func commentHeaderRuleSitsAlongBottomEdge() {
-        let grid = makeGrid(comment: "ISO 4217 exponent for the minor unit")
-        let offsets = ruleOffsets(in: grid.headerView)
-
-        #expect(!offsets.isEmpty)
-        #expect(offsets.allSatisfy { isAlongBottomEdge($0, of: grid.headerView) })
-    }
-
-    @Test("The comment header draws no horizontal rule across the comment line")
-    func commentHeaderDrawsNoRuleAcrossTheCommentLine() {
-        let grid = makeGrid(comment: "ISO 4217 exponent for the minor unit")
-        let naturalHeight = grid.headerView.commentHeaderHeight - SortableHeaderCell.commentLineHeight
-        let centredBandBottom = (grid.headerView.commentHeaderHeight + naturalHeight) / 2
-            - SortableHeaderChrome.separatorThickness
-
-        let offsets = ruleOffsets(in: grid.headerView)
-
-        #expect(!offsets.contains { abs($0 - centredBandBottom) < 1 })
-    }
-
-    @Test("The bottom rule spans past the trailing edge of the last column")
-    func bottomRuleSpansPastTheLastColumn() {
-        let grid = makeGrid(comment: "ISO 4217 exponent for the minor unit")
-        let offsets = ruleOffsets(in: grid.headerView, atX: 390)
-
-        #expect(!offsets.isEmpty)
-        #expect(offsets.allSatisfy { isAlongBottomEdge($0, of: grid.headerView) })
-    }
-
-    @Test("The natural height header keeps its rule along the bottom edge")
-    func naturalHeaderRuleSitsAlongBottomEdge() {
-        let grid = makeGrid(comment: nil)
-        let offsets = ruleOffsets(in: grid.headerView)
-
-        #expect(!offsets.isEmpty)
-        #expect(offsets.allSatisfy { isAlongBottomEdge($0, of: grid.headerView) })
-    }
-
-    @Test("Selecting a column highlights the full height of the comment header")
-    func selectionHighlightSpansTheCommentHeader() {
-        let grid = makeGrid(comment: "ISO 4217 exponent for the minor unit")
-        let unselected = brightnessColumn(of: grid.headerView, atX: 300)
-
-        grid.headerCell.isColumnSelected = true
-        grid.headerView.needsDisplay = true
-        let selected = brightnessColumn(of: grid.headerView, atX: 300)
-
-        #expect(!unselected.isEmpty)
-        #expect(unselected.count == selected.count)
-        let repainted = zip(unselected, selected).filter { abs($0 - $1) > 0.02 }.count
-        #expect(repainted >= unselected.count - 4)
-    }
-
-    @Test("A sorted column keeps its only horizontal rule along the bottom edge")
-    func sortedCommentHeaderRuleSitsAlongBottomEdge() {
-        let grid = makeGrid(comment: "ISO 4217 exponent for the minor unit")
-        grid.headerView.applySortState(sortState(column: 0), schema: grid.schema)
-        grid.headerView.needsDisplay = true
-
-        let offsets = ruleOffsets(in: grid.headerView)
-
-        #expect(grid.headerCell.sortDirection == .ascending)
-        #expect(!offsets.isEmpty)
-        #expect(offsets.allSatisfy { isAlongBottomEdge($0, of: grid.headerView) })
-    }
-
-    @Test("Sorting a column leaves every column divider where it was")
-    func sortingDoesNotMoveColumnDividers() {
-        let grid = makeGrid(comment: "ISO 4217 exponent for the minor unit", columns: ["code", "amount"])
-        let leadingEdge = grid.headerView.headerRect(ofColumn: 1).minX
-        let unsorted = brightnessColumn(of: grid.headerView, atX: leadingEdge)
-
-        grid.headerView.applySortState(sortState(column: 1), schema: grid.schema)
-        grid.headerView.needsDisplay = true
-        let sorted = brightnessColumn(of: grid.headerView, atX: leadingEdge)
-
-        #expect(!unsorted.isEmpty)
-        #expect(unsorted == sorted)
-    }
-
-    @Test("Sorting never hands the column to AppKit's own header highlight")
-    func sortingDoesNotUseTheAppKitColumnHighlight() {
-        let grid = makeGrid(comment: "ISO 4217 exponent for the minor unit", columns: ["code", "amount"])
-        grid.headerView.applySortState(sortState(column: 1), schema: grid.schema)
-
-        #expect(grid.tableView.highlightedTableColumn == nil)
-    }
-
-    @Test("Applying a sort state publishes it through the table's sort descriptors")
-    func sortStatePublishesSortDescriptors() {
-        let grid = makeGrid(comment: nil, columns: ["code", "amount"])
-
-        grid.headerView.applySortState(sortState(column: 1, direction: .descending), schema: grid.schema)
-        #expect(grid.tableView.sortDescriptors.count == 1)
-        #expect(grid.tableView.sortDescriptors.first?.key == "amount")
-        #expect(grid.tableView.sortDescriptors.first?.ascending == false)
-
-        grid.headerView.applySortState(SortState(), schema: grid.schema)
-        #expect(grid.tableView.sortDescriptors.isEmpty)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/SortableHeaderResizeZoneTests.swift b/apple/TableProTests/Views/Results/SortableHeaderResizeZoneTests.swift
deleted file mode 100644
index 61e978516b..0000000000
--- a/apple/TableProTests/Views/Results/SortableHeaderResizeZoneTests.swift
+++ /dev/null
@@ -1,176 +0,0 @@
-//
-//  SortableHeaderResizeZoneTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class ResizeZoneLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// A hidden column's header rect is zero, so its trailing edge is x = 0 and it reads as a divider
-/// at the header's leading edge: the resize cursor appeared over the row-number heading and the
-/// header swallowed the clicks landing there.
-@MainActor
-struct SortableHeaderResizeZoneTests {
-    private struct Grid {
-        let window: NSWindow
-        let coordinator: TableViewCoordinator
-        let header: SortableHeaderView
-    }
-
-    private func makeGrid(columns: [String], hidden: Set<String> = [], columnWidth: CGFloat = 120) -> Grid {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: ResizeZoneLayoutPersister()
-        )
-        let queryRows = [columns.map { PluginCellValue.text($0) }]
-        let tableRows = TableRows.from(
-            queryRows: queryRows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 900, height: 200))
-        tableView.style = .plain
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-
-        let header = SortableHeaderView(frame: NSRect(x: 0, y: 0, width: 900, height: 28))
-        header.coordinator = coordinator
-        tableView.headerView = header
-
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count),
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: hidden,
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in columnWidth }
-        )
-
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 900, height: 200))
-        scrollView.documentView = tableView
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 900, height: 200),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView = scrollView
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        return Grid(window: window, coordinator: coordinator, header: header)
-    }
-
-    private func point(x: CGFloat, in grid: Grid) -> NSPoint {
-        NSPoint(x: x, y: grid.header.bounds.midY)
-    }
-
-    @Test("The header's leading edge is not a resize zone when a column is hidden")
-    func theLeadingEdgeIsNotAResizeZone() throws {
-        let grid = makeGrid(columns: ["id", "name", "email"], hidden: ["name"])
-
-        #expect(!grid.header.isInResizeZone(point: point(x: 0, in: grid)))
-        #expect(!grid.header.isInResizeZone(point: point(x: 2, in: grid)))
-    }
-
-    /// Surplus slots need no user action: a narrower result in a grid that held a wider one leaves them.
-    @Test("Slots left over from a wider result are not resize zones")
-    func surplusPoolSlotsAreNotResizeZones() throws {
-        let grid = makeGrid(columns: ["a", "b", "c", "d", "e", "f"])
-        let tableView = try #require(grid.coordinator.tableView)
-        let narrower = TableRows.from(
-            queryRows: [[.text("a"), .text("b")]],
-            columns: ["a", "b"],
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
-        )
-        grid.coordinator.tableRowsProvider = { narrower }
-        grid.coordinator.rebuildColumnMetadataCache(from: narrower)
-        grid.coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: grid.coordinator.identitySchema,
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 120 }
-        )
-        tableView.layoutSubtreeIfNeeded()
-
-        #expect(!grid.header.isInResizeZone(point: point(x: 0, in: grid)))
-        #expect(!grid.header.isInResizeZone(point: point(x: 2, in: grid)))
-    }
-
-    @Test("A presented column's trailing edge is still a resize zone")
-    func aPresentedColumnEdgeIsAResizeZone() throws {
-        let grid = makeGrid(columns: ["id", "name", "email"])
-        let tableView = try #require(grid.coordinator.tableView)
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let edge = grid.header.headerRect(ofColumn: firstData).maxX
-        #expect(edge > 0)
-
-        #expect(grid.header.isInResizeZone(point: point(x: edge, in: grid)))
-    }
-
-    /// AppKit resizes only from a press 3pt before a column's edge up to 2pt after it, measured on
-    /// macOS 27. Past that band AppKit takes the press as a reorder, so a zone reaching further
-    /// showed the resize cursor where a drag moved the column and a click sorted nothing.
-    @Test("The resize zone is AppKit's divider band, from 3pt before a column's edge to under 2pt after it")
-    func theResizeZoneIsAppKitsDividerBand() throws {
-        let grid = makeGrid(columns: ["id", "name", "email"])
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let edge = grid.header.headerRect(ofColumn: firstData).maxX
-
-        for offset: CGFloat in [-3, -1, 0, 1, 1.5] {
-            #expect(grid.header.isInResizeZone(point: point(x: edge + offset, in: grid)), "offset \(offset)")
-        }
-        for offset: CGFloat in [-4, -3.25, 2, 3, 4] {
-            #expect(!grid.header.isInResizeZone(point: point(x: edge + offset, in: grid)), "offset \(offset)")
-        }
-    }
-
-    /// The middle of a heading is where a click sorts.
-    @Test("The middle of a column heading is not a resize zone")
-    func theMiddleOfAHeadingIsNotAResizeZone() throws {
-        let grid = makeGrid(columns: ["id", "name", "email"])
-        let firstData = try #require(grid.coordinator.firstPresentedColumnIndex())
-        let rect = grid.header.headerRect(ofColumn: firstData)
-
-        #expect(!grid.header.isInResizeZone(point: point(x: rect.midX, in: grid)))
-    }
-
-    @Test("The row-number column's trailing edge is not a resize zone")
-    func theRowNumberColumnEdgeIsNotAResizeZone() throws {
-        let grid = makeGrid(columns: ["id", "name"])
-        let tableView = try #require(grid.coordinator.tableView)
-        let rowNumber = tableView.column(withIdentifier: ColumnIdentitySchema.rowNumberIdentifier)
-        #expect(rowNumber >= 0)
-        let edge = grid.header.headerRect(ofColumn: rowNumber).maxX
-
-        #expect(!grid.header.isInResizeZone(point: point(x: edge, in: grid)))
-    }
-}
diff --git a/apple/TableProTests/Views/Results/SortableHeaderViewTests.swift b/apple/TableProTests/Views/Results/SortableHeaderViewTests.swift
deleted file mode 100644
index eaeaf3b94d..0000000000
--- a/apple/TableProTests/Views/Results/SortableHeaderViewTests.swift
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-//  SortableHeaderViewTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct SortableHeaderViewTests {
-    private struct Grid {
-        let scrollView: NSScrollView
-        let tableView: NSTableView
-        let headerView: SortableHeaderView
-
-        var headerClipHeight: CGFloat? {
-            scrollView.subviews
-                .compactMap { $0 as? NSClipView }
-                .first { $0 !== scrollView.contentView }?
-                .frame.height
-        }
-    }
-
-    private func makeGrid() -> Grid {
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 400, height: 300))
-        let tableView = NSTableView(frame: scrollView.bounds)
-        tableView.addTableColumn(NSTableColumn(identifier: NSUserInterfaceItemIdentifier("id")))
-        let headerView = SortableHeaderView(frame: tableView.headerView?.frame ?? .zero)
-        tableView.headerView = headerView
-        scrollView.documentView = tableView
-        scrollView.layoutSubtreeIfNeeded()
-        return Grid(scrollView: scrollView, tableView: tableView, headerView: headerView)
-    }
-
-    @Test("Showing comments grows the scroll view's header area, not just the header frame")
-    func showingCommentsGrowsHeaderClip() {
-        let grid = makeGrid()
-        let naturalHeight = grid.headerView.frame.height
-
-        grid.headerView.showsComments = true
-
-        #expect(grid.headerView.commentHeaderHeight > naturalHeight)
-        #expect(grid.headerView.frame.height == grid.headerView.commentHeaderHeight)
-        #expect(grid.headerClipHeight == grid.headerView.commentHeaderHeight)
-    }
-
-    @Test("Hiding comments restores the platform header height")
-    func hidingCommentsRestoresNaturalHeight() {
-        let grid = makeGrid()
-        let naturalHeight = grid.headerView.frame.height
-
-        grid.headerView.showsComments = true
-        grid.headerView.showsComments = false
-
-        #expect(grid.headerView.frame.height == naturalHeight)
-        #expect(grid.headerClipHeight == naturalHeight)
-    }
-
-    @Test("The comment header reserves room for the comment line under the column name")
-    func commentHeaderHeightFitsCommentLine() {
-        let grid = makeGrid()
-        let naturalHeight = grid.headerView.frame.height
-
-        #expect(grid.headerView.commentHeaderHeight == naturalHeight + SortableHeaderCell.commentLineHeight)
-    }
-
-    @Test("Resizing and reloading the grid keeps the grown header")
-    func laterLayoutKeepsGrownHeader() {
-        let grid = makeGrid()
-        grid.headerView.showsComments = true
-
-        grid.scrollView.setFrameSize(NSSize(width: 320, height: 240))
-        grid.scrollView.tile()
-        grid.tableView.reloadData()
-        grid.scrollView.layoutSubtreeIfNeeded()
-
-        #expect(grid.headerView.frame.height == grid.headerView.commentHeaderHeight)
-        #expect(grid.headerClipHeight == grid.headerView.commentHeaderHeight)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorColumnJumpTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorColumnJumpTests.swift
deleted file mode 100644
index 557fa505d1..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorColumnJumpTests.swift
+++ /dev/null
@@ -1,231 +0,0 @@
-//
-//  TableViewCoordinatorColumnJumpTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class ColumnJumpLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct TableViewCoordinatorColumnJumpTests {
-    private func makeCoordinator(
-        columns: [String] = ["id", "name", "email"],
-        hiddenColumns: Set<String> = [],
-        rowCount: Int = 2
-    ) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: ColumnJumpLayoutPersister()
-        )
-        let rows = (0..<rowCount).map { row in columns.map { PluginCellValue.text("\($0) \(row)") } }
-        let tableRows = TableRows.from(
-            queryRows: rows,
-            columns: columns,
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: columns.count)
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        reconcile(coordinator, hiddenColumns: hiddenColumns)
-        tableView.reloadData()
-        return coordinator
-    }
-
-    private func reconcile(_ coordinator: TableViewCoordinator, hiddenColumns: Set<String>) {
-        guard let tableView = coordinator.tableView else { return }
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: [],
-            savedLayout: nil,
-            isEditable: true,
-            hiddenColumnNames: hiddenColumns,
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        coordinator.invalidateColumnIndexCache()
-    }
-
-    @Test("A jump puts the cell cursor in the column on the first row when nothing is selected")
-    func jumpSeedsTheCursor() throws {
-        let coordinator = makeCoordinator()
-        let tableView = try #require(coordinator.tableView as? KeyHandlingTableView)
-
-        #expect(coordinator.jumpToColumn(dataIndex: 2))
-
-        #expect(tableView.selectedRow == 0)
-        #expect(tableView.focusedRow == 0)
-        #expect(tableView.focusedColumn == coordinator.tableColumnIndex(for: 2))
-        #expect(coordinator.focusedDataColumnIndex == 2)
-    }
-
-    @Test("A jump keeps the selected row")
-    func jumpKeepsTheSelectedRow() throws {
-        let coordinator = makeCoordinator()
-        let tableView = try #require(coordinator.tableView as? KeyHandlingTableView)
-        tableView.selectRowIndexes(IndexSet(integer: 1), byExtendingSelection: false)
-
-        #expect(coordinator.jumpToColumn(dataIndex: 1))
-
-        #expect(tableView.selectedRow == 1)
-        #expect(tableView.focusedRow == 1)
-        #expect(coordinator.focusedDataColumnIndex == 1)
-    }
-
-    @Test("A hidden column is refused, and the cursor is left where it was")
-    func hiddenColumnIsRefused() throws {
-        let coordinator = makeCoordinator(hiddenColumns: ["name"])
-        let tableView = try #require(coordinator.tableView as? KeyHandlingTableView)
-
-        #expect(coordinator.jumpToColumn(dataIndex: 1) == false)
-
-        #expect(tableView.selectedRow == -1)
-        #expect(coordinator.focusedDataColumnIndex == nil)
-    }
-
-    private func parked(
-        _ name: String,
-        dataIndex: Int? = nil,
-        tableKey: ColumnLayoutTableKey? = nil,
-        awaitsResultReplacement: Bool = false
-    ) -> PendingColumnJump {
-        PendingColumnJump(
-            name: name,
-            dataIndex: dataIndex,
-            tableKey: tableKey,
-            awaitsResultReplacement: awaitsResultReplacement
-        )
-    }
-
-    @Test("A parked jump waits for the column to be presented, then lands once")
-    func pendingJumpLandsWhenPresented() throws {
-        let coordinator = makeCoordinator(hiddenColumns: ["name"])
-        let pending = parked("name")
-        coordinator.pendingColumnJump = pending
-
-        coordinator.consumePendingColumnJump(contentReplaced: false)
-        #expect(coordinator.pendingColumnJump == pending)
-        #expect(coordinator.focusedDataColumnIndex == nil)
-
-        reconcile(coordinator, hiddenColumns: [])
-        coordinator.consumePendingColumnJump(contentReplaced: false)
-
-        #expect(coordinator.pendingColumnJump == nil)
-        #expect(coordinator.focusedDataColumnIndex == 1)
-    }
-
-    /// A name resolves to the last of two same-named columns, so a parked jump keeps the index the
-    /// reader chose and lands on that one.
-    @Test("A parked jump on a duplicate name lands on the chosen column")
-    func pendingJumpKeepsTheChosenDuplicate() throws {
-        let coordinator = makeCoordinator(columns: ["id", "name", "name"], hiddenColumns: ["name"])
-        coordinator.pendingColumnJump = parked("name", dataIndex: 1)
-
-        reconcile(coordinator, hiddenColumns: [])
-        coordinator.consumePendingColumnJump(contentReplaced: false)
-
-        #expect(coordinator.pendingColumnJump == nil)
-        #expect(coordinator.focusedDataColumnIndex == 1)
-    }
-
-    /// A table tab refetches to show a column, and a key or sort column is fetched while hidden,
-    /// so the interim update that unhides it must not land the jump the refetch would then undo.
-    @Test("A table tab's parked jump waits for the refetched result")
-    func pendingJumpOnATableTabWaitsForTheResult() throws {
-        let coordinator = makeCoordinator(hiddenColumns: ["name"])
-        let pending = parked("name", dataIndex: 1, awaitsResultReplacement: true)
-        coordinator.pendingColumnJump = pending
-        reconcile(coordinator, hiddenColumns: [])
-
-        coordinator.consumePendingColumnJump(contentReplaced: false)
-        #expect(coordinator.pendingColumnJump == pending)
-        #expect(coordinator.focusedDataColumnIndex == nil)
-
-        coordinator.consumePendingColumnJump(contentReplaced: true)
-        #expect(coordinator.pendingColumnJump == nil)
-        #expect(coordinator.focusedDataColumnIndex == 1)
-    }
-
-    @Test("A new result that lacks the column drops the parked jump instead of arming it forever")
-    func replacementWithoutTheColumnDropsThePendingJump() throws {
-        let coordinator = makeCoordinator(hiddenColumns: ["name"])
-        coordinator.pendingColumnJump = parked("elsewhere")
-
-        coordinator.consumePendingColumnJump(contentReplaced: false)
-        #expect(coordinator.pendingColumnJump != nil)
-
-        coordinator.consumePendingColumnJump(contentReplaced: true)
-        #expect(coordinator.pendingColumnJump == nil)
-    }
-
-    @Test("A jump that lands supersedes a jump still parked")
-    func directJumpSupersedesThePendingJump() throws {
-        let coordinator = makeCoordinator(hiddenColumns: ["name"])
-        coordinator.pendingColumnJump = parked("name", dataIndex: 1)
-
-        #expect(coordinator.jumpToColumn(dataIndex: 2))
-
-        #expect(coordinator.pendingColumnJump == nil)
-        #expect(coordinator.focusedDataColumnIndex == 2)
-    }
-
-    @Test("A parked jump made against another table is dropped")
-    func pendingJumpForAnotherTableIsDropped() throws {
-        let coordinator = makeCoordinator(hiddenColumns: ["name"])
-        let otherTable = ColumnLayoutTableKey(
-            connectionId: UUID(),
-            databaseName: "db",
-            schemaName: nil,
-            tableName: "other"
-        )
-        coordinator.pendingColumnJump = parked("name", dataIndex: 1, tableKey: otherTable)
-        reconcile(coordinator, hiddenColumns: [])
-
-        coordinator.consumePendingColumnJump(contentReplaced: false)
-
-        #expect(coordinator.pendingColumnJump == nil)
-        #expect(coordinator.focusedDataColumnIndex == nil)
-    }
-
-    @Test("A jump with no rows still scrolls to the column without seeding a cursor")
-    func jumpWithoutRows() throws {
-        let coordinator = makeCoordinator(rowCount: 0)
-        let tableView = try #require(coordinator.tableView as? KeyHandlingTableView)
-
-        #expect(coordinator.jumpToColumn(dataIndex: 2))
-
-        #expect(tableView.selectedRow == -1)
-        #expect(coordinator.focusedDataColumnIndex == nil)
-    }
-
-    @Test("Releasing the grid drops a parked jump")
-    func releaseDropsPendingJump() {
-        let coordinator = makeCoordinator(hiddenColumns: ["name"])
-        coordinator.pendingColumnJump = parked("name", dataIndex: 1)
-
-        coordinator.releaseData()
-
-        #expect(coordinator.pendingColumnJump == nil)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorDisplayCacheTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorDisplayCacheTests.swift
deleted file mode 100644
index c76ab11c8a..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorDisplayCacheTests.swift
+++ /dev/null
@@ -1,153 +0,0 @@
-//
-//  TableViewCoordinatorDisplayCacheTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct TableViewCoordinatorDisplayCacheTests {
-    private func makeCoordinator(
-        tableRows: TableRows = TableRows(
-            rows: [Row(id: .existing(0), values: [.text("A")])],
-            columns: ["name"],
-            columnTypes: [.text(rawType: nil)]
-        ),
-        delegate: (any DataGridViewDelegate)? = nil
-    ) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: delegate,
-            layoutPersister: FakeDisplayCachePersister()
-        )
-        var captured = tableRows
-        coordinator.tableRowsProvider = { captured }
-        coordinator.tableRowsMutator = { mutation in mutation(&captured) }
-        coordinator.updateCache()
-        return coordinator
-    }
-
-    private func value(_ text: String) -> PluginCellValue { .text(text) }
-
-    @Test("Cache returns the stale value for a reused RowID until it is invalidated")
-    func invalidationClearsStaleContent() {
-        let coordinator = makeCoordinator()
-        let column = 0
-        let type: ColumnType = .text(rawType: nil)
-
-        let primed = coordinator.displayValue(forID: .existing(0), column: column, rawValue: value("A"), columnType: type)
-        #expect(primed == "A")
-
-        let stale = coordinator.displayValue(forID: .existing(0), column: column, rawValue: value("B"), columnType: type)
-        #expect(stale == "A")
-
-        coordinator.invalidateDisplayCache()
-
-        let fresh = coordinator.displayValue(forID: .existing(0), column: column, rawValue: value("B"), columnType: type)
-        #expect(fresh == "B")
-    }
-
-    @Test("Display format changes recompute cached binary values")
-    func displayFormatChangesRecomputeBinaryValues() {
-        let data = Data([
-            0xAF, 0x49, 0x45, 0x3B, 0x7F, 0x2F, 0xFB, 0x58,
-            0xFC, 0xD3, 0x2B, 0xD3, 0x99, 0x59, 0x9F, 0xA5,
-        ])
-        let type = ColumnType.blob(rawType: "BLOB")
-        let coordinator = makeCoordinator(tableRows: TableRows(
-            rows: [Row(id: .existing(0), values: [.bytes(data)])],
-            columns: ["id"],
-            columnTypes: [type]
-        ))
-
-        let raw = coordinator.displayValue(
-            forID: .existing(0), column: 0, rawValue: .bytes(data), columnType: type
-        )
-        #expect(raw == "0xAF49453B7F2FFB58FCD32BD399599FA5")
-
-        coordinator.updateDisplayFormats([.uuid])
-        let formatted = coordinator.displayValue(
-            forID: .existing(0), column: 0, rawValue: .bytes(data), columnType: type
-        )
-        #expect(formatted == "af49453b-7f2f-fb58-fcd3-2bd399599fa5")
-
-        coordinator.updateDisplayFormats([.raw])
-        let restored = coordinator.displayValue(
-            forID: .existing(0), column: 0, rawValue: .bytes(data), columnType: type
-        )
-        #expect(restored == "0xAF49453B7F2FFB58FCD32BD399599FA5")
-    }
-
-    @Test("Display format changes reload existing AppKit cells")
-    func displayFormatChangeReloadsTableView() {
-        let coordinator = makeCoordinator()
-        let tableView = DisplayFormatReloadTrackingTableView()
-        coordinator.tableView = tableView
-        let reloadCount = tableView.reloadCount
-
-        coordinator.reloadAfterDisplayFormatChange()
-
-        #expect(tableView.reloadCount == reloadCount + 1)
-    }
-
-    @Test("Display format changes notify inspector observers")
-    func displayFormatChangeNotifiesDelegate() {
-        let delegate = DisplayFormatTrackingDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-
-        coordinator.updateDisplayFormats([.uuid])
-
-        #expect(delegate.changeCount == 1)
-    }
-
-    @Test("Disabling smart detection does not discard a manual format")
-    func smartDetectionSettingKeepsResolvedFormats() {
-        let coordinator = makeCoordinator()
-        coordinator.tableView = NSTableView()
-        coordinator.updateDisplayFormats([.uuid])
-        var previous = DataGridSettings.default
-        previous.enableSmartValueDetection = true
-        var current = previous
-        current.enableSmartValueDetection = false
-
-        coordinator.applyDataGridSettingsChange(from: previous, to: current)
-
-        #expect(coordinator.columnDisplayFormats == [.uuid])
-    }
-}
-
-@MainActor
-private final class DisplayFormatReloadTrackingTableView: NSTableView {
-    private(set) var reloadCount = 0
-
-    override func reloadData() {
-        reloadCount += 1
-        super.reloadData()
-    }
-}
-
-@MainActor
-private final class DisplayFormatTrackingDelegate: DataGridViewDelegate {
-    private(set) var changeCount = 0
-
-    func dataGridDisplayFormatChanged() {
-        changeCount += 1
-    }
-}
-
-@MainActor
-private final class FakeDisplayCachePersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-
-    func clear(for key: ColumnLayoutTableKey) {}
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorDisplayStateTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorDisplayStateTests.swift
deleted file mode 100644
index 6bd3c4c183..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorDisplayStateTests.swift
+++ /dev/null
@@ -1,140 +0,0 @@
-//
-//  TableViewCoordinatorDisplayStateTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct TableViewCoordinatorDisplayStateTests {
-    private static let rows = TableRows(
-        rows: [Row(id: .existing(0), values: [.text("A")])],
-        columns: ["name"],
-        columnTypes: [.text(rawType: nil)]
-    )
-
-    /// The order `DataGridView.makeNSView` runs in. The two calls after the adopt are what used to
-    /// discard the text it had just been handed, because a fresh coordinator reports the first
-    /// schema and the first format list it sees as a change.
-    private func mount(
-        displayState: DataGridDisplayState? = nil,
-        displayFormats: [ValueDisplayFormat?] = []
-    ) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeDisplayStatePersister()
-        )
-        var rows = Self.rows
-        coordinator.tableRowsProvider = { rows }
-        coordinator.tableRowsMutator = { mutation in mutation(&rows) }
-        if let displayState {
-            coordinator.adoptDisplayState(displayState)
-        }
-        coordinator.syncDisplayFormats(displayFormats)
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        coordinator.updateCache()
-        return coordinator
-    }
-
-    private func text(_ coordinator: TableViewCoordinator, raw: String) -> String? {
-        coordinator.displayValue(
-            forID: .existing(0),
-            column: 0,
-            rawValue: .text(raw),
-            columnType: .text(rawType: nil)
-        )
-    }
-
-    @Test("A remount reuses the formatted text the previous grid produced")
-    func remountReusesFormattedText() {
-        let state = DataGridDisplayState()
-        let first = mount(displayState: state)
-        #expect(text(first, raw: "A") == "A")
-
-        let remounted = mount(displayState: state)
-        #expect(text(remounted, raw: "B") == "A")
-    }
-
-    @Test("A remount with a display format applied still reuses the formatted text")
-    func remountWithDisplayFormatsReusesFormattedText() {
-        let formats: [ValueDisplayFormat?] = [.raw]
-        let state = DataGridDisplayState()
-        let first = mount(displayState: state, displayFormats: formats)
-        #expect(text(first, raw: "A") == "A")
-
-        let remounted = mount(displayState: state, displayFormats: formats)
-        #expect(text(remounted, raw: "B") == "A")
-    }
-
-    @Test("A grid with no owner formats from scratch on every mount")
-    func unownedGridDoesNotShareText() {
-        let first = mount()
-        #expect(text(first, raw: "A") == "A")
-
-        let second = mount()
-        #expect(text(second, raw: "B") == "B")
-    }
-
-    @Test("Adopting a state takes over its viewport anchor")
-    func adoptingTakesOverTheViewportAnchor() {
-        let state = DataGridDisplayState()
-        state.firstVisibleRow = 3_200
-        #expect(mount(displayState: state).scrollAnchorRow == 3_200)
-    }
-
-    @Test("Restoring an anchor puts the row back at the top of a real scroll view")
-    func restoringAnAnchorScrollsTheGrid() {
-        let rowCount = 1_000
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeDisplayStatePersister()
-        )
-        let rows = TableRows.from(
-            queryRows: (0..<rowCount).map { [PluginCellValue.text("row \($0)")] },
-            columns: ["name"],
-            columnTypes: [.text(rawType: nil)]
-        )
-        coordinator.tableRowsProvider = { rows }
-
-        let tableView = NSTableView(frame: NSRect(x: 0, y: 0, width: 400, height: 400))
-        tableView.rowHeight = 24
-        tableView.addTableColumn(NSTableColumn(identifier: NSUserInterfaceItemIdentifier("name")))
-        tableView.dataSource = coordinator
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 400, height: 400))
-        scrollView.documentView = tableView
-        scrollView.layoutSubtreeIfNeeded()
-        coordinator.tableView = tableView
-        coordinator.updateCache()
-        tableView.reloadData()
-
-        let state = DataGridDisplayState()
-        state.firstVisibleRow = 500
-        coordinator.adoptDisplayState(state)
-        coordinator.restoreScrollAnchor()
-
-        #expect(scrollView.contentView.bounds.origin.y == tableView.rect(ofRow: 500).origin.y)
-        /// Consumed by the restore, so a later update over the same rows does not drag the user
-        /// back to where they were two switches ago.
-        #expect(coordinator.scrollAnchorRow == 0)
-    }
-}
-
-private final class FakeDisplayStatePersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-
-    func clear(for key: ColumnLayoutTableKey) {}
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorFindTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorFindTests.swift
deleted file mode 100644
index e41b0774eb..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorFindTests.swift
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-//  TableViewCoordinatorFindTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct TableViewCoordinatorFindTests {
-    /// Row 0 decodes under Text, row 1 does not and falls back to hex `0x89504E47`.
-    private func makeCoordinator(format: ValueDisplayFormat?) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeFindLayoutPersister()
-        )
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.bytes(Data("signup".utf8))]),
-            Row(id: .existing(1), values: [.bytes(Data([0x89, 0x50, 0x4E, 0x47]))]),
-        ]
-        var captured = TableRows(
-            rows: rows,
-            columns: ["payload"],
-            columnTypes: [.blob(rawType: "VARBINARY(255)")]
-        )
-        coordinator.tableRowsProvider = { captured }
-        coordinator.tableRowsMutator = { (mutation: (inout TableRows) -> Delta) in mutation(&captured) }
-        coordinator.updateCache()
-        coordinator.updateDisplayFormats([format])
-        return coordinator
-    }
-
-    @Test("a binary column showing text is searched on the text")
-    func binaryTextColumnIsSearched() {
-        let coordinator = makeCoordinator(format: .text)
-
-        let matches = coordinator.runFind(term: "signup")
-
-        #expect(matches.count == 1)
-        #expect(matches.first?.displayRow == 0)
-    }
-
-    @Test("a cell that fell back to hex is not searched on that hex")
-    func hexFallbackCellIsNotSearched() {
-        let coordinator = makeCoordinator(format: .text)
-
-        #expect(coordinator.runFind(term: "8950").isEmpty)
-        #expect(coordinator.runFind(term: "0x89504E47").isEmpty)
-    }
-
-    @Test("a binary column left on raw is not searched at all")
-    func rawBinaryColumnIsNotSearched() {
-        let coordinator = makeCoordinator(format: nil)
-
-        #expect(coordinator.runFind(term: "signup").isEmpty)
-        #expect(coordinator.runFind(term: "8950").isEmpty)
-    }
-}
-
-private final class FakeFindLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-
-    func clear(for key: ColumnLayoutTableKey) {}
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorHighlightTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorHighlightTests.swift
deleted file mode 100644
index cb2a47619e..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorHighlightTests.swift
+++ /dev/null
@@ -1,144 +0,0 @@
-//
-//  TableViewCoordinatorHighlightTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-private final class HighlightTestPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class StructureStateDelegate: DataGridViewDelegate {
-    func dataGridVisualState(forRow row: Int) -> RowVisualState? { .empty }
-}
-
-@MainActor
-private final class HighlightGrid {
-    var tableRows: TableRows
-    let coordinator: TableViewCoordinator
-
-    init(statuses: [String], delegate: (any DataGridViewDelegate)? = nil) {
-        let rows = ContiguousArray(statuses.enumerated().map { index, status in
-            Row(id: .existing(index), values: [.text("\(index)"), .text(status)])
-        })
-        tableRows = TableRows(
-            rows: rows,
-            columns: ["id", "status"],
-            columnTypes: [.integer(rawType: "INT"), .text(rawType: "VARCHAR")]
-        )
-        coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: delegate,
-            layoutPersister: HighlightTestPersister()
-        )
-        coordinator.tableRowsProvider = { [weak self] in self?.tableRows ?? TableRows() }
-        coordinator.tableRowsMutator = { [weak self] mutation in
-            guard let self else { return .none }
-            return mutation(&self.tableRows)
-        }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-    }
-
-    @discardableResult
-    func apply(_ rules: [HighlightRule]) -> Bool {
-        coordinator.syncHighlightRules(rules, tableRows: tableRows)
-    }
-
-    func rowColor(_ row: Int) -> HighlightColor? {
-        coordinator.visualState(for: row).highlight.rowColor
-    }
-}
-
-@MainActor
-struct TableViewCoordinatorHighlightTests {
-    private let paid = HighlightRule(columnName: "status", value: "paid", color: .green)
-
-    @Test("Only the rows a rule matches carry its highlight")
-    func matchingRowsCarryTheHighlight() {
-        let grid = HighlightGrid(statuses: ["paid", "pending", "paid"])
-        grid.apply([paid])
-
-        #expect(grid.rowColor(0) == .green)
-        #expect(grid.rowColor(1) == nil)
-        #expect(grid.rowColor(2) == .green)
-    }
-
-    @Test("Changing the rules reports a change and recolours rows already evaluated")
-    func changingRulesRecolours() {
-        let grid = HighlightGrid(statuses: ["paid"])
-        #expect(grid.apply([paid]))
-        #expect(grid.rowColor(0) == .green)
-
-        var recolored = paid
-        recolored.color = .red
-        #expect(grid.apply([recolored]))
-        #expect(grid.rowColor(0) == .red)
-        #expect(!grid.apply([recolored]))
-    }
-
-    @Test("An edit that flips a rule is reflected once the edit commits")
-    func editFlipsTheHighlight() {
-        let grid = HighlightGrid(statuses: ["pending"])
-        grid.apply([paid])
-        #expect(grid.rowColor(0) == nil)
-
-        grid.coordinator.commitTypedCellEdit(row: 0, columnIndex: 1, newValue: .text("paid"))
-
-        #expect(grid.tableRows.rows[0].values[1] == .text("paid"))
-        #expect(grid.rowColor(0) == .green)
-    }
-
-    @Test("New rows under the same positional ids are evaluated afresh once the cache is dropped")
-    func positionalIdsAreNotServedStaleHighlights() {
-        let grid = HighlightGrid(statuses: ["paid"])
-        grid.apply([paid])
-        #expect(grid.rowColor(0) == .green)
-
-        grid.tableRows.rows[0].values[1] = .text("pending")
-        grid.coordinator.invalidateDisplayCache()
-
-        #expect(grid.rowColor(0) == nil)
-    }
-
-    @Test("A fresh display state for a new page carries no highlights from the old one")
-    func freshDisplayStateStartsClean() {
-        let grid = HighlightGrid(statuses: ["paid"])
-        grid.apply([paid])
-        #expect(grid.rowColor(0) == .green)
-
-        grid.tableRows.rows[0].values[1] = .text("pending")
-        grid.coordinator.adoptDisplayState(DataGridDisplayState())
-        grid.apply([paid])
-
-        #expect(grid.rowColor(0) == nil)
-    }
-
-    @Test("A grid whose owner supplies its own row state is never highlighted")
-    func delegateStateSuppressesHighlights() {
-        let delegate = StructureStateDelegate()
-        let grid = HighlightGrid(statuses: ["paid"], delegate: delegate)
-        grid.apply([paid])
-
-        #expect(grid.rowColor(0) == nil)
-    }
-
-    @Test("The accessibility description names the rule that coloured the cell")
-    func accessibilityDescription() {
-        let grid = HighlightGrid(statuses: ["paid"])
-        grid.apply([paid])
-
-        #expect(grid.coordinator.highlightDescription(row: 0, columnIndex: 0) == "status = “paid”")
-    }
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorLayoutTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorLayoutTests.swift
deleted file mode 100644
index b0cae5e5a3..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorLayoutTests.swift
+++ /dev/null
@@ -1,1240 +0,0 @@
-//
-//  TableViewCoordinatorLayoutTests.swift
-//  TableProTests
-//
-
-import AppKit
-import Foundation
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class FakeColumnLayoutPersister: ColumnLayoutPersisting {
-    var stored: [String: ColumnLayoutState] = [:]
-
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? {
-        stored[key.tableName]
-    }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {
-        stored[key.tableName] = layout
-    }
-
-    func clear(for key: ColumnLayoutTableKey) {
-        stored.removeValue(forKey: key.tableName)
-    }
-}
-
-@MainActor
-struct TableViewCoordinatorLayoutTests {
-    private func makeCoordinator(
-        tabType: TabType?,
-        connectionId: UUID?,
-        tableName: String?,
-        persister: ColumnLayoutPersisting
-    ) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: persister
-        )
-        coordinator.tabType = tabType
-        coordinator.connectionId = connectionId
-        coordinator.tableName = tableName
-        return coordinator
-    }
-
-    private func nonEmptyLayout() -> ColumnLayoutState {
-        var layout = ColumnLayoutState()
-        layout.columnWidths = ["id": 60]
-        return layout
-    }
-
-    private func attachColumns(
-        _ widths: [String: CGFloat],
-        tableRows: TableRows,
-        to coordinator: TableViewCoordinator
-    ) -> [String: NSTableColumn] {
-        let tableView = NSTableView()
-        coordinator.tableView = tableView
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-
-        var result: [String: NSTableColumn] = [:]
-        for (index, name) in tableRows.columns.enumerated() {
-            let identifier = coordinator.columnIdentifier(for: index) ?? ColumnIdentitySchema.slotIdentifier(index)
-            let column = NSTableColumn(identifier: identifier)
-            column.width = widths[name] ?? 100
-            tableView.addTableColumn(column)
-            result[name] = column
-        }
-        coordinator.updateColumnPresentations(from: tableRows)
-        return result
-    }
-
-    @Test("Table tab returns persisted layout when present, ignoring binding")
-    func tableTabPrefersPersister() {
-        let persister = FakeColumnLayoutPersister()
-        let stored = nonEmptyLayout()
-        persister.stored["users"] = stored
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: persister
-        )
-
-        var binding = ColumnLayoutState()
-        binding.columnWidths = ["other": 999]
-
-        let resolved = coordinator.savedColumnLayout(binding: binding)
-        #expect(resolved?.columnWidths == ["id": 60])
-    }
-
-    @Test("Table tab falls back to binding when persister has nothing")
-    func tableTabFallsBackToBinding() {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        let resolved = coordinator.savedColumnLayout(binding: nonEmptyLayout())
-        #expect(resolved?.columnWidths == ["id": 60])
-    }
-
-    @Test("Table tab returns nil when both persister and binding are empty")
-    func tableTabBothEmptyReturnsNil() {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        #expect(coordinator.savedColumnLayout(binding: ColumnLayoutState()) == nil)
-    }
-
-    @Test("Query tab drops a stale saved column order so new columns keep their query position")
-    func queryTabDropsStaleColumnOrder() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("1"), .text("direct"), .text("EU")]],
-            columns: ["id", "business_model", "region"],
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: 3)
-        )
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        var binding = ColumnLayoutState()
-        binding.columnWidths = ["id": 60, "business_model": 120]
-        binding.columnOrder = ["id", "business_model"]
-
-        var expected = ColumnLayoutState()
-        expected.columnWidths = ["id": 60, "business_model": 120]
-
-        #expect(coordinator.savedColumnLayout(binding: binding) == expected)
-    }
-
-    /// The order is dropped because the columns moved under it, not because the grid has no table.
-    /// A re-run of the same query, and every update of the Structure grid, arrives with the same
-    /// column set, and the reorder the user made has to survive it.
-    @Test("Query tab keeps a column order saved for the same columns")
-    func queryTabKeepsMatchingColumnOrder() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("1"), .text("direct")]],
-            columns: ["id", "business_model"],
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: 2)
-        )
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        var binding = ColumnLayoutState()
-        binding.columnWidths = ["id": 60, "business_model": 120]
-        binding.columnOrder = ["business_model", "id"]
-
-        #expect(coordinator.savedColumnLayout(binding: binding) == binding)
-    }
-
-    /// A saved order names its columns, and `SELECT a.id, b.id` gives two of them the same name.
-    /// `ColumnIdentitySchema` resolves a duplicate to its last slot, so replaying such an order
-    /// silently swaps the pair.
-    @Test("Query tab drops a column order when two columns share a name")
-    func queryTabDropsColumnOrderForDuplicateNames() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("1"), .text("2")]],
-            columns: ["id", "id"],
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: 2)
-        )
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        var binding = ColumnLayoutState()
-        binding.columnWidths = ["id": 60]
-        binding.columnOrder = ["id", "id"]
-
-        var expected = ColumnLayoutState()
-        expected.columnWidths = ["id": 60]
-
-        #expect(coordinator.savedColumnLayout(binding: binding) == expected)
-    }
-
-    /// A reorder with no width change is the whole layout, and it used to fall through the
-    /// emptiness guard and come back as nil.
-    @Test("Query tab keeps an order-only layout")
-    func queryTabKeepsAnOrderOnlyLayout() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("1"), .text("direct")]],
-            columns: ["id", "business_model"],
-            columnTypes: Array(repeating: ColumnType.text(rawType: "TEXT"), count: 2)
-        )
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        var binding = ColumnLayoutState()
-        binding.columnOrder = ["business_model", "id"]
-
-        #expect(coordinator.savedColumnLayout(binding: binding) == binding)
-    }
-
-    @Test("Query tab keeps remembered widths when there is no saved order")
-    func queryTabKeepsWidths() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-
-        var expected = ColumnLayoutState()
-        expected.columnWidths = ["id": 60]
-
-        #expect(coordinator.savedColumnLayout(binding: nonEmptyLayout()) == expected)
-    }
-
-    @Test("Query tab returns nil when binding is empty")
-    func queryTabEmptyReturnsNil() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        #expect(coordinator.savedColumnLayout(binding: ColumnLayoutState()) == nil)
-    }
-
-    @Test("Table tab without connectionId or tableName falls back to binding")
-    func tableTabMissingIdentitySkipsPersister() {
-        let persister = FakeColumnLayoutPersister()
-        persister.stored["users"] = nonEmptyLayout()
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: nil,
-            tableName: nil,
-            persister: persister
-        )
-
-        var binding = ColumnLayoutState()
-        binding.columnWidths = ["fallback": 42]
-
-        let resolved = coordinator.savedColumnLayout(binding: binding)
-        #expect(resolved?.columnWidths == ["fallback": 42])
-    }
-
-    @Test("resolvedColumnLayout merges live widths on top of a saved layout")
-    func resolvedMergesLiveWidthsOntoSaved() {
-        let persister = FakeColumnLayoutPersister()
-        var saved = ColumnLayoutState()
-        saved.columnWidths = ["id": 60, "name": 100]
-        persister.stored["users"] = saved
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: persister
-        )
-
-        let resolved = coordinator.resolvedColumnLayout(
-            binding: ColumnLayoutState(),
-            liveWidths: ["name": 250]
-        )
-        #expect(resolved?.columnWidths == ["id": 60, "name": 250])
-    }
-
-    @Test("resolvedColumnLayout preserves an unpersisted user width")
-    func resolvedPreservesUnpersistedUserWidth() {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        #expect(
-            coordinator.resolvedColumnLayout(
-                binding: ColumnLayoutState(),
-                liveWidths: ["name": 250]
-            )?.columnWidths == ["name": 250]
-        )
-    }
-
-    @Test("Live widths are kept on a same-table reload but discarded on a table switch")
-    func liveWidthsGatedByTableIdentity() {
-        let connectionId = UUID()
-        let tableA = ColumnLayoutTableKey(connectionId: connectionId, databaseName: "db", schemaName: "public", tableName: "a")
-        let tableB = ColumnLayoutTableKey(connectionId: connectionId, databaseName: "db", schemaName: "public", tableName: "b")
-        let live: [String: CGFloat] = ["id": 120, "name": 240]
-
-        #expect(TableViewCoordinator.liveWidthsForSameTable(previous: tableA, current: tableA, liveWidths: live) == live)
-        #expect(TableViewCoordinator.liveWidthsForSameTable(previous: tableA, current: tableB, liveWidths: live).isEmpty)
-        #expect(TableViewCoordinator.liveWidthsForSameTable(previous: nil, current: tableA, liveWidths: live).isEmpty)
-        #expect(TableViewCoordinator.liveWidthsForSameTable(previous: nil, current: nil, liveWidths: live) == live)
-    }
-
-    @Test("Captured layouts contain only user-sized widths")
-    func captureContainsOnlyUserSizedWidths() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("1"), .text("Ada")]],
-            columns: ["id", "name"],
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
-        )
-        _ = attachColumns(["id": 75, "name": 140], tableRows: rows, to: coordinator)
-        var saved = ColumnLayoutState()
-        saved.columnWidths = ["id": 75]
-        coordinator.synchronizeUserSizedColumns(
-            with: saved,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-
-        let captured = try #require(coordinator.captureColumnLayout())
-
-        #expect(captured.columnWidths == ["id": 75])
-        #expect(captured.columnContentWidths == ["id": 75])
-        #expect(captured.columnOrder == ["id", "name"])
-    }
-
-    /// The width a column had is the width it gets back. Deriving it from the accessory instead
-    /// would resize the column across sessions in exactly the cases the accessory arrives late,
-    /// which is the whole problem this area exists to avoid.
-    @Test("A captured width round-trips unchanged while an accessory is showing")
-    func capturedWidthRoundTripsWithAccessory() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "events",
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("2026-08-17")]],
-            columns: ["created_at"],
-            columnTypes: [.date(rawType: "DATE")]
-        )
-        let columns = attachColumns(["created_at": 176], tableRows: rows, to: coordinator)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["created_at": 160]
-        coordinator.synchronizeUserSizedColumns(
-            with: stored,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-
-        let captured = try #require(coordinator.captureColumnLayout())
-        let resolved = try #require(coordinator.resolvedColumnLayout(binding: captured, liveWidths: [:]))
-
-        #expect(coordinator.columnPresentation(for: 0, in: rows).accessory == .chevron)
-        #expect(columns["created_at"]?.width == 176)
-        #expect(captured.columnWidths == ["created_at": 176])
-        #expect(captured.columnContentWidths == ["created_at": 176])
-        #expect(resolved.columnWidths == ["created_at": 176])
-    }
-
-    /// The drift this guards against: a width saved while the arrow was showing, restored on an
-    /// open where the arrow is not known yet. Re-deriving the width from the current accessory
-    /// state returned it 20pt narrower and the next save recorded the smaller number, so a column
-    /// shrank on every visit until the metadata happened to be ready in time.
-    @Test("A width saved with an accessory restores unchanged before the accessory is known")
-    func capturedWidthRoundTripsWithoutAccessory() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "nodes",
-            persister: FakeColumnLayoutPersister()
-        )
-        var withForeignKey = TableRows.from(
-            queryRows: [[.text("1")]],
-            columns: ["parent_id"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        _ = withForeignKey.updateDisplayMetadata(columnForeignKeys: [
-            "parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id"),
-        ])
-        let columns = attachColumns(["parent_id": 200], tableRows: withForeignKey, to: coordinator)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["parent_id": 200]
-        coordinator.synchronizeUserSizedColumns(
-            with: stored,
-            columns: withForeignKey.columns,
-            tableIdentityChanged: true
-        )
-
-        let captured = try #require(coordinator.captureColumnLayout())
-
-        let plain = TableRows.from(
-            queryRows: [[.text("1")]],
-            columns: ["parent_id"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        coordinator.tableRowsProvider = { plain }
-        coordinator.rebuildColumnMetadataCache(from: plain)
-        _ = coordinator.updateColumnPresentations(from: plain)
-        let restored = try #require(coordinator.resolvedColumnLayout(binding: captured, liveWidths: [:]))
-
-        #expect(columns["parent_id"]?.width == 200)
-        #expect(captured.columnWidths == ["parent_id": 200])
-        #expect(coordinator.columnPresentation(for: 0, in: plain).accessory == .none)
-        #expect(restored.columnWidths == ["parent_id": 200])
-    }
-
-    @Test("A content-only layout still counts as a saved layout")
-    func contentOnlyLayoutCountsAsSaved() throws {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("a"), .text("b"), .text("c")]],
-            columns: ["a", "b", "c"],
-            columnTypes: [
-                .date(rawType: "DATE"),
-                .date(rawType: "DATE"),
-                .date(rawType: "DATE"),
-            ]
-        )
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["a": 160, "b": 170]
-        stored.columnContentWidths = ["a": 150, "c": 180]
-
-        #expect(coordinator.savedColumnLayout(binding: stored)?.columnWidths == ["a": 160, "b": 170])
-
-        var contentOnly = ColumnLayoutState()
-        contentOnly.columnContentWidths = ["c": 180]
-        #expect(coordinator.savedColumnLayout(binding: contentOnly) != nil)
-    }
-
-    @Test("Duplicate column names round-trip at their own width without growth")
-    func duplicateNamesRoundTripWithoutGrowth() throws {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("value"), .text("2026-08-17")]],
-            columns: ["result", "result"],
-            columnTypes: [.text(rawType: "TEXT"), .date(rawType: "DATE")]
-        )
-        _ = attachColumns(["result": 176], tableRows: rows, to: coordinator)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["result": 160]
-        coordinator.synchronizeUserSizedColumns(
-            with: stored,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-
-        let captured = try #require(coordinator.captureColumnLayout())
-        let restored = try #require(coordinator.resolvedColumnLayout(binding: captured, liveWidths: [:]))
-
-        #expect(coordinator.savedColumnLayout(binding: stored)?.columnWidths == ["result": 160])
-        #expect(captured.columnWidths == ["result": 176])
-        #expect(captured.columnContentWidths == ["result": 176])
-        #expect(restored.columnWidths == ["result": 176])
-    }
-
-    @Test("Duplicate slots with different accessories still round-trip at one width")
-    func mixedDuplicateAccessoriesRoundTrip() throws {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        var rows = TableRows.from(
-            queryRows: [[.text("1"), .text("2")]],
-            columns: ["parent_id", "parent_id"],
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
-        )
-        _ = rows.updateDisplayMetadata(columnForeignKeys: [
-            "parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id"),
-        ])
-        coordinator.dropdownColumns = [0]
-        _ = attachColumns(["parent_id": 180], tableRows: rows, to: coordinator)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["parent_id": 160]
-        coordinator.synchronizeUserSizedColumns(
-            with: stored,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-
-        let captured = try #require(coordinator.captureColumnLayout())
-        let restored = try #require(coordinator.resolvedColumnLayout(binding: captured, liveWidths: [:]))
-
-        #expect(coordinator.columnPresentation(for: 0, in: rows).accessory == .chevron)
-        #expect(coordinator.columnPresentation(for: 1, in: rows).accessory == .foreignKey)
-        #expect(captured.columnWidths == ["parent_id": 180])
-        #expect(captured.columnContentWidths == ["parent_id": 180])
-        #expect(restored.columnWidths == ["parent_id": 180])
-    }
-
-    @Test("Untouched automatic widths stay out of captured layouts")
-    func automaticWidthsStayOutOfCapturedLayouts() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        _ = attachColumns(["name": 140], tableRows: rows, to: coordinator)
-        coordinator.synchronizeUserSizedColumns(
-            with: nil,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-
-        let captured = try #require(coordinator.captureColumnLayout())
-
-        #expect(captured.columnWidths.isEmpty)
-        #expect(captured.columnOrder == ["name"])
-    }
-
-    @Test("A resize notification takes ownership unless the width change is automatic")
-    func resizeNotificationTakesOwnership() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        defer { coordinator.layoutPersistTask?.cancel() }
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let columns = attachColumns(["name": 140], tableRows: rows, to: coordinator)
-        let column = try #require(columns["name"])
-        let notification = Notification(
-            name: NSTableView.columnDidResizeNotification,
-            object: coordinator.tableView,
-            userInfo: ["NSTableColumn": column, "NSOldWidth": CGFloat(100)]
-        )
-
-        coordinator.isRebuildingColumns = true
-        coordinator.tableViewColumnDidResize(notification)
-        #expect(coordinator.userSizedColumnNames.isEmpty)
-
-        coordinator.isRebuildingColumns = false
-        coordinator.tableViewColumnDidResize(notification)
-        #expect(coordinator.userSizedColumnNames == ["name"])
-    }
-
-    @Test("A row-number resize never creates or persists a user layout")
-    func rowNumberResizeIsIgnored() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        _ = attachColumns(["name": 140], tableRows: rows, to: coordinator)
-        let tableView = try #require(coordinator.tableView)
-        let rowNumberColumn = DataGridView.makeRowNumberColumn()
-        tableView.addTableColumn(rowNumberColumn)
-        let notification = Notification(
-            name: NSTableView.columnDidResizeNotification,
-            object: tableView,
-            userInfo: ["NSTableColumn": rowNumberColumn, "NSOldWidth": CGFloat(40)]
-        )
-
-        coordinator.tableViewColumnDidResize(notification)
-
-        #expect(coordinator.userSizedColumnNames.isEmpty)
-        #expect(coordinator.pendingColumnLayoutPersistence == nil)
-        #expect(coordinator.layoutPersistTask == nil)
-    }
-
-    @Test("Switching tables flushes a pending resize to the outgoing table")
-    func tableSwitchFlushesOutgoingResize() throws {
-        let persister = FakeColumnLayoutPersister()
-        let connectionId = UUID()
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: connectionId,
-            tableName: "users",
-            persister: persister
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let columns = attachColumns(["name": 180], tableRows: rows, to: coordinator)
-        let column = try #require(columns["name"])
-        #expect(coordinator.markColumnWidthUserSized(column))
-        coordinator.scheduleLayoutPersist()
-
-        var nextConfiguration = DataGridConfiguration()
-        nextConfiguration.connectionId = connectionId
-        nextConfiguration.databaseName = "db"
-        nextConfiguration.tableName = "projects"
-        nextConfiguration.tabType = .table
-        coordinator.apply(configuration: nextConfiguration, isEditable: true)
-
-        #expect(persister.stored["users"]?.columnWidths == ["name": 180])
-        #expect(persister.stored["users"]?.columnContentWidths == ["name": 180])
-        #expect(persister.stored["projects"] == nil)
-        #expect(coordinator.pendingColumnLayoutPersistence == nil)
-        #expect(coordinator.layoutPersistTask == nil)
-    }
-
-    /// The foreign key arrow arrives with the table's metadata, one round trip after the rows are
-    /// already on screen. Widening the column then moves text the user is reading, so the arrow
-    /// takes its space from inside the cell instead and the column keeps the width it was given.
-    @Test("A late accessory never resizes the column it appears in")
-    func lateAccessoryNeverResizesItsColumn() throws {
-        let persister = FakeColumnLayoutPersister()
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "nodes",
-            persister: persister
-        )
-        var rows = TableRows.from(
-            queryRows: [[.text("1")]],
-            columns: ["parent_id"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let columns = attachColumns(["parent_id": 160], tableRows: rows, to: coordinator)
-        coordinator.tableRowsProvider = { rows }
-        let column = try #require(columns["parent_id"])
-        #expect(coordinator.markColumnWidthUserSized(column))
-        coordinator.scheduleLayoutPersist()
-        #expect(coordinator.pendingColumnLayoutPersistence?.layout.columnWidths == ["parent_id": 160])
-        #expect(coordinator.pendingColumnLayoutPersistence?.layout.columnContentWidths == ["parent_id": 160])
-        _ = rows.updateDisplayMetadata(columnForeignKeys: [
-            "parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id"),
-        ])
-
-        coordinator.refreshCellPresentations()
-
-        #expect(column.width == 160)
-        #expect(coordinator.pendingColumnLayoutPersistence?.layout.columnWidths == ["parent_id": 160])
-        #expect(coordinator.pendingColumnLayoutPersistence?.layout.columnContentWidths == ["parent_id": 160])
-
-        coordinator.flushPendingColumnLayoutPersistence()
-
-        #expect(persister.stored["nodes"]?.columnWidths == ["parent_id": 160])
-    }
-
-    /// Losing an accessory is the same rule read backwards: the freed space goes to the text inside
-    /// the cell, not back to the window, so the column the user sized keeps the width they gave it.
-    @Test("A column that loses its accessory keeps its width")
-    func losingAnAccessoryKeepsColumnWidth() throws {
-        let persister = FakeColumnLayoutPersister()
-        let connectionId = UUID()
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: connectionId,
-            tableName: "events",
-            persister: persister
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("2026-08-17")]],
-            columns: ["created_at"],
-            columnTypes: [.date(rawType: "DATE")]
-        )
-        let columns = attachColumns(["created_at": 176], tableRows: rows, to: coordinator)
-        coordinator.tableRowsProvider = { rows }
-        let column = try #require(columns["created_at"])
-        #expect(coordinator.markColumnWidthUserSized(column))
-        coordinator.scheduleLayoutPersist()
-
-        var configuration = DataGridConfiguration()
-        configuration.connectionId = connectionId
-        configuration.tableName = "events"
-        configuration.tabType = .table
-        coordinator.apply(configuration: configuration, isEditable: false)
-        let changes = coordinator.updateColumnPresentations(from: rows)
-        let reconciled = coordinator.liveWidthsForReconciliation(["created_at": column.width])
-
-        #expect(!changes.isEmpty)
-        #expect(reconciled == ["created_at": 176])
-        #expect(column.width == 176)
-
-        coordinator.flushPendingColumnLayoutPersistence()
-
-        #expect(persister.stored["events"]?.columnWidths == ["created_at": 176])
-        #expect(persister.stored["events"]?.columnContentWidths == ["created_at": 176])
-    }
-
-    @Test("A query-grid presentation change leaves the pending layout snapshot alone")
-    func queryPresentationChangeLeavesPendingLayoutAlone() throws {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let plainRows = TableRows.from(
-            queryRows: [[.text("value")]],
-            columns: ["result"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let dateRows = TableRows.from(
-            queryRows: [[.text("2026-08-17")]],
-            columns: ["result"],
-            columnTypes: [.date(rawType: "DATE")]
-        )
-        let columns = attachColumns(["result": 160], tableRows: plainRows, to: coordinator)
-        coordinator.tableRowsProvider = { plainRows }
-        let column = try #require(columns["result"])
-        #expect(coordinator.markColumnWidthUserSized(column))
-        var persistedLayout: ColumnLayoutState?
-        coordinator.onColumnLayoutDidChange = { persistedLayout = $0 }
-        coordinator.scheduleLayoutPersist()
-
-        coordinator.rebuildColumnMetadataCache(from: dateRows)
-        let changes = coordinator.updateColumnPresentations(from: dateRows)
-        coordinator.tableRowsProvider = { dateRows }
-
-        #expect(!changes.isEmpty)
-        #expect(column.width == 160)
-        #expect(coordinator.pendingColumnLayoutPersistence?.layout.columnWidths == ["result": 160])
-        #expect(coordinator.pendingColumnLayoutPersistence?.layout.columnContentWidths == ["result": 160])
-
-        coordinator.flushPendingColumnLayoutPersistence()
-
-        #expect(persistedLayout?.columnWidths == ["result": 160])
-    }
-
-    @Test("Divider fit takes ownership even when AppKit does not change the width")
-    func dividerFitTakesOwnership() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        defer { coordinator.layoutPersistTask?.cancel() }
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        _ = attachColumns(["name": 100], tableRows: rows, to: coordinator)
-        coordinator.synchronizeUserSizedColumns(
-            with: nil,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-        let tableView = try #require(coordinator.tableView)
-
-        _ = coordinator.tableView(tableView, sizeToFitWidthOfColumn: 0)
-
-        #expect(coordinator.userSizedColumnNames == ["name"])
-    }
-
-    @Test("Divider fit forwards each column's resolved action footprint")
-    func dividerFitUsesResolvedAccessory() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "events",
-            persister: FakeColumnLayoutPersister()
-        )
-        defer { coordinator.resetColumnWidthOwnership() }
-        let value = String(repeating: "M", count: 20)
-        let rows = TableRows.from(
-            queryRows: [[.text(value), .text(value), .text(value)]],
-            columns: ["plain", "created_at", "parent_id"],
-            columnTypes: [
-                .text(rawType: "TEXT"),
-                .date(rawType: "DATE"),
-                .text(rawType: "TEXT"),
-            ],
-            columnForeignKeys: [
-                "parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id"),
-            ],
-            foreignKeysFetched: true
-        )
-        _ = attachColumns([:], tableRows: rows, to: coordinator)
-        let tableView = try #require(coordinator.tableView)
-
-        let plain = coordinator.tableView(tableView, sizeToFitWidthOfColumn: 0)
-        let date = coordinator.tableView(tableView, sizeToFitWidthOfColumn: 1)
-        let foreignKey = coordinator.tableView(tableView, sizeToFitWidthOfColumn: 2)
-
-        #expect(date == plain + 16)
-        #expect(foreignKey == plain + 20)
-    }
-
-    @Test("Reset returns saved columns to automatic ownership")
-    func resetReturnsColumnsToAutomaticOwnership() {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        var saved = ColumnLayoutState()
-        saved.columnWidths = ["name": 240]
-        coordinator.synchronizeUserSizedColumns(
-            with: saved,
-            columns: ["name"],
-            tableIdentityChanged: true
-        )
-
-        coordinator.resetColumnWidthOwnership()
-
-        #expect(coordinator.userSizedColumnNames.isEmpty)
-    }
-
-    @Test("Reconciliation preserves live widths, presentation change or not")
-    func reconciliationPreservesLiveWidths() {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        var saved = ColumnLayoutState()
-        saved.columnWidths = ["id": 75]
-        coordinator.synchronizeUserSizedColumns(
-            with: saved,
-            columns: ["id", "name"],
-            tableIdentityChanged: true
-        )
-        let liveWidths: [String: CGFloat] = ["id": 75, "name": 140]
-
-        let stable = coordinator.liveWidthsForReconciliation(liveWidths)
-        let afterPresentationChange = coordinator.liveWidthsForReconciliation(liveWidths)
-
-        #expect(stable == liveWidths)
-        #expect(afterPresentationChange == liveWidths)
-    }
-
-    @Test("Reordering columns does not invent accessory width changes")
-    func reorderedColumnsKeepPresentationIdentity() {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "events",
-            persister: FakeColumnLayoutPersister()
-        )
-        let original = TableRows.from(
-            queryRows: [[.text("1"), .text("2026-08-17")]],
-            columns: ["id", "created_at"],
-            columnTypes: [.text(rawType: "TEXT"), .date(rawType: "DATE")]
-        )
-        let reordered = TableRows.from(
-            queryRows: [[.text("2026-08-17"), .text("1")]],
-            columns: ["created_at", "id"],
-            columnTypes: [.date(rawType: "DATE"), .text(rawType: "TEXT")]
-        )
-        coordinator.rebuildColumnMetadataCache(from: original)
-        _ = coordinator.updateColumnPresentations(from: original)
-        coordinator.rebuildColumnMetadataCache(from: reordered)
-
-        let changes = coordinator.updateColumnPresentations(from: reordered)
-
-        #expect(changes.isEmpty)
-    }
-
-    @Test("Duplicate presentation transitions adjust a shared live width once")
-    func duplicatePresentationTransitionAdjustsWidthOnce() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        var rows = TableRows.from(
-            queryRows: [[.text("open"), .text("closed")]],
-            columns: ["status", "status"],
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
-        )
-        coordinator.rebuildColumnMetadataCache(from: rows)
-        _ = coordinator.updateColumnPresentations(from: rows)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["status": 160]
-        coordinator.synchronizeUserSizedColumns(
-            with: stored,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-        _ = rows.updateDisplayMetadata(columnEnumValues: ["status": ["open", "closed"]])
-        coordinator.rebuildColumnMetadataCache(from: rows)
-
-        let changes = coordinator.updateColumnPresentations(from: rows)
-        let reconciled = coordinator.liveWidthsForReconciliation(["status": 160])
-
-        #expect(!changes.isEmpty)
-        #expect(reconciled == ["status": 160])
-        #expect(coordinator.pendingColumnLayoutPersistence == nil)
-    }
-
-    @Test("A duplicate slot change does not resize while the shared maximum is unchanged")
-    func duplicateSlotChangeKeepsSharedMaximumWidth() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let original = TableRows.from(
-            queryRows: [[.text("2026-08-17"), .text("2026-08-18")]],
-            columns: ["date", "date"],
-            columnTypes: [.date(rawType: "DATE"), .date(rawType: "DATE")]
-        )
-        let changed = TableRows.from(
-            queryRows: [[.text("plain"), .text("2026-08-18")]],
-            columns: ["date", "date"],
-            columnTypes: [.text(rawType: "TEXT"), .date(rawType: "DATE")]
-        )
-        coordinator.rebuildColumnMetadataCache(from: original)
-        _ = coordinator.updateColumnPresentations(from: original)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["date": 176]
-        stored.columnContentWidths = ["date": 160]
-        coordinator.synchronizeUserSizedColumns(
-            with: stored,
-            columns: original.columns,
-            tableIdentityChanged: true
-        )
-        coordinator.rebuildColumnMetadataCache(from: changed)
-
-        let changes = coordinator.updateColumnPresentations(from: changed)
-        let reconciled = coordinator.liveWidthsForReconciliation(["date": 176])
-
-        #expect(changes.indices == IndexSet(integer: 0))
-        #expect(reconciled == ["date": 176])
-    }
-
-    @Test("Adding and removing a max-reservation duplicate adjusts the group once")
-    func duplicateMaximumReservationAdditionAndRemoval() {
-        let coordinator = makeCoordinator(
-            tabType: .query,
-            connectionId: nil,
-            tableName: nil,
-            persister: FakeColumnLayoutPersister()
-        )
-        let plain = TableRows.from(
-            queryRows: [[.text("plain")]],
-            columns: ["value"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let withDateDuplicate = TableRows.from(
-            queryRows: [[.text("plain"), .text("2026-08-17")]],
-            columns: ["value", "value"],
-            columnTypes: [.text(rawType: "TEXT"), .date(rawType: "DATE")]
-        )
-        coordinator.rebuildColumnMetadataCache(from: plain)
-        _ = coordinator.updateColumnPresentations(from: plain)
-        var stored = ColumnLayoutState()
-        stored.columnWidths = ["value": 160]
-        stored.columnContentWidths = ["value": 160]
-        coordinator.synchronizeUserSizedColumns(
-            with: stored,
-            columns: plain.columns,
-            tableIdentityChanged: true
-        )
-
-        coordinator.rebuildColumnMetadataCache(from: withDateDuplicate)
-        let added = coordinator.updateColumnPresentations(from: withDateDuplicate)
-        let afterAdding = coordinator.liveWidthsForReconciliation(["value": 160])
-
-        coordinator.rebuildColumnMetadataCache(from: plain)
-        let removed = coordinator.updateColumnPresentations(from: plain)
-        let afterRemoving = coordinator.liveWidthsForReconciliation(afterAdding)
-
-        #expect(!added.isEmpty)
-        #expect(afterAdding == ["value": 160])
-        #expect(removed.indices.isEmpty)
-        #expect(afterRemoving == ["value": 160])
-    }
-
-    @Test("Reset invalidates every automatic live width once")
-    func resetInvalidatesAutomaticLiveWidthsOnce() {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: FakeColumnLayoutPersister()
-        )
-        let liveWidths: [String: CGFloat] = ["id": 75, "name": 140]
-
-        coordinator.resetColumnWidthOwnership()
-        let afterReset = coordinator.liveWidthsForReconciliation(liveWidths)
-        let nextUpdate = coordinator.liveWidthsForReconciliation(liveWidths)
-
-        #expect(afterReset.isEmpty)
-        #expect(nextUpdate == liveWidths)
-    }
-
-    /// A dropped table's saved layout is cleared by the adoption, and only then does its tab close.
-    /// A flush on that teardown would write the layout straight back over the clear.
-    @Test("Discarding a pending width write persists nothing")
-    func discardDropsPendingWidthWrite() throws {
-        let persister = FakeColumnLayoutPersister()
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: persister
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let columns = attachColumns(["name": 180], tableRows: rows, to: coordinator)
-        let column = try #require(columns["name"])
-        #expect(coordinator.markColumnWidthUserSized(column))
-        coordinator.scheduleLayoutPersist()
-        #expect(coordinator.pendingColumnLayoutPersistence != nil)
-
-        coordinator.discardPendingColumnLayoutPersistence()
-        coordinator.flushPendingColumnLayoutPersistence()
-
-        #expect(persister.stored["users"] == nil)
-        #expect(coordinator.pendingColumnLayoutPersistence == nil)
-        #expect(coordinator.layoutPersistTask == nil)
-    }
-
-    @Test("Reset cancels a pending width write")
-    func resetCancelsPendingWidthWrite() throws {
-        let persister = FakeColumnLayoutPersister()
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "users",
-            persister: persister
-        )
-        let rows = TableRows.from(
-            queryRows: [[.text("Ada")]],
-            columns: ["name"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let columns = attachColumns(["name": 180], tableRows: rows, to: coordinator)
-        let column = try #require(columns["name"])
-        #expect(coordinator.markColumnWidthUserSized(column))
-        coordinator.scheduleLayoutPersist()
-
-        coordinator.resetColumnWidthOwnership()
-        coordinator.flushPendingColumnLayoutPersistence()
-
-        #expect(persister.stored["users"] == nil)
-        #expect(coordinator.userSizedColumnNames.isEmpty)
-        #expect(coordinator.pendingColumnLayoutPersistence == nil)
-        #expect(coordinator.layoutPersistTask == nil)
-    }
-
-    /// Both ownership kinds, one rule. An automatic column is sized from its content when the
-    /// column is built and a user-sized one is whatever the user dragged it to; the arrow arriving
-    /// afterwards re-opens neither decision.
-    @Test("Late accessory metadata widens the automatic column and leaves the user-sized one alone")
-    func lateAccessoryMetadataWidensAutomaticColumnOnly() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "nodes",
-            persister: FakeColumnLayoutPersister()
-        )
-        let value = String(repeating: "M", count: 20)
-        var rows = TableRows.from(
-            queryRows: [[.text(value), .text(value)]],
-            columns: ["id", "parent_id"],
-            columnTypes: [.text(rawType: "TEXT"), .text(rawType: "TEXT")]
-        )
-        coordinator.tableRowsProvider = { rows }
-        let columns = attachColumns(["id": 75, "parent_id": 100], tableRows: rows, to: coordinator)
-        coordinator.tableRowsProvider = { rows }
-        var saved = ColumnLayoutState()
-        saved.columnWidths = ["id": 75]
-        coordinator.synchronizeUserSizedColumns(
-            with: saved,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-        _ = rows.updateDisplayMetadata(columnForeignKeys: [
-            "parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id"),
-        ])
-
-        coordinator.refreshCellPresentations()
-
-        let idColumn = try #require(columns["id"])
-        let parentColumn = try #require(columns["parent_id"])
-
-        #expect(idColumn.width == 75)
-        #expect(coordinator.userSizedColumnNames == ["id"])
-        #expect(coordinator.columnPresentation(for: 1, in: rows).accessory == .foreignKey)
-        #expect(parentColumn.width > 100)
-        #expect(
-            DataGridCellAccessory.foreignKey.availableTextWidth(
-                in: NSRect(x: 0, y: 0, width: parentColumn.width, height: 24)
-            ) >= CGFloat(value.count) * ThemeEngine.shared.dataGridFonts.monoCharWidth
-        )
-
-        let widenedWidth = parentColumn.width
-        _ = rows.updateDisplayMetadata(columnForeignKeys: [:])
-        coordinator.refreshCellPresentations()
-
-        #expect(idColumn.width == 75)
-        #expect(parentColumn.width == widenedWidth)
-    }
-
-    @Test("Late enum metadata widens the automatic column it appears in")
-    func lateEnumMetadataWidensItsColumn() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "tasks",
-            persister: FakeColumnLayoutPersister()
-        )
-        let value = String(repeating: "M", count: 20)
-        var rows = TableRows.from(
-            queryRows: [[.text(value)]],
-            columns: ["status"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let columns = attachColumns(["status": 100], tableRows: rows, to: coordinator)
-        coordinator.tableRowsProvider = { rows }
-        coordinator.synchronizeUserSizedColumns(
-            with: nil,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-        _ = rows.updateDisplayMetadata(columnEnumValues: ["status": ["open", "closed"]])
-
-        coordinator.refreshCellPresentations()
-
-        let column = try #require(columns["status"])
-
-        #expect(coordinator.columnPresentation(for: 0, in: rows).kind == .dropdown)
-        #expect(column.width > 100)
-        #expect(
-            DataGridCellAccessory.chevron.availableTextWidth(
-                in: NSRect(x: 0, y: 0, width: column.width, height: 24)
-            ) >= CGFloat(value.count) * ThemeEngine.shared.dataGridFonts.monoCharWidth
-        )
-
-        let widenedWidth = column.width
-        _ = rows.updateDisplayMetadata(columnEnumValues: [:])
-        coordinator.refreshCellPresentations()
-
-        #expect(column.width == widenedWidth)
-        #expect(coordinator.columnPresentation(for: 0, in: rows).kind == .text)
-    }
-
-    @Test("Late metadata waits for an active cell overlay before repainting")
-    func lateMetadataWaitsForActiveOverlay() throws {
-        let coordinator = makeCoordinator(
-            tabType: .table,
-            connectionId: UUID(),
-            tableName: "nodes",
-            persister: FakeColumnLayoutPersister()
-        )
-        let value = String(repeating: "M", count: 20)
-        var rows = TableRows.from(
-            queryRows: [[.text(value)]],
-            columns: ["parent_id"],
-            columnTypes: [.text(rawType: "TEXT")]
-        )
-        let columns = attachColumns(["parent_id": 100], tableRows: rows, to: coordinator)
-        coordinator.tableRowsProvider = { rows }
-        coordinator.synchronizeUserSizedColumns(
-            with: nil,
-            columns: rows.columns,
-            tableIdentityChanged: true
-        )
-        let tableView = try #require(coordinator.tableView)
-        let scrollView = NSScrollView()
-        scrollView.documentView = tableView
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        coordinator.updateCache()
-        tableView.reloadData()
-        let column = try #require(columns["parent_id"])
-        let originalWidth = column.width
-        let editor = CellOverlayEditor()
-        editor.onRemove = { [weak coordinator] in
-            coordinator?.flushPendingCellPresentationRefresh()
-        }
-        coordinator.overlayEditor = editor
-        editor.install(
-            in: tableView,
-            row: 0,
-            column: 0,
-            columnIndex: 0,
-            container: CellOverlayContainerView(frame: NSRect(x: 0, y: 0, width: 100, height: 24))
-        )
-        _ = rows.updateDisplayMetadata(columnForeignKeys: [
-            "parent_id": TestFixtures.makeForeignKeyInfo(column: "parent_id"),
-        ])
-
-        coordinator.refreshCellPresentations()
-
-        #expect(editor.isActive)
-        #expect(coordinator.pendingCellPresentationRefresh)
-        #expect(column.width == originalWidth)
-
-        editor.removeOverlay()
-
-        #expect(!editor.isActive)
-        #expect(!coordinator.pendingCellPresentationRefresh)
-        #expect(column.width > originalWidth)
-        #expect(coordinator.columnPresentation(for: 0, in: rows).accessory == .foreignKey)
-        #expect(coordinator.userSizedColumnNames.isEmpty)
-        withExtendedLifetime(scrollView) {}
-    }
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorPopoverDismissalTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorPopoverDismissalTests.swift
deleted file mode 100644
index 610cfa4657..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorPopoverDismissalTests.swift
+++ /dev/null
@@ -1,161 +0,0 @@
-//
-//  TableViewCoordinatorPopoverDismissalTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-/// A cell editor holds the display row it was opened from, and a display row is a position rather
-/// than an identity. Replacing the rows moves that record elsewhere, so an editor left open across
-/// the replacement commits its edit onto whichever record now sits at the position. That is the
-/// `Selection indices are display positions` invariant, and the answer is to close the editor.
-@MainActor
-struct TableViewCoordinatorPopoverDismissalTests {
-    private func makeCoordinator() -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakePopoverDismissalPersister()
-        )
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-            Row(id: .existing(1), values: [.text("b")]),
-        ]
-        var captured = TableRows(
-            rows: rows,
-            columns: ["name"],
-            columnTypes: [.text(rawType: nil)]
-        )
-        coordinator.tableRowsProvider = { captured }
-        coordinator.tableRowsMutator = { mutation in mutation(&captured) }
-        coordinator.updateCache()
-        return coordinator
-    }
-
-    @Test("Replacing the rows closes an open cell editor")
-    func fullReplaceClosesCellEditor() {
-        let tableView = NSTableView()
-        let coordinator = makeCoordinator()
-        coordinator.tableView = tableView
-        let editor = CloseCountingPopover()
-        coordinator.activeCellEditorPopover = editor
-
-        coordinator.applyFullReplace()
-
-        #expect(coordinator.activeCellEditorPopover == nil)
-        #expect(editor.closeCount == 1)
-    }
-
-    @Test("Replacing the rows closes an open column value filter")
-    func fullReplaceClosesValueFilter() {
-        let tableView = NSTableView()
-        let coordinator = makeCoordinator()
-        coordinator.tableView = tableView
-        let filter = CloseCountingPopover()
-        coordinator.activeValueFilterPopover = filter
-
-        coordinator.applyFullReplace()
-
-        #expect(coordinator.activeValueFilterPopover == nil)
-        #expect(filter.closeCount == 1)
-    }
-
-    /// A coordinator detached from its table view still has to drop these, which is why the
-    /// dismissal runs before the `tableView` guard rather than after it.
-    @Test("Replacing the rows closes editors even with no table view attached")
-    func fullReplaceClosesEditorsWithoutATableView() {
-        let coordinator = makeCoordinator()
-        let editor = CloseCountingPopover()
-        coordinator.activeCellEditorPopover = editor
-
-        coordinator.applyFullReplace()
-
-        #expect(coordinator.activeCellEditorPopover == nil)
-        #expect(editor.closeCount == 1)
-    }
-
-    /// A popped-out JSON editor is a window, so it survives every popover dismissal while still
-    /// committing through the display row it was opened from.
-    @Test("Replacing the rows closes a popped-out editor window")
-    func fullReplaceClosesPoppedOutEditor() {
-        let coordinator = makeCoordinator()
-        let popOut = JSONViewerWindowController()
-        coordinator.activePoppedOutEditor = popOut
-
-        coordinator.applyFullReplace()
-
-        #expect(coordinator.activePoppedOutEditor == nil)
-    }
-
-    /// Opening a different cell's editor must not close a window the user deliberately detached:
-    /// only a replaced row set invalidates it.
-    @Test("Opening another cell editor leaves a popped-out window alone")
-    func openingAnotherEditorKeepsThePoppedOutWindow() {
-        let coordinator = makeCoordinator()
-        let popOut = JSONViewerWindowController()
-        coordinator.activePoppedOutEditor = popOut
-
-        coordinator.dismissActiveCellEditorPopover()
-
-        #expect(coordinator.activePoppedOutEditor === popOut)
-    }
-
-    /// The array editor is `.applicationDefined`, so nothing closes it on its own. Forgetting the
-    /// reference when a second editor opens would strand it on screen with no way to dismiss it.
-    ///
-    /// `isShown` cannot answer this: it is false for a popover that was never presented, so an
-    /// assertion on it passes whether or not anything closed the first editor. Counting the `close`
-    /// calls is what actually fails when the dismissal is removed.
-    @Test("Opening a second cell editor closes the first instead of forgetting it")
-    func openingASecondEditorClosesTheFirst() {
-        let coordinator = makeCoordinator()
-        let first = CloseCountingPopover()
-        first.behavior = .applicationDefined
-        let second = CloseCountingPopover()
-
-        coordinator.dismissActiveCellEditorPopover()
-        coordinator.activeCellEditorPopover = first
-        coordinator.dismissActiveCellEditorPopover()
-        coordinator.activeCellEditorPopover = second
-
-        #expect(coordinator.activeCellEditorPopover === second)
-        #expect(first.closeCount == 1)
-        #expect(second.closeCount == 0)
-    }
-
-    @Test("Dismissing clears the slot and closes the editor")
-    func dismissClosesAndClearsTheSlot() {
-        let coordinator = makeCoordinator()
-        let editor = CloseCountingPopover()
-        coordinator.activeCellEditorPopover = editor
-
-        coordinator.dismissActiveCellEditorPopover()
-
-        #expect(coordinator.activeCellEditorPopover == nil)
-        #expect(editor.closeCount == 1)
-    }
-}
-
-private final class CloseCountingPopover: NSPopover {
-    private(set) var closeCount = 0
-
-    override func close() {
-        closeCount += 1
-        super.close()
-    }
-}
-
-private final class FakePopoverDismissalPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-
-    func clear(for key: ColumnLayoutTableKey) {}
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorRowCountCacheTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorRowCountCacheTests.swift
deleted file mode 100644
index 006eb4ed56..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorRowCountCacheTests.swift
+++ /dev/null
@@ -1,156 +0,0 @@
-//
-//  TableViewCoordinatorRowCountCacheTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct TableViewCoordinatorRowCountCacheTests {
-    private func makeCoordinator(rows: ContiguousArray<Row>) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeRowCountPersister()
-        )
-        var captured = TableRows(rows: rows, columns: ["c"])
-        coordinator.tableRowsProvider = { captured }
-        coordinator.tableRowsMutator = { mutation in mutation(&captured) }
-        coordinator.updateCache()
-        return coordinator
-    }
-
-    @Test("cachedRowCount tracks provider after initial load")
-    func cacheMatchesProviderOnLoad() {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-            Row(id: .existing(1), values: [.text("b")]),
-            Row(id: .existing(2), values: [.text("c")]),
-        ]
-        let coordinator = makeCoordinator(rows: rows)
-
-        #expect(coordinator.cachedRowCount == 3)
-        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
-    }
-
-    @Test("updateCache picks up appended rows")
-    func updateCacheReflectsAppendedRows() {
-        let coordinator = makeCoordinator(rows: [])
-
-        _ = coordinator.tableRowsMutator { rows in
-            _ = rows.appendInsertedRow(values: [.text("a")])
-            return rows.appendInsertedRow(values: [.text("b")])
-        }
-        coordinator.updateCache()
-
-        #expect(coordinator.cachedRowCount == 2)
-        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
-    }
-
-    @Test("updateCache picks up removed rows")
-    func updateCacheReflectsRemovedRows() {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-            Row(id: .existing(1), values: [.text("b")]),
-            Row(id: .existing(2), values: [.text("c")]),
-        ]
-        let coordinator = makeCoordinator(rows: rows)
-
-        _ = coordinator.tableRowsMutator { rows in
-            rows.remove(rowIDs: [.existing(1)])
-        }
-        coordinator.updateCache()
-
-        #expect(coordinator.cachedRowCount == 2)
-        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
-    }
-
-    @Test("updateCache reflects full replace")
-    func updateCacheReflectsFullReplace() {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-        ]
-        let coordinator = makeCoordinator(rows: rows)
-
-        _ = coordinator.tableRowsMutator { rows in
-            rows.replace(rows: [[.text("x")], [.text("y")], [.text("z")], [.text("w")]])
-        }
-        coordinator.updateCache()
-
-        #expect(coordinator.cachedRowCount == 4)
-        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
-    }
-
-    @Test("numberOfRows serves cachedRowCount when unsorted")
-    func numberOfRowsServesCacheWhenUnsorted() {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-            Row(id: .existing(1), values: [.text("b")]),
-        ]
-        let coordinator = makeCoordinator(rows: rows)
-        let tableView = NSTableView()
-
-        #expect(coordinator.numberOfRows(in: tableView) == 2)
-        #expect(coordinator.numberOfRows(in: tableView) == coordinator.tableRowsProvider().count)
-    }
-
-    @Test("numberOfRows serves the display count when a value filter narrows the rows")
-    func numberOfRowsServesDisplayCountWhenFiltered() {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-            Row(id: .existing(1), values: [.text("b")]),
-            Row(id: .existing(2), values: [.text("c")]),
-        ]
-        let coordinator = makeCoordinator(rows: rows)
-        let tableView = NSTableView()
-        coordinator.valueFilteredIDs = [.existing(2), .existing(0)]
-        coordinator.updateCache()
-
-        #expect(coordinator.numberOfRows(in: tableView) == 2)
-    }
-
-    @Test("the display count takes precedence over the cachedRowCount fallback")
-    func displayCountPrecedesCache() {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-            Row(id: .existing(1), values: [.text("b")]),
-            Row(id: .existing(2), values: [.text("c")]),
-        ]
-        let coordinator = makeCoordinator(rows: rows)
-
-        coordinator.valueFilteredIDs = [.existing(2), .existing(0)]
-        coordinator.updateCache()
-
-        #expect(coordinator.cachedRowCount == 2)
-    }
-
-    @Test("releaseData zeroes cachedRowCount")
-    func releaseDataZeroesCache() {
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("a")]),
-            Row(id: .existing(1), values: [.text("b")]),
-        ]
-        let coordinator = makeCoordinator(rows: rows)
-        #expect(coordinator.cachedRowCount == 2)
-
-        coordinator.releaseData()
-
-        #expect(coordinator.cachedRowCount == 0)
-    }
-}
-
-@MainActor
-private final class FakeRowCountPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-
-    func clear(for key: ColumnLayoutTableKey) {}
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorRowIdentityTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorRowIdentityTests.swift
deleted file mode 100644
index 509f1e6e6b..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorRowIdentityTests.swift
+++ /dev/null
@@ -1,230 +0,0 @@
-//
-//  TableViewCoordinatorRowIdentityTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class NoopRowIdentityLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-private final class RowStore {
-    var tableRows: TableRows
-
-    init(_ tableRows: TableRows) {
-        self.tableRows = tableRows
-    }
-}
-
-@MainActor
-struct TableViewCoordinatorRowIdentityTests {
-    private func makeManager() -> DataChangeManager {
-        let manager = DataChangeManager()
-        manager.configureForTable(
-            tableName: "users",
-            columns: ["id", "status"],
-            primaryKeyColumns: ["id"],
-            databaseType: .mysql,
-            generatedColumns: []
-        )
-        return manager
-    }
-
-    private func makeCoordinator(manager: DataChangeManager) -> (TableViewCoordinator, RowStore) {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(manager),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: NoopRowIdentityLayoutPersister()
-        )
-        let store = RowStore(TableRows.from(
-            queryRows: [
-                [.text("1"), .text("active")],
-                [.text("2"), .text("inactive")],
-                [.text("3"), .text("active")],
-                [.text("4"), .text("inactive")]
-            ],
-            columns: ["id", "status"],
-            columnTypes: [.text(rawType: nil), .text(rawType: nil)]
-        ))
-        coordinator.tableRowsProvider = { store.tableRows }
-        coordinator.tableRowsMutator = { mutation in mutation(&store.tableRows) }
-        coordinator.updateCache()
-        return (coordinator, store)
-    }
-
-    private func filterToInactive(_ coordinator: TableViewCoordinator) {
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["inactive"], includesNull: false),
-            columnName: "status",
-            forColumn: 1
-        )
-    }
-
-    @Test("An edit under a value filter is recorded on the row shown, and only that row changes")
-    func editUnderFilterLandsOnTheShownRow() throws {
-        let manager = makeManager()
-        let (coordinator, store) = makeCoordinator(manager: manager)
-        filterToInactive(coordinator)
-        #expect(coordinator.displayIDs == [.existing(1), .existing(3)])
-
-        coordinator.recordCellEdit(row: 1, columnIndex: 1, newValue: .text("archived"))
-
-        #expect(manager.isCellModified(rowID: .existing(3), columnIndex: 1))
-        #expect(!manager.isCellModified(rowID: .existing(1), columnIndex: 1))
-        #expect(store.tableRows.rows[3].values[1] == "archived")
-        #expect(store.tableRows.rows[1].values[1] == "inactive")
-
-        let statements = try manager.generateSQL()
-        let parameters = statements.first?.parameters ?? []
-        #expect(statements.count == 1)
-        #expect(parameters.count == 2)
-        #expect(parameters.last.flatMap { $0 as? String } == "4")
-    }
-
-    @Test("An edit keeps its row when the filter is cleared and positions move")
-    func editFollowsItsRowAcrossADisplayOrderChange() {
-        let manager = makeManager()
-        let (coordinator, _) = makeCoordinator(manager: manager)
-        filterToInactive(coordinator)
-
-        coordinator.recordCellEdit(row: 0, columnIndex: 1, newValue: .text("archived"))
-        coordinator.clearAllValueFilters()
-
-        #expect(coordinator.displayIDs == nil)
-        #expect(coordinator.visualState(for: 1).modifiedColumns == [1])
-        #expect(coordinator.visualState(for: 0).modifiedColumns.isEmpty)
-    }
-
-    @Test("Undoing an edit made under a value filter reverts the row that was edited")
-    func undoUnderFilterRevertsTheEditedRow() {
-        let manager = makeManager()
-        let undoManager = UndoManager()
-        undoManager.groupsByEvent = false
-        manager.undoManagerProvider = { undoManager }
-        var captured: UndoResult?
-        manager.onUndoApplied = { captured = $0 }
-        let (coordinator, store) = makeCoordinator(manager: manager)
-        filterToInactive(coordinator)
-
-        coordinator.recordCellEdit(row: 1, columnIndex: 0, newValue: .text("9"))
-        #expect(store.tableRows.rows[3].values[0] == "9")
-
-        undoManager.undo()
-        guard let captured else {
-            Issue.record("The undo produced no result")
-            return
-        }
-        _ = RowOperationsManager(changeManager: manager).applyUndoResult(captured, tableRows: &store.tableRows)
-
-        #expect(store.tableRows.rows[3].values[0] == "4")
-        #expect(store.tableRows.rows[1].values[0] == "2")
-        #expect(!manager.isCellModified(rowID: .existing(3), columnIndex: 0))
-    }
-
-    @Test("A deleted row is recognised at whatever position the filter shows it")
-    func deletedRowIsFoundByIdentity() {
-        let manager = makeManager()
-        let (coordinator, _) = makeCoordinator(manager: manager)
-        manager.recordRowDeletion(rowID: .existing(3), originalRow: ["4", "inactive"])
-        filterToInactive(coordinator)
-
-        #expect(coordinator.isRowDeleted(displayRow: 1))
-        #expect(!coordinator.isRowDeleted(displayRow: 0))
-        #expect(coordinator.visualState(for: 1).isDeleted)
-    }
-
-    @Test("Fill Column under a filter writes the shown rows and skips a deleted one")
-    func fillColumnUnderFilterTargetsShownRows() {
-        let manager = makeManager()
-        let (coordinator, _) = makeCoordinator(manager: manager)
-        filterToInactive(coordinator)
-        manager.recordRowDeletion(rowID: .existing(3), originalRow: ["4", "inactive"])
-
-        coordinator.applyFillColumn(columnIndex: 1, content: .value(.text("gone")))
-
-        #expect(manager.isCellModified(rowID: .existing(1), columnIndex: 1))
-        #expect(!manager.isCellModified(rowID: .existing(3), columnIndex: 1))
-        #expect(!manager.isCellModified(rowID: .existing(0), columnIndex: 1))
-        #expect(!manager.isCellModified(rowID: .existing(2), columnIndex: 1))
-    }
-
-    @Test("Undo Delete from the row menu clears the row shown at that position")
-    func undoDeleteUnderFilterClearsTheShownRow() {
-        let manager = makeManager()
-        let (coordinator, _) = makeCoordinator(manager: manager)
-        manager.recordRowDeletion(rowID: .existing(1), originalRow: ["2", "inactive"])
-        manager.recordRowDeletion(rowID: .existing(3), originalRow: ["4", "inactive"])
-        filterToInactive(coordinator)
-
-        coordinator.undoDeleteRow(at: 1)
-
-        #expect(!manager.isRowDeleted(.existing(3)))
-        #expect(manager.isRowDeleted(.existing(1)))
-    }
-
-    /// A detached editor outlives a filter change, and the display row it was opened from then
-    /// names a different record.
-    @Test("A commit by row identity writes the record the editor was opened for")
-    func identityCommitWritesTheOpenedRecord() {
-        let manager = makeManager()
-        let (coordinator, store) = makeCoordinator(manager: manager)
-        let openedRowID = coordinator.displayRow(at: 1)?.id
-
-        filterToInactive(coordinator)
-        coordinator.commitCellEdit(rowID: openedRowID, fallbackDisplayRow: 1, columnIndex: 1, newValue: "archived")
-
-        #expect(openedRowID == .existing(1))
-        #expect(manager.isCellModified(rowID: .existing(1), columnIndex: 1))
-        #expect(!manager.isCellModified(rowID: .existing(3), columnIndex: 1))
-        #expect(store.tableRows.rows[1].values[1] == .text("archived"))
-        #expect(store.tableRows.rows[3].values[1] == .text("inactive"))
-    }
-
-    @Test("A commit by row identity still writes a record the filter is hiding")
-    func identityCommitWritesAHiddenRecord() {
-        let manager = makeManager()
-        let (coordinator, store) = makeCoordinator(manager: manager)
-        let openedRowID = coordinator.displayRow(at: 0)?.id
-
-        filterToInactive(coordinator)
-        coordinator.commitCellEdit(rowID: openedRowID, fallbackDisplayRow: 0, columnIndex: 1, newValue: "archived")
-
-        #expect(openedRowID == .existing(0))
-        #expect(manager.isCellModified(rowID: .existing(0), columnIndex: 1))
-        #expect(store.tableRows.rows[0].values[1] == .text("archived"))
-    }
-
-    @Test("A grid with no row identity to offer falls back to the display row")
-    func identityCommitFallsBackToTheDisplayRow() {
-        let manager = makeManager()
-        let (coordinator, store) = makeCoordinator(manager: manager)
-
-        coordinator.commitCellEdit(rowID: nil, fallbackDisplayRow: 2, columnIndex: 1, newValue: "archived")
-
-        #expect(manager.isCellModified(rowID: .existing(2), columnIndex: 1))
-        #expect(store.tableRows.rows[2].values[1] == .text("archived"))
-    }
-
-    @Test("A commit naming a record the result no longer holds writes nothing")
-    func identityCommitForAMissingRecordWritesNothing() {
-        let manager = makeManager()
-        let (coordinator, store) = makeCoordinator(manager: manager)
-
-        coordinator.commitCellEdit(rowID: .existing(99), columnIndex: 1, newValue: "archived")
-
-        #expect(!manager.hasChanges)
-        #expect(store.tableRows.rows[1].values[1] == .text("inactive"))
-    }
-}
diff --git a/apple/TableProTests/Views/Results/TableViewCoordinatorValueFilterTests.swift b/apple/TableProTests/Views/Results/TableViewCoordinatorValueFilterTests.swift
deleted file mode 100644
index 5be4715cd2..0000000000
--- a/apple/TableProTests/Views/Results/TableViewCoordinatorValueFilterTests.swift
+++ /dev/null
@@ -1,437 +0,0 @@
-//
-//  TableViewCoordinatorValueFilterTests.swift
-//  TableProTests
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-struct TableViewCoordinatorValueFilterTests {
-    private func makeCoordinator() -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeValueFilterPersister()
-        )
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("active"), .text("a")]),
-            Row(id: .existing(1), values: [.text("inactive"), .text("b")]),
-            Row(id: .existing(2), values: [.text("active"), .text("c")]),
-            Row(id: .existing(3), values: [.null, .text("d")]),
-        ]
-        var captured = TableRows(
-            rows: rows,
-            columns: ["status", "name"],
-            columnTypes: [.text(rawType: nil), .text(rawType: nil)]
-        )
-        coordinator.tableRowsProvider = { captured }
-        coordinator.tableRowsMutator = { mutation in mutation(&captured) }
-        coordinator.updateCache()
-        return coordinator
-    }
-
-    @Test("distinctValues groups values with counts and a null bucket")
-    func distinctValuesGroupsWithCounts() {
-        let coordinator = makeCoordinator()
-        let values = coordinator.distinctValues(forColumn: 0)
-
-        #expect(values.count == 3)
-        #expect(values.first?.isNull == true)
-        #expect(values.first?.count == 1)
-        let active = values.first { $0.display == "active" }
-        let inactive = values.first { $0.display == "inactive" }
-        #expect(active?.count == 2)
-        #expect(inactive?.count == 1)
-    }
-
-    @Test("applying a value filter narrows the display set")
-    func applyingFilterNarrowsRows() {
-        let coordinator = makeCoordinator()
-
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["active"], includesNull: false),
-            columnName: "status",
-            forColumn: 0
-        )
-
-        #expect(coordinator.valueFilteredIDs == [.existing(0), .existing(2)])
-        #expect(coordinator.cachedRowCount == 2)
-        #expect(coordinator.displayRow(at: 0)?.id == .existing(0))
-        #expect(coordinator.displayRow(at: 1)?.id == .existing(2))
-        #expect(coordinator.tableRowsIndex(forDisplayRow: 1) == 2)
-    }
-
-    @Test("numberOfRows serves the filtered count")
-    func numberOfRowsServesFilteredCount() {
-        let coordinator = makeCoordinator()
-        let tableView = NSTableView()
-
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["active"], includesNull: false),
-            columnName: "status",
-            forColumn: 0
-        )
-
-        #expect(coordinator.numberOfRows(in: tableView) == 2)
-    }
-
-    @Test("multiple column filters intersect")
-    func multipleColumnFiltersIntersect() {
-        let coordinator = makeCoordinator()
-
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["active"], includesNull: false),
-            columnName: "status",
-            forColumn: 0
-        )
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["c"], includesNull: false),
-            columnName: "name",
-            forColumn: 1
-        )
-
-        #expect(coordinator.valueFilteredIDs == [.existing(2)])
-        #expect(coordinator.cachedRowCount == 1)
-    }
-
-    @Test("null selection matches only null rows")
-    func nullSelectionMatchesNullRows() {
-        let coordinator = makeCoordinator()
-
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: [], includesNull: true),
-            columnName: "status",
-            forColumn: 0
-        )
-
-        #expect(coordinator.valueFilteredIDs == [.existing(3)])
-    }
-
-    @Test("clearing one filter recomputes the remaining intersection")
-    func clearingOneFilterRecomputes() {
-        let coordinator = makeCoordinator()
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["active"], includesNull: false),
-            columnName: "status",
-            forColumn: 0
-        )
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["c"], includesNull: false),
-            columnName: "name",
-            forColumn: 1
-        )
-
-        coordinator.applyValueFilter(nil, columnName: "name", forColumn: 1)
-
-        #expect(coordinator.valueFilteredIDs == [.existing(0), .existing(2)])
-    }
-
-    @Test("clearAllValueFilters restores every loaded row")
-    func clearAllRestoresRows() {
-        let coordinator = makeCoordinator()
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["active"], includesNull: false),
-            columnName: "status",
-            forColumn: 0
-        )
-
-        coordinator.clearAllValueFilters()
-
-        #expect(coordinator.valueFilteredIDs == nil)
-        #expect(coordinator.cachedRowCount == 4)
-    }
-
-    @Test("inserted rows stay visible while a filter is active")
-    func insertedRowsStayVisible() {
-        let coordinator = makeCoordinator()
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["active"], includesNull: false),
-            columnName: "status",
-            forColumn: 0
-        )
-
-        _ = coordinator.tableRowsMutator { rows in
-            rows.appendInsertedRow(values: [.text("inactive"), .text("z")])
-        }
-        coordinator.recomputeValueFilteredIDs()
-        coordinator.updateCache()
-
-        #expect(coordinator.valueFilteredIDs?.count == 3)
-        #expect(coordinator.valueFilteredIDs?.last?.isInserted == true)
-    }
-
-    @Test("a column set change prunes stale filters on full replace")
-    func fullReplacePrunesStaleFilters() {
-        let coordinator = makeCoordinator()
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: ["active"], includesNull: false),
-            columnName: "status",
-            forColumn: 0
-        )
-
-        _ = coordinator.tableRowsMutator { rows in
-            rows.columns = ["other", "name"]
-            return .columnsReplaced
-        }
-        coordinator.applyFullReplace()
-        coordinator.recomputeValueFilteredIDs()
-        coordinator.updateCache()
-
-        #expect(coordinator.valueFilteredIDs == nil)
-        #expect(!coordinator.valueFilterState.isActive)
-    }
-
-    @Test("Changing binary display format preserves the filtered rows")
-    func binaryDisplayFormatRemapsSelectedValues() {
-        let first = Data([
-            0xAF, 0x49, 0x45, 0x3B, 0x7F, 0x2F, 0xFB, 0x58,
-            0xFC, 0xD3, 0x2B, 0xD3, 0x99, 0x59, 0x9F, 0xA5,
-        ])
-        let second = Data(repeating: 0xBB, count: 16)
-        let tableRows = TableRows(
-            rows: [
-                Row(id: .existing(0), values: [.bytes(first)]),
-                Row(id: .existing(1), values: [.bytes(second)]),
-            ],
-            columns: ["id"],
-            columnTypes: [.blob(rawType: "BYTEA")]
-        )
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeValueFilterPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.updateDisplayFormats([nil])
-        coordinator.updateCache()
-        coordinator.applyValueFilter(
-            ColumnValueFilter(
-                selectedValues: ["0xAF49453B7F2FFB58FCD32BD399599FA5"],
-                includesNull: false
-            ),
-            columnName: "id",
-            forColumn: 0
-        )
-
-        #expect(coordinator.updateDisplayFormats([.uuid]))
-        coordinator.recomputeValueFilteredIDs()
-
-        #expect(coordinator.valueFilteredIDs == [.existing(0)])
-        #expect(
-            coordinator.valueFilterState.filter(forColumn: 0)?.selectedValues
-                == ["af49453b-7f2f-fb58-fcd3-2bd399599fa5"]
-        )
-
-        #expect(coordinator.updateDisplayFormats([.raw]))
-        coordinator.recomputeValueFilteredIDs()
-        #expect(coordinator.valueFilteredIDs == [.existing(0)])
-        #expect(
-            coordinator.valueFilterState.filter(forColumn: 0)?.selectedValues
-                == ["0xAF49453B7F2FFB58FCD32BD399599FA5"]
-        )
-    }
-
-    @Test("Changing result sets does not discard unmatched filter selections")
-    func displayFormatRemapPreservesSelectionsMissingFromCurrentRows() {
-        let first = Data(repeating: 0xAA, count: 16)
-        let second = Data(repeating: 0xBB, count: 16)
-        let firstResult = TableRows(
-            rows: [Row(id: .existing(0), values: [.bytes(first)])],
-            columns: ["id"],
-            columnTypes: [.blob(rawType: "BYTEA")]
-        )
-        let secondResult = TableRows(
-            rows: [Row(id: .existing(1), values: [.bytes(second)])],
-            columns: ["id"],
-            columnTypes: [.blob(rawType: "BYTEA")]
-        )
-        var currentRows = firstResult
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeValueFilterPersister()
-        )
-        coordinator.tableRowsProvider = { currentRows }
-        coordinator.updateDisplayFormats([.raw])
-        coordinator.applyValueFilter(
-            ColumnValueFilter(
-                selectedValues: ["0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"],
-                includesNull: false
-            ),
-            columnName: "id",
-            forColumn: 0
-        )
-
-        currentRows = secondResult
-        coordinator.updateDisplayFormats([.uuid])
-        coordinator.recomputeValueFilteredIDs()
-        #expect(coordinator.valueFilteredIDs?.isEmpty == true)
-
-        currentRows = firstResult
-        coordinator.updateDisplayFormats([.raw])
-        coordinator.recomputeValueFilteredIDs()
-
-        #expect(coordinator.valueFilteredIDs == [.existing(0)])
-        #expect(
-            coordinator.valueFilterState.filter(forColumn: 0)?.selectedValues
-                == ["0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"]
-        )
-    }
-
-    @Test("Display format changes do not migrate filters to a renamed column")
-    func displayFormatRemapPrunesRenamedColumns() {
-        let bytes = Data(repeating: 0xAA, count: 16)
-        var currentRows = TableRows(
-            rows: [Row(id: .existing(0), values: [.bytes(bytes)])],
-            columns: ["old_id"],
-            columnTypes: [.blob(rawType: "BYTEA")]
-        )
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeValueFilterPersister()
-        )
-        coordinator.tableRowsProvider = { currentRows }
-        coordinator.updateDisplayFormats([.raw])
-        coordinator.applyValueFilter(
-            ColumnValueFilter(
-                selectedValues: ["0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"],
-                includesNull: false
-            ),
-            columnName: "old_id",
-            forColumn: 0
-        )
-
-        currentRows = TableRows(
-            rows: [Row(id: .existing(0), values: [.bytes(bytes)])],
-            columns: ["new_id"],
-            columnTypes: [.blob(rawType: "BYTEA")]
-        )
-        #expect(coordinator.updateDisplayFormats([.uuid]))
-
-        #expect(!coordinator.valueFilterState.isActive)
-    }
-
-    @Test("Display format remapping is independent of row order")
-    func displayFormatRemapHandlesOverlappingOldAndNewValues() throws {
-        let oldFirst = try #require(ValueDisplayFormatter.apply("1000000", format: .unixTimestamp))
-        let oldSecond = try #require(ValueDisplayFormatter.apply("1000", format: .unixTimestamp))
-        let newFirst = try #require(ValueDisplayFormatter.apply("1000000", format: .unixTimestampMillis))
-        let newSecond = try #require(ValueDisplayFormatter.apply("1000", format: .unixTimestampMillis))
-        #expect(newFirst == oldSecond)
-
-        let tableRows = TableRows(
-            rows: [
-                Row(id: .existing(0), values: [.text("1000000")]),
-                Row(id: .existing(1), values: [.text("1000")]),
-            ],
-            columns: ["created_at"],
-            columnTypes: [.integer(rawType: "BIGINT")]
-        )
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeValueFilterPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.updateDisplayFormats([.unixTimestamp])
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: [oldFirst, oldSecond], includesNull: false),
-            columnName: "created_at",
-            forColumn: 0
-        )
-
-        coordinator.updateDisplayFormats([.unixTimestampMillis])
-        coordinator.recomputeValueFilteredIDs()
-
-        #expect(coordinator.valueFilteredIDs == [.existing(0), .existing(1)])
-        #expect(
-            coordinator.valueFilterState.filter(forColumn: 0)?.selectedValues
-                == [newFirst, newSecond]
-        )
-    }
-
-    @Test("A format change that moves no selected value keeps the grid selection")
-    func displayFormatRemapReportsNoChangeWhenSelectionIsUnaffected() {
-        let loaded = Data(repeating: 0xCC, count: 16)
-        let tableRows = TableRows(
-            rows: [Row(id: .existing(0), values: [.bytes(loaded)])],
-            columns: ["id"],
-            columnTypes: [.blob(rawType: "BYTEA")]
-        )
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeValueFilterPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.updateDisplayFormats([.raw])
-        let selection: Set<String> = ["0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"]
-        coordinator.applyValueFilter(
-            ColumnValueFilter(selectedValues: selection, includesNull: false),
-            columnName: "id",
-            forColumn: 0
-        )
-
-        #expect(!coordinator.updateDisplayFormats([.uuid]))
-        #expect(coordinator.valueFilterState.filter(forColumn: 0)?.selectedValues == selection)
-    }
-
-    @Test("The inspector ignores grid formats left over from another tab")
-    func activeFormatsRequireMatchingColumns() {
-        let tableRows = TableRows(
-            rows: [Row(id: .existing(0), values: [.bytes(Data(repeating: 0xAA, count: 16))])],
-            columns: ["id"],
-            columnTypes: [.blob(rawType: "BYTEA")]
-        )
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: FakeValueFilterPersister()
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.updateDisplayFormats([.uuid])
-
-        #expect(
-            InspectorValueDisplayFormatResolver.activeFormats(
-                from: coordinator,
-                matching: ["id"]
-            ) == [.uuid]
-        )
-        #expect(
-            InspectorValueDisplayFormatResolver.activeFormats(
-                from: coordinator,
-                matching: ["payload"]
-            ) == nil
-        )
-        #expect(InspectorValueDisplayFormatResolver.activeFormats(from: nil, matching: ["id"]) == nil)
-    }
-}
-
-@MainActor
-private final class FakeValueFilterPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-
-    func clear(for key: ColumnLayoutTableKey) {}
-}
diff --git a/apple/TableProTests/Views/Results/ValueFilterChangeGuardTests.swift b/apple/TableProTests/Views/Results/ValueFilterChangeGuardTests.swift
deleted file mode 100644
index 1b56025335..0000000000
--- a/apple/TableProTests/Views/Results/ValueFilterChangeGuardTests.swift
+++ /dev/null
@@ -1,210 +0,0 @@
-//
-//  ValueFilterChangeGuardTests.swift
-//  TableProTests
-//
-//  Sort, pagination and the WHERE filter confirm before changing the display order while edits
-//  are pending, and the per-column value filter does the same. (#2667)
-//
-
-import AppKit
-import SwiftUI
-import TableProPluginKit
-import Testing
-
-@testable import TablePro
-
-@MainActor
-private final class GuardPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// Holds the work instead of running it, standing in for a reader who has not answered the alert.
-@MainActor
-private final class DeferringDelegate: DataGridViewDelegate {
-    private(set) var askedCount = 0
-    private var pending: (() -> Void)?
-
-    func dataGridConfirmDisplayOrderChange(then apply: @escaping () -> Void) {
-        askedCount += 1
-        pending = apply
-    }
-
-    func confirm() {
-        let work = pending
-        pending = nil
-        work?()
-    }
-
-    func discard() {
-        pending = nil
-    }
-}
-
-@MainActor
-struct ValueFilterChangeGuardTests {
-    private func makeCoordinator(delegate: (any DataGridViewDelegate)? = nil) -> TableViewCoordinator {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: delegate,
-            layoutPersister: GuardPersister()
-        )
-        let rows: ContiguousArray<Row> = [
-            Row(id: .existing(0), values: [.text("active"), .text("a")]),
-            Row(id: .existing(1), values: [.text("inactive"), .text("b")]),
-            Row(id: .existing(2), values: [.text("active"), .text("c")]),
-        ]
-        var captured = TableRows(
-            rows: rows,
-            columns: ["status", "name"],
-            columnTypes: [.text(rawType: nil), .text(rawType: nil)]
-        )
-        coordinator.tableRowsProvider = { captured }
-        coordinator.tableRowsMutator = { mutation in mutation(&captured) }
-        coordinator.updateCache()
-        return coordinator
-    }
-
-    private func onlyActive() -> ColumnValueFilter {
-        ColumnValueFilter(selectedValues: ["active"], includesNull: false)
-    }
-
-    /// The structure, create-table and inspector grids own no pending edits and take the protocol
-    /// default, so they must keep applying a filter with no round trip at all.
-    @Test("a grid with no owner applies its filter directly")
-    func ownerlessGridAppliesImmediately() {
-        let coordinator = makeCoordinator()
-
-        coordinator.applyValueFilter(onlyActive(), columnName: "status", forColumn: 0)
-
-        #expect(coordinator.valueFilterState.isActive)
-        #expect(coordinator.valueFilteredIDs?.count == 2)
-    }
-
-    @Test("a grid with an owner asks before it narrows anything")
-    func ownedGridAsksFirst() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-
-        coordinator.applyValueFilter(onlyActive(), columnName: "status", forColumn: 0)
-
-        #expect(delegate.askedCount == 1)
-        /// Nothing moved yet. The filter is written inside the approved work, not before it, or the
-        /// reader would be answering an alert about a change that had already happened.
-        #expect(!coordinator.valueFilterState.isActive)
-        #expect(coordinator.valueFilteredIDs == nil)
-    }
-
-    @Test("approving the change applies the filter")
-    func approvingApplies() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-        coordinator.applyValueFilter(onlyActive(), columnName: "status", forColumn: 0)
-
-        delegate.confirm()
-
-        #expect(coordinator.valueFilterState.isActive)
-        #expect(coordinator.valueFilteredIDs?.count == 2)
-    }
-
-    @Test("declining the change leaves the rows as they were")
-    func decliningLeavesRowsAlone() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-
-        coordinator.applyValueFilter(onlyActive(), columnName: "status", forColumn: 0)
-        delegate.discard()
-
-        #expect(!coordinator.valueFilterState.isActive)
-        #expect(coordinator.valueFilteredIDs == nil)
-    }
-
-    @Test("clearing every filter asks as well")
-    func clearingAsksFirst() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-        coordinator.applyValueFilter(onlyActive(), columnName: "status", forColumn: 0)
-        delegate.confirm()
-        #expect(coordinator.valueFilterState.isActive)
-
-        coordinator.clearAllValueFilters()
-        #expect(delegate.askedCount == 2)
-        #expect(coordinator.valueFilterState.isActive)
-
-        delegate.confirm()
-        #expect(!coordinator.valueFilterState.isActive)
-    }
-
-    /// Opening the popover and pressing Apply without touching anything is ordinary, and it moves no
-    /// row, so it must not put a discard alert in the reader's way.
-    @Test("applying the filter it already has asks nothing and still dismisses")
-    func reapplyingTheSameFilterAsksNothing() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-        coordinator.applyValueFilter(onlyActive(), columnName: "status", forColumn: 0)
-        delegate.confirm()
-        #expect(delegate.askedCount == 1)
-
-        var dismissed = false
-        coordinator.applyValueFilter(
-            onlyActive(),
-            columnName: "status",
-            forColumn: 0,
-            onApplied: { dismissed = true }
-        )
-
-        #expect(delegate.askedCount == 1)
-        #expect(dismissed)
-    }
-
-    /// The popover must not close while the reader still has an alert to answer, or Cancel leaves
-    /// them with no popover and no filter and no way to see what happened.
-    @Test("the popover is dismissed only once the change is applied")
-    func popoverDismissalWaitsForTheAnswer() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-
-        var dismissed = false
-        coordinator.applyValueFilter(
-            onlyActive(),
-            columnName: "status",
-            forColumn: 0,
-            onApplied: { dismissed = true }
-        )
-        #expect(!dismissed)
-
-        delegate.confirm()
-        #expect(dismissed)
-    }
-
-    @Test("declining leaves the popover open")
-    func decliningLeavesThePopoverOpen() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-
-        var dismissed = false
-        coordinator.applyValueFilter(
-            onlyActive(),
-            columnName: "status",
-            forColumn: 0,
-            onApplied: { dismissed = true }
-        )
-        delegate.discard()
-
-        #expect(!dismissed)
-        #expect(!coordinator.valueFilterState.isActive)
-    }
-
-    @Test("clearing when nothing is filtered asks nothing")
-    func clearingWithNoFilterAsksNothing() {
-        let delegate = DeferringDelegate()
-        let coordinator = makeCoordinator(delegate: delegate)
-
-        coordinator.clearAllValueFilters()
-
-        #expect(delegate.askedCount == 0)
-    }
-}
diff --git a/apple/TableProTests/Views/Results/ValueStandInThemeTests.swift b/apple/TableProTests/Views/Results/ValueStandInThemeTests.swift
index b7a4bb1c31..95f0ce67f3 100644
--- a/apple/TableProTests/Views/Results/ValueStandInThemeTests.swift
+++ b/apple/TableProTests/Views/Results/ValueStandInThemeTests.swift
@@ -19,7 +19,7 @@ struct ValueStandInThemeTests {
     private static let size = CGSize(width: 360, height: 280)
     private static let editorBackground = "#282A36"
 
-    /// Under the default pair the state draws nothing of its own, under a theme the editor background.
+    // Under the default pair the state draws nothing of its own, under a theme the editor background.
     private func assertStandsIn(_ view: some View, at point: CGPoint = CGPoint(x: 0.03, y: 0.8)) throws {
         let framed = view.frame(width: Self.size.width, height: Self.size.height)
         try ThemeTestFixture.adopting(.builtIn, appearance: .light) {
@@ -54,7 +54,7 @@ struct ValueStandInThemeTests {
     func resultJSONWithoutRows() throws {
         try assertStandsIn(ResultsJsonView(
             tableRows: TableRows(),
-            selectedRowIndices: [],
+            selectedRowIDs: [],
             displayIDs: nil,
             deletedRowIDs: [],
             valueFilter: GridValueFilterState(),
@@ -70,7 +70,7 @@ struct ValueStandInThemeTests {
         try #require(ThemeTestFixture.textViews(in: window).first)
     }
 
-    /// A literal the list editor cannot read opens straight into raw text.
+    // A literal the list editor cannot read opens straight into raw text.
     private var rawArrayEditor: some View {
         ArrayValueEditorView(
             literal: "{{1,2},{3}}",
diff --git a/apple/TableProTests/Views/RowInspector/SplitItemGlassBackgroundTests.swift b/apple/TableProTests/Views/RowInspector/SplitItemGlassBackgroundTests.swift
index e70632b873..807aa7c5af 100644
--- a/apple/TableProTests/Views/RowInspector/SplitItemGlassBackgroundTests.swift
+++ b/apple/TableProTests/Views/RowInspector/SplitItemGlassBackgroundTests.swift
@@ -24,7 +24,6 @@ struct SplitItemGlassBackgroundTests {
     private func fieldList() -> InspectorFieldListView {
         let state = MultiRowEditState()
         state.configure(
-            selectedRowIndices: [0],
             rowIDs: [.existing(0)],
             allRows: [["1", "Still"]],
             absentCells: [[]],
diff --git a/apple/TableProTests/Views/ServerDashboard/ServerDashboardGridTests.swift b/apple/TableProTests/Views/ServerDashboard/ServerDashboardGridTests.swift
index 361091c58a..113dc90641 100644
--- a/apple/TableProTests/Views/ServerDashboard/ServerDashboardGridTests.swift
+++ b/apple/TableProTests/Views/ServerDashboard/ServerDashboardGridTests.swift
@@ -28,16 +28,17 @@ struct ServerDashboardGridTests {
         SortState(columns: [SortColumn(columnIndex: column, direction: direction)], source: .user)
     }
 
-    private func gridTable(in view: NSView?) -> KeyHandlingTableView? {
+    private func gridTable(in view: NSView?) -> DataGridTableView? {
         guard let view else { return nil }
-        if let table = view as? KeyHandlingTableView { return table }
+        if let table = view as? DataGridTableView, table.paneKind == .main { return table }
         for subview in view.subviews {
             if let found = gridTable(in: subview) { return found }
         }
         return nil
     }
 
-    private func host(_ view: some View) -> NSWindow {
+    // The list loads its rows in onAppear, which SwiftUI runs on a later turn than the first layout.
+    private func host(_ view: some View) async -> NSWindow {
         let window = NSWindow(
             contentRect: NSRect(x: 0, y: 0, width: 800, height: 400),
             styleMask: [.titled],
@@ -46,7 +47,12 @@ struct ServerDashboardGridTests {
         )
         window.isReleasedWhenClosed = false
         window.contentView = NSHostingView(rootView: view.frame(width: 800, height: 400))
-        window.contentView?.layoutSubtreeIfNeeded()
+        for _ in 0 ..< 10 {
+            window.contentView?.layoutSubtreeIfNeeded()
+            await withCheckedContinuation { continuation in
+                DispatchQueue.main.async { continuation.resume() }
+            }
+        }
         return window
     }
 
@@ -107,19 +113,32 @@ struct ServerDashboardGridTests {
     }
 
     @Test("The sessions grid draws the State hue, white on an emphasized selection, and every other cell in the grid text")
-    func sessionsGridDrawsTheStateHue() throws {
+    func sessionsGridDrawsTheStateHue() async throws {
         let viewModel = ServerDashboardViewModel(connectionId: UUID(), databaseType: .postgresql, services: .live)
         viewModel.sessions = sessions
-        let window = host(SessionsTableView(viewModel: viewModel))
+        let window = await host(SessionsTableView(viewModel: viewModel))
         defer {
             viewModel.stopAutoRefresh()
             window.contentView = nil
         }
-        let coordinator = try #require(gridTable(in: window.contentView)?.coordinator)
-        let palette = coordinator.cellRegistry.palette
+        let table = try #require(gridTable(in: window.contentView))
+        let controller = try #require(table.controller)
+        let presenter = controller.presenter
+        let pass = try #require(presenter.makePass(in: table.effectiveAppearance))
+        let palette = pass.palette
         let state = SessionGridColumns.stateColumn
         func textColor(row: Int, column: Int, selected: Bool = false) -> NSColor? {
-            coordinator.cellAppearance(row: row, columnIndex: column, onEmphasizedSelection: selected)?.textColor
+            let model = controller.model
+            guard let rowModel = model.row(at: row),
+                  let gridColumn = model.columns.columns.first(where: { $0.dataIndex == column }) else { return nil }
+            return presenter.appearance(
+                of: rowModel,
+                displayRow: row,
+                column: gridColumn,
+                visualState: presenter.visualState(of: rowModel),
+                pass: pass,
+                onEmphasizedSelection: selected
+            )?.textColor
         }
 
         // Longest first: the idle session, then the two active ones.
@@ -130,7 +149,7 @@ struct ServerDashboardGridTests {
         #expect(textColor(row: 1, column: SessionGridColumns.durationColumn) == palette.text)
     }
 
-    private func headerRedPixels(selecting ids: Set<String>) throws -> Int {
+    private func headerRedPixels(selecting ids: Set<String>) async throws -> Int {
         let viewModel = ServerDashboardViewModel(connectionId: UUID(), databaseType: .postgresql, services: .live)
         viewModel.sessions = sessions
         viewModel.sessionSelection.ids = ids
@@ -145,7 +164,12 @@ struct ServerDashboardGridTests {
             viewModel.stopAutoRefresh()
             window.contentView = nil
         }
-        host.layoutSubtreeIfNeeded()
+        for _ in 0 ..< 10 {
+            host.layoutSubtreeIfNeeded()
+            await withCheckedContinuation { continuation in
+                DispatchQueue.main.async { continuation.resume() }
+            }
+        }
         let bitmap = try #require(host.bitmapImageRepForCachingDisplay(in: host.bounds))
         host.cacheDisplay(in: host.bounds, to: bitmap)
         let headerRows = Int(36 * CGFloat(bitmap.pixelsHigh) / size.height)
@@ -155,9 +179,9 @@ struct ServerDashboardGridTests {
     }
 
     @Test("Terminate draws its red glyph while it can end the selected session, and the standard glyph while disabled")
-    func terminateGlyphIsRedOnlyWhileEnabled() throws {
-        #expect(try headerRedPixels(selecting: ["10"]) > 0)
-        #expect(try headerRedPixels(selecting: []) == 0)
+    func terminateGlyphIsRedOnlyWhileEnabled() async throws {
+        #expect(try await headerRedPixels(selecting: ["10"]) > 0)
+        #expect(try await headerRedPixels(selecting: []) == 0)
     }
 
     @Test("Cancel and Terminate act on exactly one selected session that is still listed")
@@ -187,10 +211,10 @@ struct ServerDashboardGridTests {
     }
 
     @Test("The sessions pane draws its records in the data grid")
-    func sessionsMountTheDataGrid() throws {
+    func sessionsMountTheDataGrid() async throws {
         let viewModel = ServerDashboardViewModel(connectionId: UUID(), databaseType: .mysql, services: .live)
         viewModel.sessions = sessions
-        let window = host(SessionsTableView(viewModel: viewModel))
+        let window = await host(SessionsTableView(viewModel: viewModel))
         defer {
             viewModel.stopAutoRefresh()
             window.contentView = nil
@@ -199,10 +223,28 @@ struct ServerDashboardGridTests {
         #expect(table.numberOfRows == sessions.count)
     }
 
+    @Test("A session selected in the grid becomes the one Cancel and Terminate act on")
+    func gridSelectionReachesTheActionTarget() async throws {
+        let viewModel = ServerDashboardViewModel(connectionId: UUID(), databaseType: .postgresql, services: .live)
+        viewModel.sessions = sessions
+        let window = await host(SessionsTableView(viewModel: viewModel))
+        defer {
+            viewModel.stopAutoRefresh()
+            window.contentView = nil
+        }
+        let table = try #require(gridTable(in: window.contentView))
+
+        // Longest first: the idle session "2", then "10" and "7".
+        table.selectRowIndexes(IndexSet(integer: 1), byExtendingSelection: false)
+
+        #expect(viewModel.sessionSelection.ids == ["10"])
+        #expect(SessionGridColumns.actionTarget(viewModel.sessionSelection.ids, in: viewModel.sessions)?.id == "10")
+    }
+
     @Test("The slow query pane draws its records in the data grid")
-    func slowQueriesMountTheDataGrid() throws {
+    func slowQueriesMountTheDataGrid() async throws {
         let queries = [DashboardSlowQuery(duration: "4s", query: "SELECT SLEEP(4)", user: "app", database: "shop")]
-        let window = host(SlowQueryListView(queries: queries, error: nil, databaseType: .mysql))
+        let window = await host(SlowQueryListView(queries: queries, error: nil, databaseType: .mysql))
         defer { window.contentView = nil }
         let table = try #require(gridTable(in: window.contentView))
         #expect(table.numberOfRows == 1)
diff --git a/apple/TableProTests/Views/Settings/ThemeSlotRowTests.swift b/apple/TableProTests/Views/Settings/ThemeSlotRowTests.swift
index 69104035dd..f579b4ccb0 100644
--- a/apple/TableProTests/Views/Settings/ThemeSlotRowTests.swift
+++ b/apple/TableProTests/Views/Settings/ThemeSlotRowTests.swift
@@ -47,7 +47,7 @@ struct ThemeSlotRowTests {
         #expect(line(.syntaxString) == "Default Dark color")
         #expect(line(.syntaxOperator) == "Based on Editor Text")
         #expect(line(.gridAlternateRow) == "Based on Data Grid Background")
-        #expect(line(.gridHeaderText) == "System color")
+        #expect(line(.gridBoolTrue) == "System color")
 
         var light = Self.dark
         light.appearance = .light
@@ -97,7 +97,6 @@ struct ThemeSlotRowTests {
         #expect(ThemeContrastNote.message(for: .syntax, in: low) == nil)
     }
 
-    /// The well's alpha slider is offered only where the slot is a wash over content.
     @Test("A slot's well offers opacity only when the slot does")
     func wellOpacityFollowsTheSlot() throws {
         guard #available(macOS 14, *) else { return }
@@ -107,9 +106,7 @@ struct ThemeSlotRowTests {
         }
     }
 
-    /// Activating a well without opacity after one with it turns the shared panel's alpha off, and
-    /// the panel then sends the previous well's color and this one's, both made opaque. Taken as
-    /// picks, they froze a system color into the file.
+    // The panel sends both wells' colors, made opaque, when alpha turns off; taken as picks they froze a system color.
     @Test("Activating a well is not a pick, and a color chosen in the panel still is")
     func activationIsNotAPick() throws {
         guard #available(macOS 14, *) else { return }
diff --git a/apple/TableProTests/Views/SortableHeaderEmphasisTests.swift b/apple/TableProTests/Views/SortableHeaderEmphasisTests.swift
deleted file mode 100644
index ad1b44d3ac..0000000000
--- a/apple/TableProTests/Views/SortableHeaderEmphasisTests.swift
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-//  SortableHeaderEmphasisTests.swift
-//  TableProTests
-//
-
-import AppKit
-@testable import TablePro
-import Testing
-
-@MainActor
-struct SortableHeaderEmphasisTests {
-    @Test("Emphasis needs both the key window and table focus")
-    func requiresBothConditions() {
-        #expect(SortableHeaderEmphasis.isEmphasized(tableViewHoldsFocus: true, isKeyWindow: true))
-        #expect(SortableHeaderEmphasis.isEmphasized(tableViewHoldsFocus: true, isKeyWindow: false) == false)
-        #expect(SortableHeaderEmphasis.isEmphasized(tableViewHoldsFocus: false, isKeyWindow: true) == false)
-        #expect(SortableHeaderEmphasis.isEmphasized(tableViewHoldsFocus: false, isKeyWindow: false) == false)
-    }
-
-    /// An `NSTableView` with no columns answers `acceptsFirstResponder` with false, so a bare one
-    /// would leave the window itself as the responder and the test would prove nothing.
-    private func makeWindow() -> (NSWindow, NSTableView) {
-        let table = NSTableView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        table.addTableColumn(NSTableColumn(identifier: NSUserInterfaceItemIdentifier("column")))
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 200, height: 100))
-        scrollView.documentView = table
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 200, height: 100),
-            styleMask: [.titled],
-            backing: .buffered,
-            defer: false
-        )
-        window.contentView?.addSubview(scrollView)
-        return (window, table)
-    }
-
-    @Test("The table itself holding focus counts")
-    func tableIsFirstResponder() {
-        let (window, table) = makeWindow()
-        _ = window.makeFirstResponder(table)
-        #expect(SortableHeaderEmphasis.holdsFocus(tableView: table, in: window))
-    }
-
-    /// Focus has to be resolved by ancestry. Keying on identity alone dropped the header out of
-    /// emphasis mid-edit.
-    @Test("A responder inside the table still counts as focus")
-    func descendantIsFirstResponder() {
-        let (window, table) = makeWindow()
-        let field = NSTextField(frame: NSRect(x: 0, y: 0, width: 50, height: 20))
-        table.addSubview(field)
-        _ = window.makeFirstResponder(field)
-        #expect(SortableHeaderEmphasis.holdsFocus(tableView: table, in: window))
-    }
-
-    /// The grid mounts its cell editor and viewer in the table's scroll view, beside the table
-    /// rather than inside it, so accessibility can reach them.
-    @Test("A responder in the table's scroll view, beside the table, still counts as focus")
-    func scrollViewDescendantIsFirstResponder() throws {
-        let (window, table) = makeWindow()
-        let scrollView = try #require(table.enclosingScrollView)
-        let field = NSTextField(frame: NSRect(x: 0, y: 0, width: 50, height: 20))
-        scrollView.addSubview(field, positioned: .above, relativeTo: scrollView.contentView)
-        _ = window.makeFirstResponder(field)
-        #expect(!field.isDescendant(of: table))
-        #expect(SortableHeaderEmphasis.holdsFocus(tableView: table, in: window))
-    }
-
-    @Test("A responder outside the table does not count as focus")
-    func siblingIsFirstResponder() {
-        let (window, table) = makeWindow()
-        let field = NSTextField(frame: NSRect(x: 0, y: 0, width: 50, height: 20))
-        window.contentView?.addSubview(field)
-        _ = window.makeFirstResponder(field)
-        #expect(SortableHeaderEmphasis.holdsFocus(tableView: table, in: window) == false)
-    }
-
-    @Test("No table and no window resolve to no focus")
-    func missingPiecesResolveToFalse() {
-        let (window, table) = makeWindow()
-        #expect(SortableHeaderEmphasis.holdsFocus(tableView: nil, in: window) == false)
-        #expect(SortableHeaderEmphasis.holdsFocus(tableView: table, in: nil) == false)
-    }
-}
diff --git a/apple/TableProTests/Views/Structure/ClickHousePartsGridTests.swift b/apple/TableProTests/Views/Structure/ClickHousePartsGridTests.swift
index 09f9ca21ea..41044fa125 100644
--- a/apple/TableProTests/Views/Structure/ClickHousePartsGridTests.swift
+++ b/apple/TableProTests/Views/Structure/ClickHousePartsGridTests.swift
@@ -73,17 +73,29 @@ struct ClickHousePartsGridTests {
     }
 
     @Test("A selected grid row names its own part")
-    func selectedRowResolvesToItsPart() {
+    func selectedRowResolvesToItsPart() throws {
         let other = ClickHousePartInfo(
             partition: "202602", name: "202602_1_1_0", rows: 1, bytesOnDisk: 1, modificationTime: "", active: true
         )
         let parts = [part, other]
         let grid = StructureListGridModel<UUID>()
-        _ = grid.ensureLoaded(key: 1, columns: ClickHousePartsView.columnTitles) {
-            parts.map(ClickHousePartsView.gridRow(for:))
-        }
+        var selected: Set<UUID> = []
+        grid.onSelect = { selected = $0 }
+        grid.load(
+            columns: ClickHousePartsView.columnTitles,
+            rows: parts.map(ClickHousePartsView.gridRow(for:)),
+            defaultWidths: ClickHousePartsView.columnWidths,
+            minimumWidths: ClickHousePartsView.columnMinimumWidths,
+            databaseType: .clickhouse,
+            sortState: nil
+        )
+        let second = try #require(grid.model.rowID(at: 1))
+
+        grid.model.selectRows([second])
 
-        #expect(grid.id(atDisplayRow: 1) == other.id)
-        #expect(grid.id(atDisplayRow: 2) == nil)
+        #expect(grid.id(for: second) == other.id)
+        #expect(selected == [other.id])
+        #expect(ClickHousePartsView.partition(of: selected, in: parts) == "202602")
+        #expect(grid.model.rowID(at: 2) == nil)
     }
 }
diff --git a/apple/TableProTests/Views/Structure/CreateTableDraftCompositionTests.swift b/apple/TableProTests/Views/Structure/CreateTableDraftCompositionTests.swift
index 84c9443068..42c28febea 100644
--- a/apple/TableProTests/Views/Structure/CreateTableDraftCompositionTests.swift
+++ b/apple/TableProTests/Views/Structure/CreateTableDraftCompositionTests.swift
@@ -164,31 +164,29 @@ struct CreateTableDraftCompositionTests {
         "A grid edit reaches whoever observes the draft, so the preview and Create Table follow it",
         arguments: [StructureTab.columns, StructureTab.indexes, StructureTab.foreignKeys]
     )
-    func gridEditPublishesTheDraft(tab: StructureTab) {
+    func gridEditPublishesTheDraft(tab: StructureTab) throws {
         let connection = TestFixtures.makeConnection(type: .postgresql)
         let scope = DatabaseScope(connectionId: connection.id, database: "shop", schema: "reporting")
         let draft = Self.makeDraft(tableName: "sales")
         draft.changeManager.addNewIndex()
         draft.changeManager.addNewForeignKey()
-        let delegate = CreateTableGridDelegate(
-            structureChangeManager: draft.changeManager,
-            structureTab: tab,
-            connection: connection
-        )
-        delegate.orderedFields = StructureRowProvider(
-            changeManager: draft.changeManager,
-            tab: tab,
-            databaseType: connection.type,
-            additionalFields: [.primaryKey],
-            serverSupport: .unrestricted
-        ).orderedColumnFields
+        let adapter = draft.gridAdapter(for: connection)
+        adapter.select(tab)
+        adapter.refresh()
+        let model = adapter.model
+        let rowID = try #require(model.rowID(at: 0))
+        let name = try #require(model.columns.column(at: 0))
         let keyBefore = draft.compositionKey(scope: scope)
 
         var published = 0
         let observation = draft.objectWillChange.sink { published += 1 }
         defer { observation.cancel() }
-        delegate.dataGridDidEditCell(row: 0, column: 0, newValue: "email")
+        let committed = model.commit(
+            [DataGridCellEdit(rowID: rowID, columnID: name.id, value: .enteredText("email"))],
+            actionName: String(localized: "Edit Cell")
+        )
 
+        #expect(committed)
         #expect(published > 0)
         #expect(draft.compositionKey(scope: scope) != keyBefore)
     }
diff --git a/apple/TableProTests/Views/Structure/StructureEditingSessionTests.swift b/apple/TableProTests/Views/Structure/StructureEditingSessionTests.swift
index b05ab59f61..bdb7f6f6b4 100644
--- a/apple/TableProTests/Views/Structure/StructureEditingSessionTests.swift
+++ b/apple/TableProTests/Views/Structure/StructureEditingSessionTests.swift
@@ -1,14 +1,13 @@
-// A structure tab's staged edits, and the ability to apply them, belong to the tab. Two tabs on
-// one table are two editors, and Save has to reach the work whether or not a structure view is on
-// screen to hear it.
+// A structure tab's staged edits and its Save belong to the tab, whether or not a structure view is on screen.
 
+import AppKit
 import Foundation
 @testable import TablePro
 import TableProPluginKit
 import TableProTestSupport
 import Testing
 
-/// A save suspends first inside its composition, so a gate there holds it mid-save.
+// A save suspends first inside its composition, so a gate there holds it mid-save.
 private final class StructureSessionDriver: PluginDriverStub, @unchecked Sendable {
     private(set) var executedQueries: [String] = []
     var compositionGate: AsyncGate?
@@ -74,10 +73,7 @@ struct StructureEditingSessionTests {
 
     // MARK: - Two tabs on one table are two editors
 
-    /// The structure view used to take its SwiftUI identity from the table rather than the tab, so
-    /// two tabs on one table shared one view. Its `@State` was seeded from whichever session mounted
-    /// first and never re-seeded, so the grid went on writing into that tab's change manager while
-    /// the close prompt read the other's.
+    // A view keyed by table, not tab, shared one grid between two tabs and wrote into the first one's manager.
     @Test("Two tabs on one table stage into their own change managers")
     func sessionsOnOneTableAreIndependent() {
         let connection = TestFixtures.makeConnection()
@@ -93,22 +89,49 @@ struct StructureEditingSessionTests {
         #expect(!second.changeManager.hasChanges)
     }
 
-    /// The grid the user types into and the edits the close prompt reports have to be the same
-    /// object. They stopped being one when `StructureGridDelegate` was built in the view's `init`
-    /// and parked in `@State`, which SwiftUI seeds only at the first creation of a view identity.
-    @Test("A session's grid delegate writes into that session's change manager")
-    func gridDelegateBelongsToItsSession() {
+    // A grid owner seeded once into a view's `@State` kept writing into the first session to mount.
+    @Test("A session's grid adapter writes into that session's change manager")
+    func gridAdapterBelongsToItsSession() {
         let connection = TestFixtures.makeConnection()
         let first = Self.makeSession(connection: connection)
         let second = Self.makeSession(connection: connection)
 
-        #expect(first.gridDelegate !== second.gridDelegate)
-        #expect(first.gridDelegate.structureChangeManager === first.changeManager)
-        #expect(second.gridDelegate.structureChangeManager === second.changeManager)
+        #expect(first.gridAdapter !== second.gridAdapter)
+        #expect(first.gridModel !== second.gridModel)
+        #expect(first.gridAdapter.structureChangeManager === first.changeManager)
+        #expect(second.gridAdapter.structureChangeManager === second.changeManager)
+        #expect(first.gridAdapter.session === first)
+        #expect(first.gridAdapter.store.session === first)
     }
 
-    /// Where the user was is per tab too. Sharing it meant one tab moving to Indexes moved the
-    /// other, and a trip through the Data view lost the sub-tab, the filter and the sort.
+    @Test("A session's grid model survives the view: the adapter, not a mount, owns it")
+    func gridModelOutlivesTheView() {
+        let session = Self.makeSession(connection: TestFixtures.makeConnection())
+        Self.stageAColumn(on: session)
+        session.gridAdapter.refresh()
+        let model = session.gridModel
+
+        #expect(!model.isMounted)
+        #expect(model.rowCount == 1)
+        #expect(session.gridModel === model)
+        #expect(model.dataSource === session.gridAdapter)
+    }
+
+    @Test("The session answers the grid on screen only while a sub-tab shows one")
+    func activeGridModelFollowsTheSubTab() {
+        let session = Self.makeSession(connection: TestFixtures.makeConnection())
+
+        for tab in [StructureTab.columns, .indexes, .foreignKeys, .checkConstraints] {
+            session.selectedTab = tab
+            #expect(session.activeGridModel === session.gridModel, "\(tab.rawValue)")
+        }
+        for tab in [StructureTab.ddl, .parts, .triggers] {
+            session.selectedTab = tab
+            #expect(session.activeGridModel == nil, "\(tab.rawValue)")
+        }
+    }
+
+    // Sharing the place moved one tab to Indexes when the other did, and lost the sub-tab on a Data trip.
     @Test("Each session keeps its own place in the editor")
     func editorPlaceIsPerSession() {
         let connection = TestFixtures.makeConnection()
@@ -122,6 +145,49 @@ struct StructureEditingSessionTests {
         #expect(second.searchText.isEmpty)
     }
 
+    // MARK: - Sub-tab switch
+
+    // The switch used to commit an open edit into the incoming sub-tab's rows.
+    @Test("An edit open when the sub-tab changes commits into the column it was typed on")
+    func openEditCommitsIntoItsOwnSubTab() throws {
+        let session = Self.makeSession(connection: TestFixtures.makeConnection(database: "testdb", type: .mysql))
+        session.changeManager.loadSchema(
+            tableName: "users",
+            columns: ["id", "email"].map {
+                ColumnInfo(name: $0, dataType: "VARCHAR(64)", isNullable: true, isPrimaryKey: false)
+            },
+            indexes: ["ix_id", "ix_email"].map {
+                IndexInfo(name: $0, columns: ["id"], isUnique: false, isPrimary: false, type: "BTREE")
+            },
+            foreignKeys: [],
+            primaryKey: []
+        )
+        session.gridAdapter.refresh()
+        let controller = DataGridViewController(model: session.gridModel)
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 800, height: 400),
+            styleMask: [.titled],
+            backing: .buffered,
+            defer: false
+        )
+        window.isReleasedWhenClosed = false
+        window.contentViewController = controller
+        defer {
+            controller.dismantle()
+            window.orderOut(nil)
+        }
+        try #require(controller.beginEditingCell(row: 1, displayColumn: 0))
+        let editor = try #require(controller.editingState.editingCellView.field.currentEditor() as? NSTextView)
+        editor.string = "mail"
+
+        session.selectedTab = .indexes
+        session.gridAdapter.refresh()
+
+        #expect(session.changeManager.workingColumns.map(\.name) == ["id", "mail"])
+        #expect(session.changeManager.workingIndexes.map(\.name) == ["ix_id", "ix_email"])
+        #expect(!session.gridModel.isEditing)
+    }
+
     // MARK: - Applying without a mounted view
 
     @Test("An outcome that leaves the edits staged stands the close down")
@@ -140,14 +206,7 @@ struct StructureEditingSessionTests {
         #expect(await session.applyStagedChanges(coordinator: nil) == .nothingToApply)
     }
 
-    /// The save no longer needs a mounted structure view. This is the whole point: `hasUnsavedWork`
-    /// reads the session, so the prompt offering Save can be raised by a tab showing its Data view
-    /// or by a background tab in a batch close, and the save it offers has to reach the work.
-    ///
-    /// The ALTER lands on a pooled connection, not the session driver, because a save runs on the
-    /// schema change route. The pool is seeded here for the same reason it is in
-    /// `DatabaseManagerSchemaChangeRoutingTests`: no plugin loads under XCTest, so a pool left to
-    /// open its own connection reports the driver missing and nothing runs.
+    // hasUnsavedWork reads the session, so Save reaches the work from a Data view or a background tab; the ALTER runs on a seeded pooled connection.
     @Test("A session applies its staged edits with no view mounted")
     func applyRunsWithoutAView() async throws {
         let connection = TestFixtures.makeConnection(database: "testdb")
@@ -183,10 +242,7 @@ struct StructureEditingSessionTests {
         #expect(!session.owesRefetch, "The apply fetches everything again, which answers the change it owed")
     }
 
-    /// The gate's sheet is the one confirmation a save gets, so Cancel there is how a user backs
-    /// out. It leaves the edits staged, runs nothing, and presents nothing: answering it with an
-    /// "Error Applying Changes" sheet was a second dialog for the choice just made, and with no
-    /// window here any sheet would be an application-modal alert this test host never leaves.
+    // Cancel at the gate is the user's own choice: a second error sheet would be a modal alert this host never leaves.
     @Test("Cancelling at the gate keeps the edits staged and runs nothing")
     func cancelAtTheGateKeepsTheEdits() async throws {
         let connection = TestFixtures.makeConnection(database: "testdb")
@@ -258,10 +314,7 @@ struct StructureEditingSessionTests {
         #expect(session.changeManager.hasChanges)
     }
 
-    /// The save composes its statements before it writes, and on MongoDB composing reads the catalog,
-    /// so the gate holds it there. Before the hold, `isApplying` was raised only after composition,
-    /// so a second press passed the guard, and an edit staged meanwhile missed the script and was
-    /// then cleared with the edits that ran.
+    // Before the hold, a second press passed the guard mid-composition and an edit staged meanwhile was cleared unsaved.
     @Test("A save holds its edits from the press: a second Save and a mid-save edit are refused, and it clears only what it wrote")
     func saveHoldsItsSnapshot() async throws {
         let connection = TestFixtures.makeConnection(database: "testdb")
@@ -286,9 +339,7 @@ struct StructureEditingSessionTests {
         let manager = session.changeManager
         let pressed = manager.getChangesArray()
 
-        /// A failed `#require` leaves this save parked at the gate for good. Opening the gate after
-        /// the pool is gone would send it to an error alert with no window to hang on, which is a
-        /// modal run loop the test host never leaves.
+        // A failed #require leaves the save parked at the gate; opening it after the pool is gone raises a windowless alert.
         let first = Task { await session.applyStagedChanges(coordinator: nil) }
         await gate.arrived(1)
 
@@ -319,7 +370,7 @@ struct StructureEditingSessionTests {
         #expect(manager.hasChanges)
     }
 
-    /// Stands in for the connection the pool would open on the scope.
+    // Stands in for the connection the pool would open on the scope.
     private static func seedPooledDriver(
         _ connection: DatabaseConnection,
         scope: DatabaseScope
@@ -331,8 +382,7 @@ struct StructureEditingSessionTests {
         return driver
     }
 
-    /// A tab the server withdraws cannot stay selected, or the editor shows a grid for something
-    /// the server has none of and no segment matches the selection.
+    // A withdrawn tab cannot stay selected: no segment would match it.
     @Test("A session on Constraints moves to Columns when the server withdraws the tab")
     func withdrawnTabMovesSelection() {
         let connection = DatabaseConnection(name: "MySQL", type: .mysql)
@@ -384,8 +434,7 @@ struct StructureEditingSessionTests {
         #expect(session.selectedTab == .columns)
     }
 
-    /// A session left on DDL or Triggers is marked stale by a change made elsewhere, and its next
-    /// mount does not change the selection, so the selection handler never fetches that sub-tab.
+    // A stale session left on DDL or Triggers mounts without a selection change, so nothing else fetches that sub-tab.
     @Test("A mount fetches the sub-tab the user left selected, once, after the ones it baselines from")
     func mountFetchesTheSelectedSubTab() {
         let session = Self.makeSession(connection: TestFixtures.makeConnection())
@@ -406,9 +455,7 @@ struct StructureEditingSessionTests {
         #expect(!session.tabsFetchedOnMount.contains(.ddl))
     }
 
-    /// A change made elsewhere while edits are staged cannot be fetched without re-baselining the
-    /// change manager, which throws the edits away. Dropping it instead left a session undone back to
-    /// clean still marked loaded, so it showed the old columns and staged its next edit against them.
+    // A refetch with edits staged would re-baseline and drop them, and dropping the refetch left an undone session showing old columns.
     @Test("A change made while edits are staged is fetched once they are undone, and once only")
     func aChangeOwedWhileEditingIsFetchedOnceTheEditsAreGone() {
         let session = Self.makeSession(connection: TestFixtures.makeConnection())
diff --git a/apple/TableProTests/Views/Structure/StructureGridAdapterAddRowTests.swift b/apple/TableProTests/Views/Structure/StructureGridAdapterAddRowTests.swift
new file mode 100644
index 0000000000..c34d51cdd6
--- /dev/null
+++ b/apple/TableProTests/Views/Structure/StructureGridAdapterAddRowTests.swift
@@ -0,0 +1,204 @@
+//
+//  StructureGridAdapterAddRowTests.swift
+//  TableProTests
+//
+//  Add and Delete per sub-tab, the contract the footer +/- buttons, Cmd+Shift+N and the row menus share.
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct StructureGridAdapterAddRowTests {
+    private func makeAdapter(
+        selectedTab: StructureTab = .columns,
+        type: DatabaseType = .mysql,
+        objectKind: TableInfo.TableType = .table,
+        manager: StructureChangeManager = StructureChangeManager()
+    ) -> (StructureGridAdapter, StructureChangeManager) {
+        let adapter = StructureGridAdapter(
+            structureChangeManager: manager,
+            connection: TestFixtures.makeConnection(type: type),
+            tableName: "t",
+            databaseName: "db",
+            schemaName: nil,
+            objectKind: objectKind,
+            isSessionBound: false
+        )
+        adapter.store.switchSubTab(to: selectedTab)
+        adapter.refresh()
+        return (adapter, manager)
+    }
+
+    private func row(_ sourceIndex: Int) -> RowID {
+        StructureRowProvider.rowID(forSourceIndex: sourceIndex)
+    }
+
+    private func counts(_ manager: StructureChangeManager) -> [Int] {
+        [manager.workingColumns.count, manager.workingIndexes.count, manager.workingForeignKeys.count]
+    }
+
+    @Test("Columns sub-tab: Add Row appends a placeholder column")
+    func columnsTabAddsColumn() {
+        let (adapter, manager) = makeAdapter(selectedTab: .columns)
+        let before = manager.workingColumns.count
+        adapter.gridAddRow()
+        #expect(manager.workingColumns.count == before + 1)
+    }
+
+    @Test("Indexes sub-tab: Add Row appends a placeholder index")
+    func indexesTabAddsIndex() {
+        let (adapter, manager) = makeAdapter(selectedTab: .indexes)
+        let before = manager.workingIndexes.count
+        adapter.gridAddRow()
+        #expect(manager.workingIndexes.count == before + 1)
+    }
+
+    @Test("Foreign keys sub-tab: Add Row appends a placeholder foreign key")
+    func foreignKeysTabAddsForeignKey() {
+        let (adapter, manager) = makeAdapter(selectedTab: .foreignKeys)
+        let before = manager.workingForeignKeys.count
+        adapter.gridAddRow()
+        #expect(manager.workingForeignKeys.count == before + 1)
+    }
+
+    @Test("Add Row does nothing on a sub-tab without a grid", arguments: [StructureTab.ddl, .parts, .triggers])
+    func gridlessTabAddsNothing(tab: StructureTab) {
+        let (adapter, manager) = makeAdapter(selectedTab: tab)
+        let before = counts(manager)
+        adapter.gridAddRow()
+        #expect(counts(manager) == before)
+    }
+
+    @Test("Delete does nothing on a sub-tab without a grid", arguments: [StructureTab.ddl, .parts, .triggers])
+    func gridlessTabDeletesNothing(tab: StructureTab) {
+        let (adapter, manager) = makeAdapter(selectedTab: tab)
+        let before = counts(manager)
+        adapter.gridDeleteRows([row(0)])
+        #expect(counts(manager) == before)
+    }
+
+    // SQLite's curated snapshot overrides neither supportsAddIndex nor supportsDropIndex, so both default to true.
+    @Test("Indexes sub-tab on SQLite: Add Row appends an index")
+    func sqliteIndexesAddsAnIndex() {
+        let (adapter, manager) = makeAdapter(selectedTab: .indexes, type: .sqlite)
+        let before = manager.workingIndexes.count
+        adapter.gridAddRow()
+        #expect(manager.workingIndexes.count == before + 1)
+    }
+
+    @Test("Columns sub-tab: Delete removes the column the row names")
+    func columnsTabDeleteRemovesColumn() {
+        let (adapter, manager) = makeAdapter(selectedTab: .columns)
+        adapter.gridAddRow()
+        let after = manager.workingColumns.count
+        #expect(after > 0)
+        adapter.gridDeleteRows([row(after - 1)])
+        #expect(manager.workingColumns.count == after - 1)
+    }
+
+    @Test("Indexes sub-tab: Delete removes the index the row names")
+    func indexesTabDeleteRemovesIndex() {
+        let (adapter, manager) = makeAdapter(selectedTab: .indexes)
+        adapter.gridAddRow()
+        let after = manager.workingIndexes.count
+        #expect(after > 0)
+        adapter.gridDeleteRows([row(after - 1)])
+        #expect(manager.workingIndexes.count == after - 1)
+    }
+
+    @Test("Foreign keys sub-tab: Delete removes the foreign key the row names")
+    func foreignKeysTabDeleteRemovesForeignKey() {
+        let (adapter, manager) = makeAdapter(selectedTab: .foreignKeys)
+        adapter.gridAddRow()
+        let after = manager.workingForeignKeys.count
+        #expect(after > 0)
+        adapter.gridDeleteRows([row(after - 1)])
+        #expect(manager.workingForeignKeys.count == after - 1)
+    }
+
+    @Test("Indexes sub-tab on SQLite: Delete removes an index")
+    func sqliteIndexesDeletesAnIndex() {
+        let manager = StructureChangeManager()
+        manager.addIndex(.placeholder())
+        let (adapter, _) = makeAdapter(selectedTab: .indexes, type: .sqlite, manager: manager)
+        let before = manager.workingIndexes.count
+
+        adapter.gridDeleteRows([row(before - 1)])
+
+        #expect(manager.workingIndexes.count == before - 1)
+    }
+
+    @Test("Deleting the last row selects the row above it")
+    func deletingTheLastRowSelectsTheOneAbove() {
+        let manager = StructureChangeManager()
+        for _ in 0..<3 {
+            manager.addColumn(.placeholder())
+        }
+        let (adapter, _) = makeAdapter(selectedTab: .columns, manager: manager)
+        adapter.model.selectRows([row(2)])
+
+        adapter.gridDeleteRows([row(2)])
+
+        #expect(manager.workingColumns.count == 2)
+        #expect(adapter.model.selectedRowIDs == [row(1)])
+    }
+
+    // MARK: - Per object kind
+
+    // Cmd+Shift+N, the row menus and the footer all reach the adapter, so it refuses for itself (#2726).
+    @Test("A PostgreSQL view refuses an added column, whatever reaches the adapter")
+    func viewRefusesAnAddedColumn() {
+        let (adapter, manager) = makeAdapter(selectedTab: .columns, type: .postgresql, objectKind: .view)
+        adapter.gridAddRow()
+        #expect(manager.workingColumns.isEmpty)
+        #expect(!adapter.model.configuration.commands.contains(.addRow))
+    }
+
+    @Test("A PostgreSQL view refuses an added index and a materialized view accepts one")
+    func indexesFollowTheObjectKind() {
+        let (view, viewManager) = makeAdapter(selectedTab: .indexes, type: .postgresql, objectKind: .view)
+        view.gridAddRow()
+        #expect(viewManager.workingIndexes.isEmpty)
+
+        let (matview, matviewManager) = makeAdapter(
+            selectedTab: .indexes, type: .postgresql, objectKind: .materializedView
+        )
+        matview.gridAddRow()
+        #expect(matviewManager.workingIndexes.count == 1)
+    }
+
+    @Test("A PostgreSQL materialized view refuses a foreign key")
+    func materializedViewRefusesAForeignKey() {
+        let (adapter, manager) = makeAdapter(
+            selectedTab: .foreignKeys, type: .postgresql, objectKind: .materializedView
+        )
+        adapter.gridAddRow()
+        #expect(manager.workingForeignKeys.isEmpty)
+    }
+
+    @Test("A view refuses to drop a column its own grid is showing")
+    func viewRefusesADroppedColumn() {
+        let manager = StructureChangeManager()
+        manager.addColumn(.placeholder())
+        #expect(manager.workingColumns.count == 1)
+        let (view, _) = makeAdapter(selectedTab: .columns, type: .postgresql, objectKind: .view, manager: manager)
+
+        view.gridDeleteRows([row(0)])
+
+        #expect(manager.workingColumns.count == 1)
+        #expect(!view.model.configuration.commands.contains(.deleteRows))
+    }
+
+    @Test("A system table refuses every add", arguments: [StructureTab.columns, .indexes, .foreignKeys, .checkConstraints])
+    func systemTableRefusesEveryAdd(tab: StructureTab) {
+        let (adapter, manager) = makeAdapter(selectedTab: tab, type: .postgresql, objectKind: .systemTable)
+        adapter.gridAddRow()
+        #expect(manager.workingColumns.isEmpty)
+        #expect(manager.workingIndexes.isEmpty)
+        #expect(manager.workingForeignKeys.isEmpty)
+        #expect(manager.workingCheckConstraints.isEmpty)
+    }
+}
diff --git a/apple/TableProTests/Views/Structure/StructureGridAdapterInspectorTests.swift b/apple/TableProTests/Views/Structure/StructureGridAdapterInspectorTests.swift
new file mode 100644
index 0000000000..8137a54eb2
--- /dev/null
+++ b/apple/TableProTests/Views/Structure/StructureGridAdapterInspectorTests.swift
@@ -0,0 +1,278 @@
+//
+//  StructureGridAdapterInspectorTests.swift
+//  TableProTests
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct StructureGridAdapterInspectorTests {
+    private func connection(_ type: DatabaseType = .mysql) -> DatabaseConnection {
+        DatabaseConnection(
+            name: "Test",
+            host: "localhost",
+            port: type == .postgresql ? 5_432 : 3_306,
+            database: "test",
+            username: "root",
+            type: type
+        )
+    }
+
+    private func loadSchema(into manager: StructureChangeManager) {
+        manager.loadSchema(
+            tableName: "users",
+            columns: [
+                ColumnInfo(name: "id", dataType: "INT", isNullable: false, isPrimaryKey: true,
+                           defaultValue: nil, extra: nil, charset: nil, collation: nil, comment: nil),
+                ColumnInfo(name: "email", dataType: "VARCHAR(255)", isNullable: true, isPrimaryKey: false,
+                           defaultValue: nil, extra: nil, charset: nil, collation: nil, comment: nil)
+            ],
+            indexes: [],
+            foreignKeys: [],
+            primaryKey: ["id"]
+        )
+    }
+
+    // The session owns the adapter in the app, and its search text is what filters the provider.
+    private func makeSession(
+        type: DatabaseType = .mysql,
+        objectKind: TableInfo.TableType = .table,
+        tab: StructureTab = .columns,
+        searchText: String = ""
+    ) -> StructureEditingSession {
+        let session = StructureEditingSession(
+            identity: "test.users",
+            connection: connection(type),
+            databaseName: "test",
+            schemaName: nil,
+            tableName: "users",
+            objectKind: objectKind
+        )
+        loadSchema(into: session.changeManager)
+        session.selectedTab = tab
+        session.searchText = searchText
+        session.gridAdapter.refresh()
+        return session
+    }
+
+    private func fieldIndex(_ adapter: StructureGridAdapter, _ field: StructureColumnField) throws -> Int {
+        try #require(adapter.provider.orderedColumnFields.firstIndex(of: field))
+    }
+
+    @Test("A row is read-only while a save holds the edits, and editable again once it lets go")
+    func heldSaveMakesTheRowReadOnly() throws {
+        let session = makeSession()
+        let manager = session.changeManager
+        let adapter = session.gridAdapter
+        var email = try #require(manager.workingColumns.first { $0.name == "email" })
+        email.comment = "Contact"
+        manager.updateColumn(id: email.id, with: email)
+        adapter.refresh()
+
+        let snapshot = try #require(manager.holdForSave())
+        #expect(adapter.inspectorRow(atDisplayRow: 1)?.isEditable == false)
+
+        manager.releaseHold(snapshot, written: false)
+        #expect(adapter.inspectorRow(atDisplayRow: 1)?.isEditable == true)
+    }
+
+    // A hold changes no row, so the inspector kept the fields it built before the save and dropped what was typed.
+    @Test("A save hold and its release each rebuild the inspector")
+    func heldSaveRebuildsTheInspector() throws {
+        let fixture = CoordinatorFixture(connection: connection())
+        let session = makeSession()
+        let manager = session.changeManager
+        let adapter = session.gridAdapter
+        adapter.coordinator = fixture.coordinator
+        var email = try #require(manager.workingColumns.first { $0.name == "email" })
+        email.comment = "Contact"
+        manager.updateColumn(id: email.id, with: email)
+        adapter.refresh()
+        let beforeHold = fixture.coordinator.inspectorRowSourceRevision
+
+        let snapshot = try #require(manager.holdForSave())
+        adapter.refresh()
+        #expect(fixture.coordinator.inspectorRowSourceRevision == beforeHold + 1)
+
+        manager.releaseHold(snapshot, written: false)
+        adapter.refresh()
+        #expect(fixture.coordinator.inspectorRowSourceRevision == beforeHold + 2)
+    }
+
+    @Test("The published row describes the structure grid, not the data grid")
+    func publishedRowDescribesStructure() throws {
+        let session = makeSession()
+        let adapter = session.gridAdapter
+        let row = try #require(adapter.inspectorRow(atDisplayRow: 1))
+
+        #expect(row.fields.map(\.name) == adapter.provider.orderedColumnFields.map(\.displayName))
+        #expect(row.fields.first?.value == "email")
+    }
+
+    @Test("An inspector edit lands on the column the display row points at under a search")
+    func editResolvesFilteredDisplayRow() throws {
+        let session = makeSession(searchText: "email")
+        let adapter = session.gridAdapter
+        #expect(adapter.model.rowCount == 1)
+
+        adapter.commitInspectorField(
+            displayRow: 0,
+            fieldIndex: try fieldIndex(adapter, .name),
+            value: "user_email"
+        )
+
+        #expect(session.changeManager.workingColumns[0].name == "id")
+        #expect(session.changeManager.workingColumns[1].name == "user_email")
+    }
+
+    @Test("An inspector edit records a pending schema change")
+    func editRecordsPendingChange() throws {
+        let session = makeSession()
+        let adapter = session.gridAdapter
+
+        adapter.commitInspectorField(
+            displayRow: 1,
+            fieldIndex: try fieldIndex(adapter, .type),
+            value: "TEXT"
+        )
+
+        #expect(session.changeManager.hasChanges)
+        #expect(session.changeManager.workingColumns[1].dataType == "TEXT")
+    }
+
+    @Test("A flag field commits the value the dropdown offers")
+    func flagEditCommitsBooleanValue() throws {
+        let session = makeSession()
+        let adapter = session.gridAdapter
+
+        adapter.commitInspectorField(
+            displayRow: 1,
+            fieldIndex: try fieldIndex(adapter, .nullable),
+            value: "NO"
+        )
+
+        #expect(session.changeManager.workingColumns[1].isNullable == false)
+    }
+
+    // A Foreign Keys inspector built before a reference list arrived holds only "Loading…" until it rebuilds.
+    @Test("A reference list landing rebuilds the structure inspector")
+    func referenceListArrivalRebuildsInspector() {
+        let fixture = CoordinatorFixture(connection: connection())
+        let session = makeSession(tab: .foreignKeys)
+        session.gridAdapter.coordinator = fixture.coordinator
+        let revision = fixture.coordinator.inspectorRowSourceRevision
+
+        session.gridAdapter.referenceMenus.onListsChanged?()
+
+        #expect(fixture.coordinator.inspectorRowSourceRevision == revision + 1)
+    }
+
+    @Test("Before its first refresh the adapter publishes nothing")
+    func beforeRefreshPublishesNothing() {
+        let manager = StructureChangeManager()
+        loadSchema(into: manager)
+        let adapter = StructureGridAdapter(
+            structureChangeManager: manager,
+            connection: connection(),
+            tableName: "users",
+            databaseName: "test",
+            schemaName: nil,
+            objectKind: .table,
+            isSessionBound: false
+        )
+
+        #expect(adapter.inspectorRow(atDisplayRow: 0) == nil)
+    }
+
+    @Test("The new-table grid publishes its own rows and takes edits")
+    func createTableAdapterPublishesRows() throws {
+        let manager = StructureChangeManager()
+        manager.addNewColumn()
+        let adapter = CreateTableGridAdapter(structureChangeManager: manager, connection: connection())
+        adapter.refresh()
+
+        let row = try #require(adapter.inspectorRow(atDisplayRow: 0))
+        #expect(row.isEditable)
+
+        let nameIndex = try #require(adapter.provider.orderedColumnFields.firstIndex(of: .name))
+        adapter.commitInspectorField(displayRow: 0, fieldIndex: nameIndex, value: "sku")
+        #expect(manager.workingColumns[0].name == "sku")
+    }
+
+    // MARK: - A kind that locks fields
+
+    // The grid locked a materialized view's Type, Nullable and Default while the inspector offered all three.
+    private func makeMaterializedView(tab: StructureTab = .columns) -> StructureEditingSession {
+        makeSession(type: .postgresql, objectKind: .materializedView, tab: tab)
+    }
+
+    @Test("A materialized view's inspector locks the fields its grid locks")
+    func materializedViewInspectorLocksFields() throws {
+        let adapter = makeMaterializedView().gridAdapter
+        let row = try #require(adapter.inspectorRow(atDisplayRow: 1))
+
+        #expect(row.isEditable)
+        #expect(row.fields[try fieldIndex(adapter, .name)].isEditable)
+        #expect(row.fields[try fieldIndex(adapter, .comment)].isEditable)
+        #expect(!row.fields[try fieldIndex(adapter, .type)].isEditable)
+        #expect(!row.fields[try fieldIndex(adapter, .nullable)].isEditable)
+        #expect(!row.fields[try fieldIndex(adapter, .defaultValue)].isEditable)
+    }
+
+    @Test("The grid locks the same headings the inspector locks")
+    func gridLocksTheSameHeadings() throws {
+        let adapter = makeMaterializedView().gridAdapter
+        let headings = adapter.provider.columns
+        let locked = adapter.model.configuration.lockedColumns
+
+        #expect(locked.contains(headings[try fieldIndex(adapter, .type)]))
+        #expect(locked.contains(headings[try fieldIndex(adapter, .nullable)]))
+        #expect(!locked.contains(headings[try fieldIndex(adapter, .name)]))
+    }
+
+    @Test("A locked field refuses the edit even when it arrives through the inspector")
+    func lockedFieldRefusesTheCommit() throws {
+        let session = makeMaterializedView()
+        let adapter = session.gridAdapter
+
+        adapter.commitInspectorField(displayRow: 1, fieldIndex: try fieldIndex(adapter, .type), value: "TEXT")
+        adapter.commitInspectorField(displayRow: 1, fieldIndex: try fieldIndex(adapter, .defaultValue), value: "'x'")
+
+        #expect(!session.changeManager.hasChanges)
+        #expect(session.changeManager.workingColumns[1].dataType == "VARCHAR(255)")
+        #expect(session.changeManager.workingColumns[1].defaultValue == nil)
+    }
+
+    @Test("An unlocked field on the same object still takes the edit")
+    func unlockedFieldTakesTheCommit() throws {
+        let session = makeMaterializedView()
+        let adapter = session.gridAdapter
+
+        adapter.commitInspectorField(displayRow: 1, fieldIndex: try fieldIndex(adapter, .name), value: "mail")
+
+        #expect(session.changeManager.workingColumns[1].name == "mail")
+    }
+
+    @Test("A table locks nothing, so every field stays open")
+    func tableLocksNothing() {
+        let adapter = makeSession().gridAdapter
+        #expect(adapter.lockedFieldIndices.isEmpty)
+        #expect(adapter.model.configuration.lockedColumns.isEmpty)
+    }
+
+    @Test("The row commands offer Delete only where the object accepts the drop")
+    func rowCommandsFollowTheGate() {
+        let columns = makeMaterializedView(tab: .columns).gridAdapter
+        #expect(!columns.canStageRemoveForSelectedTab)
+        #expect(!columns.canStageAddForSelectedTab)
+        #expect(columns.model.configuration.commands.isDisjoint(with: [.deleteRows, .addRow, .duplicateRows]))
+
+        let indexes = makeMaterializedView(tab: .indexes).gridAdapter
+        #expect(indexes.canStageRemoveForSelectedTab)
+        #expect(indexes.canStageAddForSelectedTab)
+        #expect(indexes.model.configuration.commands.isSuperset(of: [.deleteRows, .addRow, .duplicateRows]))
+    }
+}
diff --git a/apple/TableProTests/Views/Structure/StructureGridDelegateAddRowTests.swift b/apple/TableProTests/Views/Structure/StructureGridDelegateAddRowTests.swift
deleted file mode 100644
index 16f3dcbb6e..0000000000
--- a/apple/TableProTests/Views/Structure/StructureGridDelegateAddRowTests.swift
+++ /dev/null
@@ -1,250 +0,0 @@
-//
-//  StructureGridDelegateAddRowTests.swift
-//  TableProTests
-//
-//  Tests for StructureGridDelegate.dataGridAddRow() / dataGridDeleteRows(_:)
-//  routing per active sub-tab. These cover the contract the new structure
-//  footer +/- buttons depend on.
-//
-
-import Foundation
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-struct StructureGridDelegateAddRowTests {
-    private func makeDelegate(
-        selectedTab: StructureTab = .columns,
-        type: DatabaseType = .mysql,
-        objectKind: TableInfo.TableType = .table
-    ) -> (StructureGridDelegate, StructureChangeManager) {
-        let manager = StructureChangeManager()
-        let connection = TestFixtures.makeConnection(type: type)
-        let delegate = StructureGridDelegate(
-            structureChangeManager: manager,
-            selectedTab: selectedTab,
-            connection: connection,
-            tableName: "t",
-            objectKind: objectKind,
-            coordinator: nil
-        )
-        return (delegate, manager)
-    }
-
-    @Test("Columns sub-tab: dataGridAddRow appends a placeholder column")
-    func columnsTab_addsColumn() {
-        let (delegate, manager) = makeDelegate(selectedTab: .columns)
-        let before = manager.workingColumns.count
-        delegate.dataGridAddRow()
-        #expect(manager.workingColumns.count == before + 1)
-    }
-
-    @Test("Indexes sub-tab: dataGridAddRow appends a placeholder index")
-    func indexesTab_addsIndex() {
-        let (delegate, manager) = makeDelegate(selectedTab: .indexes)
-        let before = manager.workingIndexes.count
-        delegate.dataGridAddRow()
-        #expect(manager.workingIndexes.count == before + 1)
-    }
-
-    @Test("Foreign keys sub-tab: dataGridAddRow appends a placeholder foreign key")
-    func foreignKeysTab_addsForeignKey() {
-        let (delegate, manager) = makeDelegate(selectedTab: .foreignKeys)
-        let before = manager.workingForeignKeys.count
-        delegate.dataGridAddRow()
-        #expect(manager.workingForeignKeys.count == before + 1)
-    }
-
-    @Test("DDL sub-tab: dataGridAddRow is a no-op")
-    func ddlTab_isNoOp() {
-        let (delegate, manager) = makeDelegate(selectedTab: .ddl)
-        let columnsBefore = manager.workingColumns.count
-        let indexesBefore = manager.workingIndexes.count
-        let fksBefore = manager.workingForeignKeys.count
-        delegate.dataGridAddRow()
-        #expect(manager.workingColumns.count == columnsBefore)
-        #expect(manager.workingIndexes.count == indexesBefore)
-        #expect(manager.workingForeignKeys.count == fksBefore)
-    }
-
-    @Test("Parts sub-tab: dataGridAddRow is a no-op")
-    func partsTab_isNoOp() {
-        let (delegate, manager) = makeDelegate(selectedTab: .parts)
-        let columnsBefore = manager.workingColumns.count
-        let indexesBefore = manager.workingIndexes.count
-        let fksBefore = manager.workingForeignKeys.count
-        delegate.dataGridAddRow()
-        #expect(manager.workingColumns.count == columnsBefore)
-        #expect(manager.workingIndexes.count == indexesBefore)
-        #expect(manager.workingForeignKeys.count == fksBefore)
-    }
-
-    @Test("Triggers sub-tab: dataGridAddRow is a no-op")
-    func triggersTab_isNoOp() {
-        let (delegate, manager) = makeDelegate(selectedTab: .triggers)
-        let columnsBefore = manager.workingColumns.count
-        let indexesBefore = manager.workingIndexes.count
-        let fksBefore = manager.workingForeignKeys.count
-        delegate.dataGridAddRow()
-        #expect(manager.workingColumns.count == columnsBefore)
-        #expect(manager.workingIndexes.count == indexesBefore)
-        #expect(manager.workingForeignKeys.count == fksBefore)
-    }
-
-    @Test("Delete: triggers sub-tab is a no-op")
-    func triggersTab_deleteIsNoOp() {
-        let (delegate, manager) = makeDelegate(selectedTab: .triggers)
-        let columnsBefore = manager.workingColumns.count
-        let indexesBefore = manager.workingIndexes.count
-        let fksBefore = manager.workingForeignKeys.count
-        delegate.dataGridDeleteRows([0])
-        #expect(manager.workingColumns.count == columnsBefore)
-        #expect(manager.workingIndexes.count == indexesBefore)
-        #expect(manager.workingForeignKeys.count == fksBefore)
-    }
-
-    /// SQLite's curated snapshot overrides neither `supportsAddIndex` nor `supportsDropIndex`, so
-    /// both default to true, which matches an engine that has `CREATE INDEX` and `DROP INDEX`.
-    /// These two asserted the opposite and were quarantined for it.
-    @Test("Indexes sub-tab on SQLite: dataGridAddRow appends an index")
-    func sqliteIndexesAddsAnIndex() {
-        let (delegate, manager) = makeDelegate(selectedTab: .indexes, type: .sqlite)
-        let before = manager.workingIndexes.count
-
-        delegate.dataGridAddRow()
-
-        #expect(manager.workingIndexes.count == before + 1)
-    }
-
-    @Test("Delete: ddl sub-tab is a no-op")
-    func ddlTab_deleteIsNoOp() {
-        let (delegate, manager) = makeDelegate(selectedTab: .ddl)
-        let columnsBefore = manager.workingColumns.count
-        let indexesBefore = manager.workingIndexes.count
-        let fksBefore = manager.workingForeignKeys.count
-        delegate.dataGridDeleteRows([0])
-        #expect(manager.workingColumns.count == columnsBefore)
-        #expect(manager.workingIndexes.count == indexesBefore)
-        #expect(manager.workingForeignKeys.count == fksBefore)
-    }
-
-    @Test("Delete: parts sub-tab is a no-op")
-    func partsTab_deleteIsNoOp() {
-        let (delegate, manager) = makeDelegate(selectedTab: .parts)
-        let columnsBefore = manager.workingColumns.count
-        let indexesBefore = manager.workingIndexes.count
-        let fksBefore = manager.workingForeignKeys.count
-        delegate.dataGridDeleteRows([0])
-        #expect(manager.workingColumns.count == columnsBefore)
-        #expect(manager.workingIndexes.count == indexesBefore)
-        #expect(manager.workingForeignKeys.count == fksBefore)
-    }
-
-    @Test("Columns sub-tab: dataGridDeleteRows removes the selected column")
-    func columnsTab_deleteRemovesColumn() {
-        let (delegate, manager) = makeDelegate(selectedTab: .columns)
-        delegate.dataGridAddRow()
-        let after = manager.workingColumns.count
-        #expect(after > 0)
-        delegate.dataGridDeleteRows([after - 1])
-        #expect(manager.workingColumns.count == after - 1)
-    }
-
-    @Test("Indexes sub-tab: dataGridDeleteRows removes the selected index")
-    func indexesTab_deleteRemovesIndex() {
-        let (delegate, manager) = makeDelegate(selectedTab: .indexes)
-        delegate.dataGridAddRow()
-        let after = manager.workingIndexes.count
-        #expect(after > 0)
-        delegate.dataGridDeleteRows([after - 1])
-        #expect(manager.workingIndexes.count == after - 1)
-    }
-
-    @Test("Foreign keys sub-tab: dataGridDeleteRows removes the selected foreign key")
-    func foreignKeysTab_deleteRemovesForeignKey() {
-        let (delegate, manager) = makeDelegate(selectedTab: .foreignKeys)
-        delegate.dataGridAddRow()
-        let after = manager.workingForeignKeys.count
-        #expect(after > 0)
-        delegate.dataGridDeleteRows([after - 1])
-        #expect(manager.workingForeignKeys.count == after - 1)
-    }
-
-    @Test("Indexes sub-tab on SQLite: dataGridDeleteRows is a no-op (supportsDropIndex == false)")
-    func sqliteIndexesDeletesAnIndex() {
-        let (delegate, manager) = makeDelegate(selectedTab: .indexes, type: .sqlite)
-        manager.addIndex(.placeholder())
-        let before = manager.workingIndexes.count
-
-        delegate.dataGridDeleteRows([before - 1])
-
-        #expect(manager.workingIndexes.count == before - 1)
-    }
-
-    // MARK: - Per object kind
-
-    /// The footer pair is not the only way in. Cmd+Shift+N reaches `dataGridAddRow` through
-    /// `structureActions`, the row and empty-space menus reach it directly, and none of them consults
-    /// the dimmed button, so the delegate has to refuse for itself. (#2726)
-    @Test("A PostgreSQL view refuses an added column, whatever reaches the delegate")
-    func viewRefusesAnAddedColumn() {
-        let (delegate, manager) = makeDelegate(selectedTab: .columns, type: .postgresql, objectKind: .view)
-        delegate.dataGridAddRow()
-        #expect(manager.workingColumns.isEmpty)
-    }
-
-    @Test("A PostgreSQL view refuses an added index and a materialized view accepts one")
-    func indexesFollowTheObjectKind() {
-        let (view, viewManager) = makeDelegate(selectedTab: .indexes, type: .postgresql, objectKind: .view)
-        view.dataGridAddRow()
-        #expect(viewManager.workingIndexes.isEmpty)
-
-        let (matview, matviewManager) = makeDelegate(
-            selectedTab: .indexes, type: .postgresql, objectKind: .materializedView
-        )
-        matview.dataGridAddRow()
-        #expect(matviewManager.workingIndexes.count == 1)
-    }
-
-    @Test("A PostgreSQL materialized view refuses a foreign key")
-    func materializedViewRefusesAForeignKey() {
-        let (delegate, manager) = makeDelegate(
-            selectedTab: .foreignKeys, type: .postgresql, objectKind: .materializedView
-        )
-        delegate.dataGridAddRow()
-        #expect(manager.workingForeignKeys.isEmpty)
-    }
-
-    @Test("A view refuses to drop a column its own grid is showing")
-    func viewRefusesADroppedColumn() {
-        let manager = StructureChangeManager()
-        manager.addColumn(.placeholder())
-        let before = manager.workingColumns.count
-        #expect(before == 1)
-
-        let view = StructureGridDelegate(
-            structureChangeManager: manager,
-            selectedTab: .columns,
-            connection: TestFixtures.makeConnection(type: .postgresql),
-            tableName: "v_sales",
-            objectKind: .view,
-            coordinator: nil
-        )
-        view.dataGridDeleteRows([0])
-
-        #expect(manager.workingColumns.count == before)
-    }
-
-    @Test("A system table refuses every add")
-    func systemTableRefusesEveryAdd() {
-        for tab in [StructureTab.columns, .indexes, .foreignKeys, .checkConstraints] {
-            let (delegate, manager) = makeDelegate(selectedTab: tab, type: .postgresql, objectKind: .systemTable)
-            delegate.dataGridAddRow()
-            #expect(manager.workingColumns.isEmpty, "\(tab.rawValue)")
-            #expect(manager.workingIndexes.isEmpty, "\(tab.rawValue)")
-            #expect(manager.workingForeignKeys.isEmpty, "\(tab.rawValue)")
-            #expect(manager.workingCheckConstraints.isEmpty, "\(tab.rawValue)")
-        }
-    }
-}
diff --git a/apple/TableProTests/Views/Structure/StructureGridDelegateInspectorTests.swift b/apple/TableProTests/Views/Structure/StructureGridDelegateInspectorTests.swift
deleted file mode 100644
index a9e9737a3f..0000000000
--- a/apple/TableProTests/Views/Structure/StructureGridDelegateInspectorTests.swift
+++ /dev/null
@@ -1,282 +0,0 @@
-//
-//  StructureGridDelegateInspectorTests.swift
-//  TableProTests
-//
-
-import Foundation
-@testable import TablePro
-import TableProPluginKit
-import Testing
-
-@MainActor
-struct StructureGridDelegateInspectorTests {
-    private func connection() -> DatabaseConnection {
-        DatabaseConnection(
-            name: "Test",
-            host: "localhost",
-            port: 3_306,
-            database: "test",
-            username: "root",
-            type: .mysql
-        )
-    }
-
-    private func loadedManager() -> StructureChangeManager {
-        let manager = StructureChangeManager()
-        manager.loadSchema(
-            tableName: "users",
-            columns: [
-                ColumnInfo(name: "id", dataType: "INT", isNullable: false, isPrimaryKey: true,
-                           defaultValue: nil, extra: nil, charset: nil, collation: nil, comment: nil),
-                ColumnInfo(name: "email", dataType: "VARCHAR(255)", isNullable: true, isPrimaryKey: false,
-                           defaultValue: nil, extra: nil, charset: nil, collation: nil, comment: nil)
-            ],
-            indexes: [],
-            foreignKeys: [],
-            primaryKey: ["id"]
-        )
-        return manager
-    }
-
-    private func makeDelegate(
-        manager: StructureChangeManager,
-        filterText: String? = nil
-    ) -> StructureGridDelegate {
-        let delegate = StructureGridDelegate(
-            structureChangeManager: manager,
-            selectedTab: .columns,
-            connection: connection(),
-            tableName: "users",
-            coordinator: nil
-        )
-        let provider = StructureRowProvider(
-            changeManager: manager,
-            tab: .columns,
-            databaseType: .mysql,
-            additionalFields: [.primaryKey],
-            serverSupport: .unrestricted,
-            filterText: filterText
-        )
-        delegate.currentProvider = provider
-        delegate.orderedFields = provider.orderedColumnFields
-        return delegate
-    }
-
-    private func fieldIndex(_ delegate: StructureGridDelegate, _ field: StructureColumnField) throws -> Int {
-        try #require(delegate.orderedFields.firstIndex(of: field))
-    }
-
-    @Test("A row is read-only while a save holds the edits, and editable again once it lets go")
-    func heldSaveMakesTheRowReadOnly() throws {
-        let manager = loadedManager()
-        let delegate = makeDelegate(manager: manager)
-        var email = try #require(manager.workingColumns.first { $0.name == "email" })
-        email.comment = "Contact"
-        manager.updateColumn(id: email.id, with: email)
-
-        let snapshot = try #require(manager.holdForSave())
-        #expect(delegate.inspectorRow(atDisplayRow: 1)?.isEditable == false)
-
-        manager.releaseHold(snapshot, written: false)
-        #expect(delegate.inspectorRow(atDisplayRow: 1)?.isEditable == true)
-    }
-
-    @Test("The published row describes the structure grid, not the data grid")
-    func publishedRowDescribesStructure() throws {
-        let delegate = makeDelegate(manager: loadedManager())
-        let row = try #require(delegate.inspectorRow(atDisplayRow: 1))
-
-        #expect(row.fields.map(\.name) == delegate.orderedFields.map(\.displayName))
-        #expect(row.fields.first?.value == "email")
-    }
-
-    @Test("An inspector edit lands on the column the display row points at")
-    func editResolvesFilteredDisplayRow() throws {
-        let manager = loadedManager()
-        let delegate = makeDelegate(manager: manager, filterText: "email")
-
-        delegate.commitInspectorField(
-            displayRow: 0,
-            fieldIndex: try fieldIndex(delegate, .name),
-            value: "user_email"
-        )
-
-        #expect(manager.workingColumns[0].name == "id")
-        #expect(manager.workingColumns[1].name == "user_email")
-    }
-
-    @Test("An inspector edit records a pending schema change")
-    func editRecordsPendingChange() throws {
-        let manager = loadedManager()
-        let delegate = makeDelegate(manager: manager)
-
-        delegate.commitInspectorField(
-            displayRow: 1,
-            fieldIndex: try fieldIndex(delegate, .type),
-            value: "TEXT"
-        )
-
-        #expect(manager.hasChanges)
-        #expect(manager.workingColumns[1].dataType == "TEXT")
-    }
-
-    @Test("A flag field commits the value the dropdown offers")
-    func flagEditCommitsBooleanValue() throws {
-        let manager = loadedManager()
-        let delegate = makeDelegate(manager: manager)
-
-        delegate.commitInspectorField(
-            displayRow: 1,
-            fieldIndex: try fieldIndex(delegate, .nullable),
-            value: "NO"
-        )
-
-        #expect(manager.workingColumns[1].isNullable == false)
-    }
-
-    /// The Foreign Keys inspector offers the same reference lists the grid does. One built before a
-    /// list arrived holds only `Loading…`, and nothing rebuilt it, because only Create Table moved
-    /// the inspector's revision when a list landed.
-    @Test("A reference list landing rebuilds the structure inspector")
-    func referenceListArrivalRebuildsInspector() {
-        let coordinator = MainContentCoordinator(
-            connection: connection(),
-            tabManager: QueryTabManager(),
-            changeManager: DataChangeManager(),
-            toolbarState: ConnectionToolbarState()
-        )
-        let delegate = StructureGridDelegate(
-            structureChangeManager: loadedManager(),
-            selectedTab: .foreignKeys,
-            connection: connection(),
-            tableName: "users",
-            coordinator: coordinator
-        )
-        let revision = coordinator.inspectorRowSourceRevision
-
-        delegate.referenceMenus.onListsChanged?()
-
-        #expect(coordinator.inspectorRowSourceRevision == revision + 1)
-    }
-
-    @Test("Without a provider the delegate publishes nothing")
-    func withoutProviderPublishesNothing() {
-        let delegate = StructureGridDelegate(
-            structureChangeManager: loadedManager(),
-            selectedTab: .columns,
-            connection: connection(),
-            tableName: "users",
-            coordinator: nil
-        )
-
-        #expect(delegate.inspectorRow(atDisplayRow: 0) == nil)
-    }
-
-    @Test("The new-table grid publishes its own rows and takes edits")
-    func createTableDelegatePublishesRows() throws {
-        let manager = StructureChangeManager()
-        manager.addNewColumn()
-        let delegate = CreateTableGridDelegate(
-            structureChangeManager: manager,
-            structureTab: .columns,
-            connection: connection()
-        )
-        let provider = StructureRowProvider(
-            changeManager: manager,
-            tab: .columns,
-            databaseType: .mysql,
-            additionalFields: [.primaryKey],
-            serverSupport: .unrestricted
-        )
-        delegate.orderedFields = provider.orderedColumnFields
-
-        let row = try #require(delegate.inspectorRow(atDisplayRow: 0))
-        #expect(row.isEditable)
-
-        let nameIndex = try #require(delegate.orderedFields.firstIndex(of: .name))
-        delegate.commitInspectorField(displayRow: 0, fieldIndex: nameIndex, value: "sku")
-        #expect(manager.workingColumns[0].name == "sku")
-    }
-
-    // MARK: - A kind that locks fields
-
-    /// The grid locked a materialized view's Type, Nullable and Default, while the inspector beside
-    /// it offered all three and staged an `ALTER COLUMN` PostgreSQL always refuses on a matview.
-    private func makeMaterializedViewDelegate(
-        manager: StructureChangeManager,
-        tab: StructureTab = .columns
-    ) -> StructureGridDelegate {
-        let connection = DatabaseConnection(
-            name: "Test", host: "localhost", port: 5_432, database: "shop", username: "postgres", type: .postgresql
-        )
-        let delegate = StructureGridDelegate(
-            structureChangeManager: manager,
-            selectedTab: tab,
-            connection: connection,
-            tableName: "daily_totals",
-            objectKind: .materializedView,
-            coordinator: nil
-        )
-        let provider = StructureRowProvider(
-            changeManager: manager,
-            tab: tab,
-            databaseType: .postgresql,
-            serverSupport: .unrestricted
-        )
-        delegate.currentProvider = provider
-        delegate.orderedFields = provider.orderedColumnFields
-        return delegate
-    }
-
-    @Test("A materialized view's inspector locks the fields its grid locks")
-    func materializedViewInspectorLocksFields() throws {
-        let delegate = makeMaterializedViewDelegate(manager: loadedManager())
-        let row = try #require(delegate.inspectorRow(atDisplayRow: 1))
-
-        #expect(row.isEditable)
-        #expect(row.fields[try fieldIndex(delegate, .name)].isEditable)
-        #expect(row.fields[try fieldIndex(delegate, .comment)].isEditable)
-        #expect(!row.fields[try fieldIndex(delegate, .type)].isEditable)
-        #expect(!row.fields[try fieldIndex(delegate, .nullable)].isEditable)
-        #expect(!row.fields[try fieldIndex(delegate, .defaultValue)].isEditable)
-    }
-
-    @Test("A locked field refuses the edit even when it arrives through the inspector")
-    func lockedFieldRefusesTheCommit() throws {
-        let manager = loadedManager()
-        let delegate = makeMaterializedViewDelegate(manager: manager)
-
-        delegate.commitInspectorField(displayRow: 1, fieldIndex: try fieldIndex(delegate, .type), value: "TEXT")
-        delegate.commitInspectorField(displayRow: 1, fieldIndex: try fieldIndex(delegate, .defaultValue), value: "'x'")
-
-        #expect(!manager.hasChanges)
-        #expect(manager.workingColumns[1].dataType == "VARCHAR(255)")
-        #expect(manager.workingColumns[1].defaultValue == nil)
-    }
-
-    @Test("An unlocked field on the same object still takes the edit")
-    func unlockedFieldTakesTheCommit() throws {
-        let manager = loadedManager()
-        let delegate = makeMaterializedViewDelegate(manager: manager)
-
-        delegate.commitInspectorField(displayRow: 1, fieldIndex: try fieldIndex(delegate, .name), value: "mail")
-
-        #expect(manager.workingColumns[1].name == "mail")
-    }
-
-    @Test("A table locks nothing, so every field stays open")
-    func tableLocksNothing() {
-        #expect(makeDelegate(manager: loadedManager()).lockedFieldIndices.isEmpty)
-    }
-
-    @Test("The row menu offers Delete only where the object accepts the drop")
-    func rowMenuFollowsTheGate() {
-        let columns = makeMaterializedViewDelegate(manager: loadedManager(), tab: .columns)
-        #expect(!columns.canStageRemoveForSelectedTab)
-        #expect(!columns.canStageAddForSelectedTab)
-
-        let indexes = makeMaterializedViewDelegate(manager: loadedManager(), tab: .indexes)
-        #expect(indexes.canStageRemoveForSelectedTab)
-        #expect(indexes.canStageAddForSelectedTab)
-    }
-}
diff --git a/apple/TableProTests/Views/Structure/StructureGridStateStoreTests.swift b/apple/TableProTests/Views/Structure/StructureGridStateStoreTests.swift
new file mode 100644
index 0000000000..ee853acd11
--- /dev/null
+++ b/apple/TableProTests/Views/Structure/StructureGridStateStoreTests.swift
@@ -0,0 +1,137 @@
+//
+//  StructureGridStateStoreTests.swift
+//  TableProTests
+//
+//  D1: the Structure grid used to save its column widths under the table's own key, over the Data tab's layout.
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct StructureGridStateStoreTests {
+    private func makeSession(table: String = "orders_\(UUID().uuidString.prefix(8))") -> StructureEditingSession {
+        let session = StructureEditingSession(
+            identity: "shop.\(table)",
+            connection: TestFixtures.makeConnection(database: "shop", type: .mysql),
+            databaseName: "shop",
+            schemaName: nil,
+            tableName: table
+        )
+        session.changeManager.loadSchema(
+            tableName: table,
+            columns: [
+                ColumnInfo(name: "id", dataType: "INT", isNullable: false, isPrimaryKey: true),
+                ColumnInfo(name: "total", dataType: "DECIMAL(10,2)", isNullable: true, isPrimaryKey: false),
+            ],
+            indexes: [IndexInfo(name: "ix_total", columns: ["total"], isUnique: false, isPrimary: false, type: "BTREE")],
+            foreignKeys: [],
+            primaryKey: ["id"]
+        )
+        session.gridAdapter.refresh()
+        return session
+    }
+
+    private func nameHeading(_ session: StructureEditingSession) throws -> String {
+        try #require(session.gridModel.columns.column(at: 0)).name
+    }
+
+    @Test("A column resized in the Structure grid stays on the session and never reaches the table's saved layout")
+    func resizeNeverWritesTheTableLayout() throws {
+        let session = makeSession()
+        let model = session.gridModel
+        let name = try nameHeading(session)
+        let tableKey = ColumnLayoutTableKey(
+            connectionId: session.connection.id,
+            databaseName: "shop",
+            schemaName: nil,
+            tableName: session.tableName
+        )
+
+        model.columnGeometryDidChange(widths: [name: 260], order: nil)
+
+        #expect(model.store.layoutScope == .ephemeral)
+        #expect(session.columnLayouts[.columns]?.columnWidths[name] == 260)
+        #expect(model.store.columnLayout.columnWidths[name] == 260)
+        #expect(FileColumnLayoutPersister.shared.load(for: tableKey) == nil)
+    }
+
+    @Test("Each sub-tab keeps its own column layout")
+    func layoutIsPerSubTab() throws {
+        let session = makeSession()
+        let model = session.gridModel
+        let name = try nameHeading(session)
+        model.columnGeometryDidChange(widths: [name: 260], order: nil)
+
+        session.selectedTab = .indexes
+        session.gridAdapter.refresh()
+        #expect(model.store.columnLayout.columnWidths[name] == nil)
+        model.columnGeometryDidChange(widths: [name: 180], order: nil)
+
+        session.selectedTab = .columns
+        session.gridAdapter.refresh()
+        #expect(model.store.columnLayout.columnWidths[name] == 260)
+        #expect(session.columnLayouts[.indexes]?.columnWidths[name] == 180)
+    }
+
+    @Test("Another sub-tab starts with no value filter and no selection")
+    func subTabSwitchStartsTheViewOver() throws {
+        let session = makeSession()
+        let model = session.gridModel
+        let name = try nameHeading(session)
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: ["id"], includesNull: false), columnName: name, forColumn: 0)
+        model.setValueFilter(filter)
+        model.selectRows([StructureRowProvider.rowID(forSourceIndex: 0)])
+        #expect(model.store.valueFilter.isActive)
+        #expect(!model.selection.isEmpty)
+
+        session.selectedTab = .indexes
+        session.gridAdapter.refresh()
+
+        #expect(!model.store.valueFilter.isActive)
+        #expect(model.store.selectionSnapshot.isEmpty)
+        #expect(model.selection.isEmpty)
+        #expect(model.rowCount == 1)
+    }
+
+    @Test("The sort lives on the session, which is what orders the provider's rows")
+    func sortLivesOnTheSession() {
+        let session = makeSession()
+        let model = session.gridModel
+        let descending = SortState(columns: [SortColumn(columnIndex: 0, direction: .descending)], source: .user)
+
+        model.setSort(descending)
+
+        #expect(session.sortState == descending)
+        #expect(session.sortDescriptor?.column == 0)
+        #expect(session.sortDescriptor?.ascending == false)
+        #expect(model.rows.rows.compactMap { $0.values.first?.asText } == ["total", "id"])
+    }
+
+    // The provider sorts by one key, so a secondary key the header appended is dropped (changed on purpose).
+    @Test("A secondary sort key is dropped, since the provider sorts by one column")
+    func secondarySortKeyIsDropped() {
+        let session = makeSession()
+        let model = session.gridModel
+        let primary = SortColumn(columnIndex: 1, direction: .ascending)
+
+        model.setSort(SortState(columns: [primary, SortColumn(columnIndex: 0, direction: .descending)], source: .user))
+
+        #expect(session.sortState.columns == [primary])
+        #expect(model.store.sortState.columns == [primary])
+    }
+
+    @Test("Create Table's grid is ephemeral too")
+    func createTableIsEphemeral() {
+        let adapter = CreateTableGridAdapter(
+            structureChangeManager: StructureChangeManager(),
+            connection: TestFixtures.makeConnection(type: .postgresql)
+        )
+        adapter.refresh()
+
+        #expect(adapter.model.store.layoutScope == .ephemeral)
+    }
+}
diff --git a/apple/TableProTests/Views/Structure/StructureGridValueFilterEditTests.swift b/apple/TableProTests/Views/Structure/StructureGridValueFilterEditTests.swift
new file mode 100644
index 0000000000..38612e4914
--- /dev/null
+++ b/apple/TableProTests/Views/Structure/StructureGridValueFilterEditTests.swift
@@ -0,0 +1,156 @@
+//
+//  StructureGridValueFilterEditTests.swift
+//  TableProTests
+//
+//  D2: under the grid's value filter the Structure and Create Table grids mapped a display row to the wrong
+//  definition. Every edit now names its row by RowID, the definition's index in the working list.
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@MainActor
+struct StructureGridValueFilterEditTests {
+    private let columnNames = ["id", "email", "created_at"]
+
+    private func makeSession() -> StructureEditingSession {
+        let session = StructureEditingSession(
+            identity: "shop.users",
+            connection: TestFixtures.makeConnection(database: "shop", type: .mysql),
+            databaseName: "shop",
+            schemaName: nil,
+            tableName: "users"
+        )
+        session.changeManager.loadSchema(
+            tableName: "users",
+            columns: columnNames.map {
+                ColumnInfo(name: $0, dataType: "VARCHAR(64)", isNullable: true, isPrimaryKey: false)
+            },
+            indexes: [],
+            foreignKeys: [],
+            primaryKey: []
+        )
+        session.gridAdapter.refresh()
+        return session
+    }
+
+    // Keeps only the rows whose Name is `value`.
+    private func filterName(to value: String, on model: DataGridModel) throws {
+        let name = try #require(model.columns.column(at: 0))
+        var filter = GridValueFilterState()
+        filter.set(ColumnValueFilter(selectedValues: [value], includesNull: false), columnName: name.name, forColumn: name.dataIndex)
+        model.setValueFilter(filter)
+    }
+
+    private func commitName(_ text: String, atDisplayRow row: Int, on model: DataGridModel) throws -> Bool {
+        let rowID = try #require(model.rowID(at: row))
+        let name = try #require(model.columns.column(at: 0))
+        return model.commit([DataGridCellEdit(rowID: rowID, columnID: name.id, value: .enteredText(text))], actionName: "Edit Cell")
+    }
+
+    @Test("A Structure edit on the one row a value filter leaves lands on that column")
+    func structureEditUnderFilter() throws {
+        let session = makeSession()
+        let model = session.gridModel
+        try filterName(to: "created_at", on: model)
+        try #require(model.rowCount == 1)
+        #expect(model.rowID(at: 0) == StructureRowProvider.rowID(forSourceIndex: 2))
+
+        #expect(try commitName("created_on", atDisplayRow: 0, on: model))
+
+        #expect(session.changeManager.workingColumns.map(\.name) == ["id", "email", "created_on"])
+    }
+
+    @Test("A Structure inspector edit under a value filter lands on the row the grid shows")
+    func structureInspectorEditUnderFilter() throws {
+        let session = makeSession()
+        let adapter = session.gridAdapter
+        try filterName(to: "email", on: session.gridModel)
+        let nameField = try #require(adapter.provider.orderedColumnFields.firstIndex(of: .name))
+
+        #expect(adapter.inspectorRow(atDisplayRow: 0)?.fields.first?.value == "email")
+        adapter.commitInspectorField(displayRow: 0, fieldIndex: nameField, value: "mail")
+
+        #expect(session.changeManager.workingColumns.map(\.name) == ["id", "mail", "created_at"])
+    }
+
+    @Test("A Structure delete under a value filter marks the column the grid shows")
+    func structureDeleteUnderFilter() throws {
+        let session = makeSession()
+        let model = session.gridModel
+        try filterName(to: "email", on: model)
+        let shown = try #require(model.rowID(at: 0))
+
+        session.gridAdapter.gridDeleteRows([shown])
+
+        let manager = session.changeManager
+        #expect(manager.deleteInsertState(for: 1, tab: .columns).isDeleted)
+        #expect(!manager.deleteInsertState(for: 0, tab: .columns).isDeleted)
+        #expect(!manager.deleteInsertState(for: 2, tab: .columns).isDeleted)
+    }
+
+    @Test("A Structure edit under a sort and a value filter still lands on the row it names")
+    func structureEditUnderSortAndFilter() throws {
+        let session = makeSession()
+        let model = session.gridModel
+        model.setSort(SortState(columns: [SortColumn(columnIndex: 0, direction: .ascending)], source: .user))
+        #expect(model.rows.rows.compactMap { $0.values.first?.asText } == ["created_at", "email", "id"])
+        try filterName(to: "id", on: model)
+        #expect(model.rowID(at: 0) == StructureRowProvider.rowID(forSourceIndex: 0))
+
+        #expect(try commitName("user_id", atDisplayRow: 0, on: model))
+
+        #expect(session.changeManager.workingColumns.map(\.name) == ["user_id", "email", "created_at"])
+    }
+
+    // A value filter rearranges the list, so the drag that moves a column is withdrawn (changed on purpose).
+    @Test("A value filter withdraws the column move")
+    func valueFilterWithdrawsTheColumnMove() throws {
+        let session = makeSession()
+        let model = session.gridModel
+        try filterName(to: "email", on: model)
+
+        #expect(!model.configuration.rowReorder.isEnabled)
+        #expect(!model.configuration.commands.contains(.moveRows))
+    }
+
+    @Test("A Create Table edit on the one row a value filter leaves lands on that definition")
+    func createTableEditUnderFilter() throws {
+        let manager = StructureChangeManager()
+        for name in columnNames {
+            var column = EditableColumnDefinition.placeholder()
+            column.name = name
+            column.dataType = "TEXT"
+            manager.addColumn(column)
+        }
+        let adapter = CreateTableGridAdapter(structureChangeManager: manager, connection: TestFixtures.makeConnection(type: .postgresql))
+        adapter.refresh()
+        let model = adapter.model
+        try filterName(to: "email", on: model)
+        try #require(model.rowCount == 1)
+
+        #expect(try commitName("contact", atDisplayRow: 0, on: model))
+
+        #expect(manager.workingColumns.map(\.name) == ["id", "contact", "created_at"])
+    }
+
+    @Test("A Create Table delete under a value filter removes the definition the grid shows")
+    func createTableDeleteUnderFilter() throws {
+        let manager = StructureChangeManager()
+        for name in columnNames {
+            var column = EditableColumnDefinition.placeholder()
+            column.name = name
+            manager.addColumn(column)
+        }
+        let adapter = CreateTableGridAdapter(structureChangeManager: manager, connection: TestFixtures.makeConnection(type: .postgresql))
+        adapter.refresh()
+        try filterName(to: "created_at", on: adapter.model)
+
+        let shown = try #require(adapter.model.rowID(at: 0))
+        adapter.gridDeleteRows([shown])
+
+        #expect(manager.workingColumns.map(\.name) == ["id", "email"])
+    }
+}
diff --git a/apple/TableProTests/Views/Structure/StructureIndexTypeMenuTests.swift b/apple/TableProTests/Views/Structure/StructureIndexTypeMenuTests.swift
index 18c83c71fc..3855217c90 100644
--- a/apple/TableProTests/Views/Structure/StructureIndexTypeMenuTests.swift
+++ b/apple/TableProTests/Views/Structure/StructureIndexTypeMenuTests.swift
@@ -31,41 +31,53 @@ struct StructureIndexTypeMenuTests {
         return manager
     }
 
-    private func structureDelegate(_ manager: StructureChangeManager) -> StructureGridDelegate {
-        let delegate = StructureGridDelegate(
+    private func structureAdapter(_ manager: StructureChangeManager) -> StructureGridAdapter {
+        let adapter = StructureGridAdapter(
             structureChangeManager: manager,
-            selectedTab: .indexes,
             connection: connection(),
             tableName: "items",
-            coordinator: nil
+            databaseName: "test",
+            schemaName: nil,
+            objectKind: .table,
+            isSessionBound: false
         )
-        delegate.currentProvider = StructureRowProvider(
-            changeManager: manager,
-            tab: .indexes,
-            databaseType: .postgresql,
-            serverSupport: .unrestricted
-        )
-        return delegate
+        adapter.store.switchSubTab(to: .indexes)
+        adapter.refresh()
+        return adapter
+    }
+
+    private func column(_ model: DataGridModel, dataIndex: Int) throws -> DataGridColumn {
+        try #require(model.columns.columns.first { $0.dataIndex == dataIndex })
+    }
+
+    private func options(
+        _ source: any DataGridDataSource,
+        model: DataGridModel,
+        sourceIndex: Int,
+        dataIndex: Int
+    ) throws -> [String]? {
+        source.gridMenuOptions(
+            for: StructureRowProvider.rowID(forSourceIndex: sourceIndex),
+            column: try column(model, dataIndex: dataIndex)
+        )?.compactMap(\.sql)
     }
 
     private static let knownNames = EditableIndexDefinition.IndexType.knownTypes.map(\.rawValue)
 
     @Test("A bloom row offers BLOOM after the known types, and a b-tree row offers the known types alone")
-    func rowOffersItsOwnType() {
-        let delegate = structureDelegate(manager(indexTypes: ["bloom", "btree"]))
+    func rowOffersItsOwnType() throws {
+        let adapter = structureAdapter(manager(indexTypes: ["bloom", "btree"]))
         let typeColumn = StructureRowProvider.indexTypeColumn
 
-        #expect(delegate.dataGridMenuOptions(forRow: 0, columnIndex: typeColumn)?.compactMap(\.sql)
-            == Self.knownNames + ["BLOOM"])
-        #expect(delegate.dataGridMenuOptions(forRow: 1, columnIndex: typeColumn)?.compactMap(\.sql)
-            == Self.knownNames)
-        #expect(delegate.dataGridMenuOptions(forRow: 0, columnIndex: 3) == nil)
+        #expect(try options(adapter, model: adapter.model, sourceIndex: 0, dataIndex: typeColumn) == Self.knownNames + ["BLOOM"])
+        #expect(try options(adapter, model: adapter.model, sourceIndex: 1, dataIndex: typeColumn) == Self.knownNames)
+        #expect(try options(adapter, model: adapter.model, sourceIndex: 0, dataIndex: 3) == nil)
     }
 
     @Test("The inspector's Type picker for a CLUSTERED row holds the value it shows")
     func inspectorPickerHoldsTheRowType() throws {
-        let delegate = structureDelegate(manager(indexTypes: ["CLUSTERED"]))
-        let row = try #require(delegate.inspectorRow(atDisplayRow: 0))
+        let adapter = structureAdapter(manager(indexTypes: ["CLUSTERED"]))
+        let row = try #require(adapter.inspectorRow(atDisplayRow: 0))
         let typeField = row.fields[StructureRowProvider.indexTypeColumn]
 
         #expect(typeField.value == "CLUSTERED")
@@ -73,12 +85,12 @@ struct StructureIndexTypeMenuTests {
     }
 
     @Test("The new-table grid offers a pasted index its own type the same way")
-    func createTableOffersItsOwnType() {
-        let manager = manager(indexTypes: ["hnsw"])
-        let delegate = CreateTableGridDelegate(structureChangeManager: manager, structureTab: .indexes, connection: connection())
+    func createTableOffersItsOwnType() throws {
+        let adapter = CreateTableGridAdapter(structureChangeManager: manager(indexTypes: ["hnsw"]), connection: connection())
+        adapter.select(.indexes)
 
-        #expect(delegate.dataGridMenuOptions(forRow: 0, columnIndex: StructureRowProvider.indexTypeColumn)?
-            .compactMap(\.sql) == Self.knownNames + ["HNSW"])
+        #expect(try options(adapter, model: adapter.model, sourceIndex: 0, dataIndex: StructureRowProvider.indexTypeColumn)
+            == Self.knownNames + ["HNSW"])
     }
 
     @Test("A Type edit takes a known type and leaves the index alone for any other text")
diff --git a/apple/TableProTests/Views/Structure/StructureListGridAccessibilityTests.swift b/apple/TableProTests/Views/Structure/StructureListGridAccessibilityTests.swift
index 7f09856739..6a51846885 100644
--- a/apple/TableProTests/Views/Structure/StructureListGridAccessibilityTests.swift
+++ b/apple/TableProTests/Views/Structure/StructureListGridAccessibilityTests.swift
@@ -11,85 +11,69 @@ import Testing
 @testable import TablePro
 
 @MainActor
-private final class SpokenValueLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-@MainActor
-struct StructureListGridAccessibilityTests {
-    private struct Grid {
-        let window: NSWindow
-        let coordinator: TableViewCoordinator
-        let model: StructureListGridModel<String>
-    }
+private final class MountedStructureList {
+    let window: NSWindow
+    let controller: DataGridViewController
+    let list: StructureListGridModel<String>
 
-    private func makeGrid(columns: [String], rows: [StructureListRow<String>]) -> Grid {
-        let model = StructureListGridModel<String>()
-        let tableRows = model.ensureLoaded(key: 1, columns: columns) { rows }
-        let coordinator = TableViewCoordinator(
-            changeManager: model.changeManager,
-            isEditable: false,
-            selectedRowIndices: .constant([]),
-            delegate: model,
-            layoutPersister: SpokenValueLayoutPersister()
+    init(columns: [String], rows: [StructureListRow<String>]) {
+        list = StructureListGridModel<String>()
+        list.load(
+            columns: columns,
+            rows: rows,
+            defaultWidths: Array(repeating: 100, count: columns.count),
+            minimumWidths: [],
+            databaseType: .mysql,
+            sortState: nil
         )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView(frame: NSRect(x: 0, y: 0, width: 700, height: 200))
-        tableView.columnAutoresizingStyle = .noColumnAutoresizing
-        tableView.rowHeight = 21
-        tableView.coordinator = coordinator
-        tableView.dataSource = coordinator
-        tableView.delegate = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-        coordinator.columnPool.reconcile(
-            tableView: tableView,
-            schema: coordinator.identitySchema,
-            columnTypes: Array(repeating: ColumnType.text(rawType: nil), count: columns.count),
-            savedLayout: nil,
-            isEditable: false,
-            hiddenColumnNames: [],
-            firstClickSortDirection: .ascending,
-            widthCalculator: { _, _ in 100 }
-        )
-        let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 700, height: 200))
-        scrollView.documentView = tableView
-        let window = NSWindow(
+        controller = DataGridViewController(model: list.model)
+        window = NSWindow(
             contentRect: NSRect(x: 0, y: 0, width: 700, height: 200),
             styleMask: [.titled],
             backing: .buffered,
             defer: false
         )
         window.isReleasedWhenClosed = false
-        window.contentView = scrollView
-        model.dataGridAttach(tableViewCoordinator: coordinator)
-        tableView.reloadData()
-        tableView.layoutSubtreeIfNeeded()
-        window.layoutIfNeeded()
-        return Grid(window: window, coordinator: coordinator, model: model)
+        window.contentView = controller.view
+        controller.view.layoutSubtreeIfNeeded()
     }
 
-    private func cell(in grid: Grid, row: Int, dataColumn: Int) throws -> DataGridCellAccessibilityView {
-        let tableView = try #require(grid.coordinator.tableView)
-        let column = try #require(grid.coordinator.tableColumnIndex(for: dataColumn))
-        return try #require(
-            tableView.view(atColumn: column, row: row, makeIfNecessary: true) as? DataGridCellAccessibilityView
-        )
+    var table: DataGridTableView { controller.main.tableView }
+
+    func cell(row: Int, dataColumn: Int) throws -> DataGridAccessibilityCellView {
+        let columns = list.model.columns
+        let position = try #require(columns.displayPosition(ofDataIndex: dataColumn))
+        let index = try #require(controller.main.tableIndex(forDisplayPosition: position, columns: columns))
+        return try #require(table.view(atColumn: index, row: row, makeIfNecessary: true) as? DataGridAccessibilityCellView)
+    }
+
+    func spoken(row: Int, dataColumn: Int) throws -> String? {
+        try cell(row: row, dataColumn: dataColumn).accessibilityValue() as? String
     }
 
-    private func spoken(in grid: Grid, row: Int, dataColumn: Int) throws -> String? {
-        try cell(in: grid, row: row, dataColumn: dataColumn).accessibilityValue() as? String
+    func drawn(row: Int, dataColumn: Int) -> String? {
+        let model = list.model
+        guard let rowModel = model.row(at: row),
+              let column = model.columns.columns.first(where: { $0.dataIndex == dataColumn }),
+              let pass = controller.presenter.makePass(in: table.effectiveAppearance) else { return nil }
+        return controller.presenter.appearance(
+            of: rowModel,
+            displayRow: row,
+            column: column,
+            visualState: controller.presenter.visualState(of: rowModel),
+            pass: pass,
+            onEmphasizedSelection: false
+        )?.text
     }
 
-    private func drawn(in grid: Grid, row: Int, dataColumn: Int) -> String? {
-        grid.coordinator.cellAppearance(row: row, columnIndex: dataColumn, onEmphasizedSelection: false)?.text
+    func tearDown() {
+        controller.dismantle()
+        window.contentView = nil
     }
+}
 
+@MainActor
+struct StructureListGridAccessibilityTests {
     @Test("The Enabled column draws YES and NO and reads Enabled and Disabled")
     func triggerEnabledIsSpoken() throws {
         DataGridAccessibility.isActive = true
@@ -105,18 +89,18 @@ struct StructureListGridAccessibilityTests {
                 spokenValues: TriggerListColumns.spokenValues(for: trigger, showsEnabled: true)
             )
         }
-        let grid = makeGrid(columns: TriggerListColumns.titles(showsEnabled: true), rows: rows)
+        let grid = MountedStructureList(columns: TriggerListColumns.titles(showsEnabled: true), rows: rows)
+        defer { grid.tearDown() }
         let enabled = TriggerListColumns.enabledColumn
 
-        #expect(drawn(in: grid, row: 0, dataColumn: enabled) == "YES")
-        #expect(drawn(in: grid, row: 1, dataColumn: enabled) == "NO")
-        #expect(try spoken(in: grid, row: 0, dataColumn: enabled) == String(localized: "Enabled"))
-        #expect(try spoken(in: grid, row: 1, dataColumn: enabled) == String(localized: "Disabled"))
-        #expect(try cell(in: grid, row: 1, dataColumn: enabled).accessibilityLabel() == String(
+        #expect(grid.drawn(row: 0, dataColumn: enabled) == "YES")
+        #expect(grid.drawn(row: 1, dataColumn: enabled) == "NO")
+        #expect(try grid.spoken(row: 0, dataColumn: enabled) == String(localized: "Enabled"))
+        #expect(try grid.spoken(row: 1, dataColumn: enabled) == String(localized: "Disabled"))
+        #expect(try grid.cell(row: 1, dataColumn: enabled).accessibilityLabel() == String(
             format: String(localized: "Row %d, column %d: %@"), 2, enabled + 1, String(localized: "Disabled")
         ))
-        #expect(try spoken(in: grid, row: 0, dataColumn: TriggerListColumns.nameColumn) == "trg_on")
-        withExtendedLifetime(grid) {}
+        #expect(try grid.spoken(row: 0, dataColumn: TriggerListColumns.nameColumn) == "trg_on")
     }
 
     @Test("The Active column draws YES and NO and reads Active and Inactive")
@@ -132,27 +116,58 @@ struct StructureListGridAccessibilityTests {
             let row = ClickHousePartsView.gridRow(for: part)
             return StructureListRow(id: part.id.uuidString, values: row.values, spokenValues: row.spokenValues)
         }
-        let grid = makeGrid(columns: ClickHousePartsView.columnTitles, rows: rows)
+        let grid = MountedStructureList(columns: ClickHousePartsView.columnTitles, rows: rows)
+        defer { grid.tearDown() }
         let active = ClickHousePartsView.activeColumn
 
-        #expect(drawn(in: grid, row: 0, dataColumn: active) == "YES")
-        #expect(try spoken(in: grid, row: 0, dataColumn: active) == String(localized: "Active"))
-        #expect(try spoken(in: grid, row: 1, dataColumn: active) == String(localized: "Inactive"))
-        #expect(try spoken(in: grid, row: 0, dataColumn: 0) == "202601")
-        withExtendedLifetime(grid) {}
+        #expect(grid.drawn(row: 0, dataColumn: active) == "YES")
+        #expect(try grid.spoken(row: 0, dataColumn: active) == String(localized: "Active"))
+        #expect(try grid.spoken(row: 1, dataColumn: active) == String(localized: "Inactive"))
+        #expect(try grid.spoken(row: 0, dataColumn: 0) == "202601")
     }
 
     @Test("A cell with no spoken value reads the text it draws")
     func unspokenCellReadsItsText() throws {
         DataGridAccessibility.isActive = true
         defer { DataGridAccessibility.isActive = false }
-        let grid = makeGrid(
+        let grid = MountedStructureList(
             columns: ["Name", "Unique"],
             rows: [StructureListRow(id: "idx", values: ["idx_name", "YES"])]
         )
+        defer { grid.tearDown() }
+        let rowID = try #require(grid.list.model.rowID(at: 0))
+        let unique = try #require(grid.list.model.columns.column(at: 1))
+
+        #expect(try grid.spoken(row: 0, dataColumn: 1) == "YES")
+        #expect(grid.list.grid.gridAccessibilityText(for: rowID, column: unique) == nil)
+    }
+
+    // Each list names its grid for VoiceOver ("Triggers"), where an unnamed one reads "Data grid".
+    @Test("The trigger list's grid is named for the list it shows")
+    func namesTheGrid() async throws {
+        let window = ThemeTestFixture.host(
+            TriggerListPane(
+                triggers: [TriggerInfo(name: "trg", timing: "BEFORE", event: "UPDATE", statement: "")],
+                databaseType: .mysql,
+                state: TriggerInspectorState()
+            ),
+            size: NSSize(width: 600, height: 240)
+        )
+        defer { window.contentView = nil }
+        for _ in 0 ..< 10 {
+            window.contentView?.layoutSubtreeIfNeeded()
+            await withCheckedContinuation { continuation in
+                DispatchQueue.main.async { continuation.resume() }
+            }
+        }
+        let table = try #require(Self.mainTable(in: window.contentView))
+
+        #expect(table.accessibilityLabel() == StructureTab.triggers.displayName)
+    }
 
-        #expect(try spoken(in: grid, row: 0, dataColumn: 1) == "YES")
-        #expect(grid.model.dataGridAccessibilityText(row: 0, column: 1) == nil)
-        withExtendedLifetime(grid) {}
+    private static func mainTable(in view: NSView?) -> DataGridTableView? {
+        guard let view else { return nil }
+        if let table = view as? DataGridTableView, table.paneKind == .main { return table }
+        return view.subviews.lazy.compactMap { mainTable(in: $0) }.first
     }
 }
diff --git a/apple/TableProTests/Views/Structure/StructureListGridModelTests.swift b/apple/TableProTests/Views/Structure/StructureListGridModelTests.swift
index a8b4a8047e..bf5a3f9f6a 100644
--- a/apple/TableProTests/Views/Structure/StructureListGridModelTests.swift
+++ b/apple/TableProTests/Views/Structure/StructureListGridModelTests.swift
@@ -1,202 +1,214 @@
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
 @MainActor
-private final class NoLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
+struct StructureListGridModelTests {
+    private let columns = ["Name", "Timing"]
+    private let rows = [
+        StructureListRow(id: "a", values: ["alpha", "BEFORE"]),
+        StructureListRow(id: "b", values: ["beta", "AFTER"]),
+        StructureListRow(id: "c", values: ["gamma", "AFTER"]),
+    ]
+
+    private func load(
+        _ model: StructureListGridModel<String>,
+        _ rows: [StructureListRow<String>],
+        sortState: SortState? = nil
+    ) {
+        model.load(
+            columns: columns,
+            rows: rows,
+            defaultWidths: [],
+            minimumWidths: [],
+            databaseType: .mysql,
+            sortState: sortState
+        )
+    }
 
-extension GlobalStateSuites {
-    @Suite(.recordingClipboard)
-    @MainActor
-    struct StructureListGridModelTests {
-        private let columns = ["Name", "Timing"]
-        private let rows = [
-            StructureListRow(id: "a", values: ["alpha", "BEFORE"]),
-            StructureListRow(id: "b", values: ["beta", "AFTER"]),
-            StructureListRow(id: "c", values: ["gamma", "AFTER"]),
-        ]
-
-        private func loadedModel(accessibilityLabel: String? = nil) -> StructureListGridModel<String> {
-            let model = StructureListGridModel<String>(accessibilityLabel: accessibilityLabel)
-            _ = model.ensureLoaded(key: 1, columns: columns) { rows }
-            return model
-        }
-
-        private func makeCoordinator(tableView: NSTableView? = nil) -> TableViewCoordinator {
-            let coordinator = TableViewCoordinator(
-                changeManager: AnyChangeManager(DataChangeManager()),
-                isEditable: false,
-                selectedRowIndices: .constant([]),
-                delegate: nil,
-                layoutPersister: NoLayoutPersister()
-            )
-            coordinator.tableView = tableView
-            return coordinator
-        }
-
-        @Test("Rows are built once per content key, in the order given, as text cells")
-        func buildsRowsOncePerKey() {
-            let model = StructureListGridModel<String>()
-            var builds = 0
-            let loaded = model.ensureLoaded(key: 1, columns: columns) {
-                builds += 1
-                return rows
-            }
-            _ = model.ensureLoaded(key: 1, columns: columns) {
-                builds += 1
-                return rows
-            }
-            #expect(builds == 1)
-            #expect(loaded.columns == columns)
-            #expect(loaded.rows.map { $0.values.map(\.asText) } == rows.map { $0.values.map(Optional.some) })
-            #expect(model.rowIDs == ["a", "b", "c"])
-
-            let reordered = model.ensureLoaded(key: 2, columns: columns) {
-                builds += 1
-                return rows.reversed()
-            }
-            #expect(builds == 2)
-            #expect(reordered.rows.first?.values.first?.asText == "gamma")
-            #expect(model.rowIDs == ["c", "b", "a"])
-        }
-
-        @Test("A display row and a row id map both ways, and an unknown one maps to nothing")
-        func mapsDisplayRowsAndIDs() {
-            let model = loadedModel()
-            #expect(model.id(atDisplayRow: 1) == "b")
-            #expect(model.id(atDisplayRow: 3) == nil)
-            #expect(model.id(atDisplayRow: -1) == nil)
-            #expect(model.ids(atDisplayRows: [0, 2, 7]) == ["a", "c"])
-            #expect(model.displayRows(of: ["c", "z"]) == [2])
-            #expect(model.displayRows(of: []).isEmpty)
-        }
-
-        @Test("Copying rows writes them as tab-separated lines in display order")
-        func copiesRowsAsTabSeparatedText() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            loadedModel().dataGridCopyRows([2, 0, 9])
-
-            #expect(clipboard.text == "alpha\tBEFORE\ngamma\tAFTER")
-        }
-
-        @Test("Copying no row leaves the clipboard alone")
-        func copyingNothingWritesNothing() throws {
-            let clipboard = try #require(RecordingClipboard.current)
-
-            loadedModel().dataGridCopyRows([])
-
-            #expect(clipboard.text == nil)
-        }
-
-        @Test("A header click reaches the owner of the rows")
-        func forwardsSortToOwner() {
-            let model = loadedModel()
-            var received: SortState?
-            model.onSortStateChanged = { received = $0 }
-            let state = SortState(columns: [SortColumn(columnIndex: 1, direction: .descending)], source: .user)
-
-            model.dataGridSortStateChanged(state)
-
-            #expect(received == state)
-        }
-
-        @Test("Every reload has the selection put back by identity")
-        func rearmsSelectionRestoreOnAttach() {
-            let coordinator = makeCoordinator()
-            coordinator.hasRestoredSelection = true
-            loadedModel().dataGridAttach(tableViewCoordinator: coordinator)
-            #expect(!coordinator.hasRestoredSelection)
-        }
-
-        @Test("The selection binding maps rows to ids and back")
-        func selectionBindingMapsBothWays() {
-            let model = loadedModel()
-            var ids: Set<String> = ["b"]
-            let selection = model.selection(get: { ids }, set: { ids = $0 })
-
-            #expect(selection.wrappedValue == [1])
-            selection.wrappedValue = [0, 2]
-            #expect(ids == ["a", "c"])
-        }
-
-        @Test("Rows published before the grid puts the selection back after a reload leave the ids alone")
-        func dropsPublicationsDuringReload() {
-            let model = loadedModel()
-            let coordinator = makeCoordinator()
-            model.dataGridAttach(tableViewCoordinator: coordinator)
-            var ids: Set<String> = ["a", "b"]
-            let selection = model.selection(get: { ids }, set: { ids = $0 })
-
-            selection.wrappedValue = [2]
-            #expect(ids == ["a", "b"])
-
-            coordinator.hasRestoredSelection = true
-            selection.wrappedValue = [2]
-            #expect(ids == ["c"])
-        }
-
-        @Test("Republishing the rows the selection already shows keeps the ids a filter hides")
-        func echoKeepsHiddenIDs() {
-            let model = loadedModel()
-            var ids: Set<String> = ["a", "hidden"]
-            let selection = model.selection(get: { ids }, set: { ids = $0 })
-
-            selection.wrappedValue = [0]
-            #expect(ids == ["a", "hidden"])
-        }
-
-        @Test("Default widths fill only the columns the layout has no width for")
-        func defaultWidthsFillMissingColumns() {
-            var stored = ColumnLayoutState()
-            stored.columnWidths["Timing"] = 300
-
-            let layout = StructureListGrid<String>.layout(stored, columns: columns, defaultWidths: [220, 90])
-
-            #expect(layout.columnWidths == ["Name": 220, "Timing": 300])
-            #expect(StructureListGrid<String>.layout(stored, columns: columns, defaultWidths: []) == stored)
-        }
-
-        @Test("Minimum widths follow the columns by index and name nothing past them")
-        func minimumWidthsFollowColumns() {
-            #expect(StructureListGrid<String>.minimumWidths([140, 70], columns: columns) == ["Name": 140, "Timing": 70])
-            #expect(StructureListGrid<String>.minimumWidths([140], columns: columns) == ["Name": 140])
-            #expect(StructureListGrid<String>.minimumWidths([], columns: columns).isEmpty)
-        }
-
-        @Test("A spoken value is answered for its display row and column, and nothing else is")
-        func answersSpokenValues() {
-            let model = StructureListGridModel<String>()
-            _ = model.ensureLoaded(key: 1, columns: columns) {
-                [
-                    StructureListRow(id: "a", values: ["alpha", "YES"], spokenValues: [1: "Enabled"]),
-                    StructureListRow(id: "b", values: ["beta", "NO"]),
-                ]
-            }
-
-            #expect(model.dataGridAccessibilityText(row: 0, column: 1) == "Enabled")
-            #expect(model.dataGridAccessibilityText(row: 0, column: 0) == nil)
-            #expect(model.dataGridAccessibilityText(row: 1, column: 1) == nil)
-            #expect(model.dataGridAccessibilityText(row: 5, column: 1) == nil)
-        }
-
-        @Test("The grid is named for the list it shows")
-        func namesTheGrid() {
-            let tableView = NSTableView()
-            tableView.setAccessibilityLabel(String(localized: "Data grid"))
-            let coordinator = makeCoordinator(tableView: tableView)
-
-            loadedModel(accessibilityLabel: StructureTab.triggers.displayName).dataGridAttach(tableViewCoordinator: coordinator)
-
-            #expect(tableView.accessibilityLabel() == StructureTab.triggers.displayName)
-        }
+    private func loadedModel() -> StructureListGridModel<String> {
+        let model = StructureListGridModel<String>()
+        load(model, rows)
+        return model
+    }
+
+    private func displayedIDs(_ model: StructureListGridModel<String>) -> [String] {
+        (0..<model.model.rowCount).compactMap { index in model.model.rowID(at: index).flatMap { model.id(for: $0) } }
+    }
+
+    private func displayRows(_ model: StructureListGridModel<String>, of ids: Set<String>) -> IndexSet {
+        IndexSet(ids.compactMap { id in model.rowID(for: id).flatMap { model.model.displayIndex(of: $0) } })
+    }
+
+    @Test("Rows load in the order given, as text cells, and the same rows again change nothing")
+    func loadsRowsInOrder() {
+        let model = loadedModel()
+        let revision = model.model.displayRevision
+
+        #expect(model.tableRows.columns == columns)
+        #expect(model.tableRows.rows.map { $0.values.map(\.asText) } == rows.map { $0.values.map(Optional.some) })
+        #expect(model.rowIDs == ["a", "b", "c"])
+        #expect(displayedIDs(model) == ["a", "b", "c"])
+
+        load(model, rows)
+        #expect(model.model.displayRevision == revision)
+
+        load(model, rows.reversed())
+        #expect(model.tableRows.rows.first?.values.first?.asText == "gamma")
+        #expect(model.rowIDs == ["c", "b", "a"])
+    }
+
+    @Test("An id and its grid row map both ways, and an unknown one maps to nothing")
+    func mapsRowsAndIDs() throws {
+        let model = loadedModel()
+        let second = try #require(model.model.rowID(at: 1))
+
+        #expect(model.id(for: second) == "b")
+        #expect(model.rowID(for: "b") == second)
+        #expect(model.model.rowID(at: 3) == nil)
+        #expect(model.rowID(for: "z") == nil)
+        #expect(displayRows(model, of: ["c", "z"]) == [2])
+        #expect(displayRows(model, of: []).isEmpty)
+    }
+
+    @Test("A list row keeps its grid row across a reload, so a reorder is not a new record")
+    func rowIdentitySurvivesAReorder() throws {
+        let model = loadedModel()
+        let beta = try #require(model.rowID(for: "b"))
+
+        load(model, rows.reversed())
+
+        #expect(model.rowID(for: "b") == beta)
+        #expect(model.model.displayIndex(of: beta) == 1)
+    }
+
+    @Test("A header sort reaches the owner of the rows")
+    func forwardsSortToOwner() {
+        let model = loadedModel()
+        var received: SortState?
+        model.grid.onSortChange = { received = $0 }
+        let state = SortState(columns: [SortColumn(columnIndex: 1, direction: .descending)], source: .user)
+
+        model.model.setSort(state)
+
+        #expect(received == state)
+        #expect(model.model.store.sortState == state)
+    }
+
+    @Test("A nil sort turns header sorting off, and a sort turns it on")
+    func sortStateDecidesHeaderSorting() {
+        let model = StructureListGridModel<String>()
+        load(model, rows)
+        #expect(!model.model.configuration.supportsColumnSort)
+
+        load(model, rows, sortState: SortState())
+        #expect(model.model.configuration.supportsColumnSort)
+    }
+
+    @Test("The owner's selection maps to grid rows, and a grid selection maps back to ids")
+    func selectionMapsBothWays() throws {
+        let model = loadedModel()
+        var published: [Set<String>] = []
+        model.onSelect = { published.append($0) }
+
+        model.syncSelection(["b"])
+        #expect(displayRows(model, of: model.selectedIDs) == [1])
+        #expect(published.isEmpty)
+
+        let first = try #require(model.model.rowID(at: 0))
+        let third = try #require(model.model.rowID(at: 2))
+        model.model.selectRows([first, third])
+        #expect(published.last == ["a", "c"])
+        #expect(model.selectedIDs == ["a", "c"])
+    }
+
+    @Test("A reload that keeps the selected records publishes nothing to the owner")
+    func reloadKeepsTheIDsWithoutPublishing() {
+        let model = loadedModel()
+        var published: [Set<String>] = []
+        model.onSelect = { published.append($0) }
+        model.syncSelection(["a", "b"])
+
+        load(model, rows.reversed())
+
+        #expect(published.isEmpty)
+        #expect(model.selectedIDs == ["a", "b"])
+        #expect(displayRows(model, of: ["a", "b"]) == [1, 2])
+    }
+
+    // A filtered list republishing what it shows used to drop the selected ids the filter hid.
+    @Test("Syncing ids a filter hides keeps them for the owner")
+    func syncKeepsHiddenIDs() {
+        let model = loadedModel()
+        var published: [Set<String>] = []
+        model.onSelect = { published.append($0) }
+
+        model.syncSelection(["a", "hidden"])
+
+        #expect(published.isEmpty)
+        #expect(model.selectedIDs == ["a"])
+    }
+
+    @Test("Default widths fill only the columns the layout has no width for")
+    func defaultWidthsFillMissingColumns() {
+        var stored = ColumnLayoutState()
+        stored.columnWidths["Timing"] = 300
+
+        let layout = StructureListGrid<String>.layout(stored, columns: columns, defaultWidths: [220, 90])
+
+        #expect(layout.columnWidths == ["Name": 220, "Timing": 300])
+        #expect(StructureListGrid<String>.layout(stored, columns: columns, defaultWidths: []) == stored)
+    }
+
+    @Test("A width the reader set survives a reload of the same columns")
+    func readerWidthSurvivesAReload() {
+        let model = StructureListGridModel<String>()
+        model.load(columns: columns, rows: rows, defaultWidths: [220, 90], minimumWidths: [], databaseType: .mysql, sortState: nil)
+        model.model.updateColumnLayout { $0.columnWidths["Name"] = 400 }
+
+        model.load(columns: columns, rows: Array(rows.prefix(2)), defaultWidths: [220, 90], minimumWidths: [], databaseType: .mysql, sortState: nil)
+
+        #expect(model.model.store.columnLayout.columnWidths["Name"] == 400)
+        #expect(model.model.store.layoutScope == .ephemeral)
+    }
+
+    @Test("Minimum widths follow the columns by index and name nothing past them")
+    func minimumWidthsFollowColumns() {
+        #expect(StructureListGrid<String>.minimumWidths([140, 70], columns: columns) == ["Name": 140, "Timing": 70])
+        #expect(StructureListGrid<String>.minimumWidths([140], columns: columns) == ["Name": 140])
+        #expect(StructureListGrid<String>.minimumWidths([], columns: columns).isEmpty)
+    }
+
+    @Test("A spoken value is answered for its row and column, and nothing else is")
+    func answersSpokenValues() throws {
+        let model = StructureListGridModel<String>()
+        load(model, [
+            StructureListRow(id: "a", values: ["alpha", "YES"], spokenValues: [1: "Enabled"]),
+            StructureListRow(id: "b", values: ["beta", "NO"]),
+        ])
+        let first = try #require(model.model.rowID(at: 0))
+        let second = try #require(model.model.rowID(at: 1))
+        let name = try #require(model.model.columns.column(at: 0))
+        let timing = try #require(model.model.columns.column(at: 1))
+
+        #expect(model.grid.gridAccessibilityText(for: first, column: timing) == "Enabled")
+        #expect(model.grid.gridAccessibilityText(for: first, column: name) == nil)
+        #expect(model.grid.gridAccessibilityText(for: second, column: timing) == nil)
+        #expect(model.grid.gridAccessibilityText(for: .existing(99), column: timing) == nil)
+    }
+
+    @Test("The list is read-only, never takes a commit, and offers no row commands")
+    func listIsReadOnly() throws {
+        let model = loadedModel()
+        let first = try #require(model.model.rowID(at: 0))
+        let name = try #require(model.model.columns.column(at: 0))
+
+        #expect(!model.model.configuration.isEditable)
+        #expect(!model.model.commit([DataGridCellEdit(rowID: first, columnID: name.id, value: .enteredText("x"))], actionName: "Edit"))
+        #expect(model.model.configuration.commands == [.freezeColumns])
+        #expect(model.tableRows.rows.first?.values.first?.asText == "alpha")
     }
 }
 
@@ -229,9 +241,7 @@ struct StructureListGridToneTests {
             content: DataGridCellContent(displayText: "active", rawValue: "active", placeholder: placeholder),
             state: DataGridCellState(
                 visualState: visualState,
-                isFocused: false,
                 isEditable: false,
-                isLargeDataset: false,
                 isCurrentFindMatch: isCurrentFindMatch,
                 row: 0,
                 columnIndex: 0
@@ -239,7 +249,6 @@ struct StructureListGridToneTests {
             palette: palette,
             nullDisplayString: "NULL",
             onEmphasizedSelection: onEmphasizedSelection,
-            hasOverlay: false,
             textTone: tone
         )
     }
@@ -253,19 +262,28 @@ struct StructureListGridToneTests {
     }
 
     @Test("A tone is answered for its own cell, and a row without tones answers none")
-    func modelAnswersTonePerCell() {
+    func modelAnswersTonePerCell() throws {
         let model = StructureListGridModel<String>()
-        _ = model.ensureLoaded(key: 1, columns: ["Name", "State"]) {
-            [
+        model.load(
+            columns: ["Name", "State"],
+            rows: [
                 StructureListRow(id: "a", values: ["alpha", "active"], tones: [1: .positive]),
                 StructureListRow(id: "b", values: ["beta", "idle"]),
-            ]
-        }
-
-        #expect(model.dataGridTextTone(row: 0, column: 1) == .systemGreen)
-        #expect(model.dataGridTextTone(row: 0, column: 0) == nil)
-        #expect(model.dataGridTextTone(row: 1, column: 1) == nil)
-        #expect(model.dataGridTextTone(row: 5, column: 1) == nil)
+            ],
+            defaultWidths: [],
+            minimumWidths: [],
+            databaseType: .mysql,
+            sortState: nil
+        )
+        let first = try #require(model.model.rowID(at: 0))
+        let second = try #require(model.model.rowID(at: 1))
+        let name = try #require(model.model.columns.column(at: 0))
+        let state = try #require(model.model.columns.column(at: 1))
+
+        #expect(model.grid.gridTextTone(for: first, column: state) == .systemGreen)
+        #expect(model.grid.gridTextTone(for: first, column: name) == nil)
+        #expect(model.grid.gridTextTone(for: second, column: state) == nil)
+        #expect(model.grid.gridTextTone(for: .existing(99), column: state) == nil)
     }
 
     @Test("A toned value draws in its tone and turns to the selection text on an emphasized selection")
diff --git a/apple/TableProTests/Views/Structure/StructureListGridSelectionTests.swift b/apple/TableProTests/Views/Structure/StructureListGridSelectionTests.swift
index 4657ba37e0..c54a9acdb4 100644
--- a/apple/TableProTests/Views/Structure/StructureListGridSelectionTests.swift
+++ b/apple/TableProTests/Views/Structure/StructureListGridSelectionTests.swift
@@ -1,15 +1,15 @@
-// Driven through a real NSHostingView, because the reload that lost the selection runs in
-// DataGridView.updateNSView, which only SwiftUI calls.
+// Hosted in a real NSHostingView: a list's rows reach the grid through StructureListGrid's onChange.
 
 import AppKit
 import Combine
 import Foundation
 import SwiftUI
 @testable import TablePro
+import TableProPluginKit
 import Testing
 
 @MainActor
-private final class HostedList<Content: View> {
+private final class HostedStructureList<Content: View> {
     private let window: NSWindow
     private let host: NSHostingView<Content>
 
@@ -26,13 +26,12 @@ private final class HostedList<Content: View> {
         await settle()
     }
 
-    func show(_ content: Content) async {
-        host.rootView = content
-        await settle()
+    var tableView: DataGridTableView? {
+        Self.mainTable(in: host)
     }
 
-    var tableView: KeyHandlingTableView? {
-        Self.firstTableView(in: host)
+    var model: DataGridModel? {
+        tableView?.controller?.model
     }
 
     func click(row: Int) async {
@@ -60,11 +59,10 @@ private final class HostedList<Content: View> {
     }
 
     func width(ofColumnTitled title: String) -> CGFloat? {
-        tableView?.tableColumns.first { !$0.isHidden && $0.headerCell.stringValue == title }?.width
+        tableView?.tableColumns.first { $0.headerCell.stringValue == title }?.width
     }
 
-    /// Each pass lays out, then waits for one main-queue turn: SwiftUI applies a change on a later
-    /// run-loop turn, and a main-actor task started by the reload runs before the turn comes back.
+    // SwiftUI applies a change on a later run-loop turn, so each pass lays out and waits one main-queue turn.
     func settle() async {
         for _ in 0 ..< 10 {
             host.layoutSubtreeIfNeeded()
@@ -74,10 +72,10 @@ private final class HostedList<Content: View> {
         }
     }
 
-    private static func firstTableView(in view: NSView) -> KeyHandlingTableView? {
-        if let tableView = view as? KeyHandlingTableView { return tableView }
+    private static func mainTable(in view: NSView) -> DataGridTableView? {
+        if let table = view as? DataGridTableView, table.paneKind == .main { return table }
         for subview in view.subviews {
-            if let found = firstTableView(in: subview) { return found }
+            if let found = mainTable(in: subview) { return found }
         }
         return nil
     }
@@ -96,23 +94,17 @@ private final class ListState: ObservableObject {
 private struct ListHarness: View {
     let grid: StructureListGridModel<String>
     @ObservedObject var state: ListState
-    @State private var columnLayout = ColumnLayoutState()
 
     var body: some View {
         let state = state
-        let rows = state.rows
-        var hasher = Hasher()
-        hasher.combine(rows)
         return StructureListGrid(
             model: grid,
             columns: ["Name", "Timing"],
-            contentKey: hasher.finalize(),
-            rows: { rows },
+            rows: state.rows,
             databaseType: .mysql,
-            selectedIDs: { state.selectedIDs },
+            selectedIDs: state.selectedIDs,
             select: { state.selectedIDs = $0 },
-            sortState: nil,
-            columnLayout: $columnLayout
+            sortState: nil
         )
     }
 }
@@ -132,8 +124,9 @@ struct StructureListGridSelectionTests {
     @Test("Reversing the sort after Shift+Down keeps both selected triggers")
     func sortAfterExtendedSelectionKeepsTheTriggers() async throws {
         let state = TriggerInspectorState()
-        let list = await HostedList(TriggerListPane(triggers: triggers, databaseType: .mysql, state: state))
+        let list = await HostedStructureList(TriggerListPane(triggers: triggers, databaseType: .mysql, state: state))
         let tableView = try #require(list.tableView)
+        let model = try #require(list.model)
         try #require(tableView.numberOfRows == 3)
 
         await list.click(row: 0)
@@ -144,19 +137,20 @@ struct StructureListGridSelectionTests {
             columns: [SortColumn(columnIndex: TriggerListColumns.nameColumn, direction: .descending, columnName: "Name")],
             source: .user
         )
-        tableView.coordinator?.delegate?.dataGridSortStateChanged(reversed)
+        model.setSort(reversed)
         await list.settle()
         try #require(state.displayed(triggers).map(\.name) == ["trg_c", "trg_b", "trg_a"])
 
         #expect(state.selectedIDs == [id("trg_a"), id("trg_b")])
-        #expect(tableView.selectedRowIndexes == IndexSet([1, 2]))
+        #expect(Array(tableView.selectedRowIndexes) == [1, 2])
+        #expect(Array(model.selection.affectedRows) == [1, 2])
         #expect(state.actionTarget(triggers) == nil)
     }
 
     @Test("A filter that hides a selected trigger keeps it selected for when the filter clears")
     func filterKeepsHiddenSelection() async throws {
         let state = TriggerInspectorState()
-        let list = await HostedList(TriggerListPane(triggers: triggers, databaseType: .mysql, state: state))
+        let list = await HostedStructureList(TriggerListPane(triggers: triggers, databaseType: .mysql, state: state))
         let tableView = try #require(list.tableView)
         await list.click(row: 0)
         await list.shiftDown()
@@ -181,7 +175,7 @@ struct StructureListGridSelectionTests {
             StructureListRow(id: "b", values: ["beta", "AFTER"]),
             StructureListRow(id: "c", values: ["gamma", "AFTER"]),
         ])
-        let list = await HostedList(ListHarness(grid: StructureListGridModel<String>(), state: state))
+        let list = await HostedStructureList(ListHarness(grid: StructureListGridModel<String>(), state: state))
         let tableView = try #require(list.tableView)
         await list.click(row: 0)
         await list.shiftDown()
@@ -191,7 +185,7 @@ struct StructureListGridSelectionTests {
         await list.settle()
 
         #expect(state.selectedIDs == ["a", "b"])
-        #expect(tableView.selectedRowIndexes == IndexSet([1, 2]))
+        #expect(Array(tableView.selectedRowIndexes) == [1, 2])
     }
 
     @Test("A refresh that replaces every row selects none of the new ones")
@@ -200,7 +194,7 @@ struct StructureListGridSelectionTests {
             StructureListRow(id: "a", values: ["alpha", "BEFORE"]),
             StructureListRow(id: "b", values: ["beta", "AFTER"]),
         ])
-        let list = await HostedList(ListHarness(grid: StructureListGridModel<String>(), state: state))
+        let list = await HostedStructureList(ListHarness(grid: StructureListGridModel<String>(), state: state))
         let tableView = try #require(list.tableView)
         await list.click(row: 0)
         await list.shiftDown()
@@ -217,9 +211,26 @@ struct StructureListGridSelectionTests {
         #expect(tableView.selectedRowIndexes.isEmpty)
     }
 
+    @Test("A selection the owner makes reaches the grid by identity")
+    func ownerSelectionReachesTheGrid() async throws {
+        let state = ListState(rows: [
+            StructureListRow(id: "a", values: ["alpha", "BEFORE"]),
+            StructureListRow(id: "b", values: ["beta", "AFTER"]),
+            StructureListRow(id: "c", values: ["gamma", "AFTER"]),
+        ])
+        let list = await HostedStructureList(ListHarness(grid: StructureListGridModel<String>(), state: state))
+        let tableView = try #require(list.tableView)
+
+        state.selectedIDs = ["c"]
+        await list.settle()
+
+        #expect(tableView.selectedRowIndexes == IndexSet(integer: 2))
+        #expect(state.selectedIDs == ["c"])
+    }
+
     @Test("Trigger columns open at the widths the list has always given them")
     func triggerColumnWidths() async {
-        let withEnabled = await HostedList(TriggerListPane(triggers: triggers, databaseType: .mysql, state: TriggerInspectorState()))
+        let withEnabled = await HostedStructureList(TriggerListPane(triggers: triggers, databaseType: .mysql, state: TriggerInspectorState()))
         #expect(withEnabled.width(ofColumnTitled: String(localized: "Name")) == 220)
         #expect(withEnabled.width(ofColumnTitled: String(localized: "Timing")) == 90)
         #expect(withEnabled.width(ofColumnTitled: String(localized: "Event")) == 150)
@@ -228,7 +239,7 @@ struct StructureListGridSelectionTests {
         let unknownEnabled = triggers.map {
             TriggerInfo(name: $0.name, timing: $0.timing, event: $0.event, statement: "")
         }
-        let withoutEnabled = await HostedList(TriggerListPane(
+        let withoutEnabled = await HostedStructureList(TriggerListPane(
             triggers: unknownEnabled, databaseType: .mysql, state: TriggerInspectorState()
         ))
         #expect(withoutEnabled.width(ofColumnTitled: String(localized: "Name")) == 240)
diff --git a/apple/TableProTests/Views/Structure/StructureRowMenuRouteTests.swift b/apple/TableProTests/Views/Structure/StructureRowMenuRouteTests.swift
index 733b9516df..ca55e1a0a9 100644
--- a/apple/TableProTests/Views/Structure/StructureRowMenuRouteTests.swift
+++ b/apple/TableProTests/Views/Structure/StructureRowMenuRouteTests.swift
@@ -5,145 +5,179 @@
 
 import AppKit
 import Foundation
-import SwiftUI
 @testable import TablePro
 import TableProPluginKit
 import Testing
 
-@MainActor
-private final class StructureRouteLayoutPersister: ColumnLayoutPersisting {
-    func load(for key: ColumnLayoutTableKey) -> ColumnLayoutState? { nil }
-    func save(_ layout: ColumnLayoutState, for key: ColumnLayoutTableKey) {}
-    func clear(for key: ColumnLayoutTableKey) {}
-}
-
-/// A column row raises the same menu whichever way AppKit reaches it.
-///
-/// There are two routes and they used to end in two different menus.
-/// `KeyHandlingTableView.rightMouseDown` intercepts a click that lands inside the selection and
-/// answers from `DataGridRowView.contextMenu(for:)`; a click outside the selection falls through to
-/// `super`, which reaches the row view's own `menu(for:)`. The Structure tab overrode only the
-/// second, so selecting a column and right-clicking it produced the data grid's row commands over a
-/// schema row.
-///
-/// Asserted here rather than in a UI test because XCUITest cannot tell the two menus apart in this
-/// runner: an open contextual menu is not a child of the application element, and the titles that
-/// would discriminate (`Export Results…`) also sit in the menu bar, so an app-rooted query answers
-/// from there whatever the contextual menu holds.
+// Every row menu, from any click and either pane, is the grid's commands plus the owner's `gridRowMenuItems`.
 @MainActor
 struct StructureRowMenuRouteTests {
-    /// Only the structure menu builds this.
-    private let structureOnly = "Copy Name"
-    /// Only the data grid's row menu builds this.
-    private let dataGridOnly = "Export Results…"
-
-    private func makeRowView(tab: StructureTab = .columns) -> StructureRowViewWithMenu {
-        let coordinator = TableViewCoordinator(
-            changeManager: AnyChangeManager(DataChangeManager()),
-            isEditable: true,
-            selectedRowIndices: .constant([]),
-            delegate: nil,
-            layoutPersister: StructureRouteLayoutPersister()
+    private func makeAdapter(
+        tab: StructureTab = .columns,
+        type: DatabaseType = .mysql,
+        objectKind: TableInfo.TableType = .table,
+        manager: StructureChangeManager = StructureChangeManager()
+    ) -> StructureGridAdapter {
+        if manager.workingColumns.isEmpty {
+            manager.addColumn(.placeholder())
+        }
+        let adapter = StructureGridAdapter(
+            structureChangeManager: manager,
+            connection: TestFixtures.makeConnection(type: type),
+            tableName: "orders",
+            databaseName: "shop",
+            schemaName: nil,
+            objectKind: objectKind,
+            isSessionBound: false
         )
-        let tableRows = TableRows.from(
-            queryRows: [[.text("id")]], columns: ["Name"], columnTypes: [.text(rawType: "TEXT")]
-        )
-        coordinator.tableRowsProvider = { tableRows }
-        coordinator.rebuildColumnMetadataCache(from: tableRows)
-        coordinator.updateCache()
-
-        let tableView = KeyHandlingTableView()
-        tableView.coordinator = coordinator
-        tableView.addTableColumn(DataGridView.makeRowNumberColumn())
-        coordinator.tableView = tableView
-
-        let rowView = StructureRowViewWithMenu()
-        rowView.coordinator = coordinator
-        rowView.rowIndex = 0
-        rowView.structureTab = tab
-        return rowView
+        adapter.store.switchSubTab(to: tab)
+        adapter.refresh()
+        return adapter
     }
 
-    private func rightClick() throws -> NSEvent {
-        try #require(NSEvent.mouseEvent(
-            with: .rightMouseDown,
-            location: NSPoint(x: 10, y: 10),
-            modifierFlags: [],
-            timestamp: 0,
-            windowNumber: 0,
-            context: nil,
-            eventNumber: 0,
-            clickCount: 1,
-            pressure: 1
-        ))
+    private func row(_ sourceIndex: Int) -> RowID {
+        StructureRowProvider.rowID(forSourceIndex: sourceIndex)
     }
 
-    private func titles(_ menu: NSMenu?) -> [String] {
-        (menu?.items ?? []).map(\.title)
+    private func titles(_ items: [NSMenuItem]) -> [String] {
+        items.map { $0.title }
     }
 
-    @Test("The route a click outside the selection takes builds the structure menu")
-    func theUnselectedRouteBuildsTheStructureMenu() throws {
-        let rowView = makeRowView()
-        let items = titles(rowView.menu(for: try rightClick()))
+    @Test("A column row's menu is the schema's own items, with no result commands")
+    func columnRowsGetTheStructureMenu() {
+        let adapter = makeAdapter()
+        let items = titles(adapter.gridRowMenuItems(for: [row(0)], clickedRow: row(0)))
 
-        #expect(items.contains(structureOnly))
-        #expect(!items.contains(dataGridOnly))
+        #expect(items.contains(String(localized: "Copy Name")))
+        #expect(items.contains(String(localized: "Copy Definition")))
+        let commands = adapter.model.configuration.commands
+        #expect(commands.isDisjoint(with: [.exportResults, .showRowsAsJSON, .clearResults, .copyAsSQL, .filterWithColumn]))
     }
 
-    @Test("The route a click inside the selection takes builds the structure menu too")
-    func theSelectedRouteBuildsTheStructureMenu() throws {
-        let rowView = makeRowView()
-        let items = titles(rowView.contextMenu(for: try rightClick()))
+    @Test("A DDL tab row offers no row items and no row commands")
+    func theDdlTabRaisesNoMenu() {
+        let adapter = makeAdapter(tab: .ddl)
 
-        #expect(items.contains(structureOnly))
-        #expect(!items.contains(dataGridOnly))
+        #expect(adapter.gridRowMenuItems(for: [row(0)], clickedRow: row(0)).isEmpty)
+        #expect(adapter.gridEmptySpaceMenu() == nil)
+        #expect(adapter.model.configuration.commands.isDisjoint(with: [.deleteRows, .duplicateRows, .addRow, .undoDelete]))
     }
 
-    /// The pinned row-number strip asks with the target already resolved, because the column under the
-    /// pointer there is one scrolled out of sight. Only the two event routes were overridden, so the
-    /// strip raised the data grid's row menu over a schema row.
-    @Test("The pinned row-number strip's route builds the structure menu too")
-    func thePinnedStripRouteBuildsTheStructureMenu() {
-        let rowView = makeRowView()
-        let items = titles(rowView.contextMenu(target: .row))
+    @Test("A row pending deletion offers none of the schema's items")
+    func deletedRowOffersNothing() throws {
+        let manager = StructureChangeManager()
+        manager.loadSchema(
+            tableName: "orders",
+            columns: [ColumnInfo(name: "id", dataType: "INT", isNullable: false, isPrimaryKey: true)],
+            indexes: [],
+            foreignKeys: [],
+            primaryKey: ["id"]
+        )
+        let adapter = makeAdapter(manager: manager)
+        adapter.gridDeleteRows([row(0)])
+        try #require(manager.deleteInsertState(for: 0, tab: .columns).isDeleted)
 
-        #expect(items.contains(structureOnly))
-        #expect(!items.contains(dataGridOnly))
+        #expect(adapter.gridRowMenuItems(for: [row(0)], clickedRow: row(0)).isEmpty)
     }
 
-    /// Not a column list, so no route offers a menu at all.
-    @Test("A DDL tab row raises no menu on any route")
-    func theDdlTabRaisesNoMenu() throws {
-        let rowView = makeRowView(tab: .ddl)
+    // A materialized view refuses DROP COLUMN and ADD COLUMN; the menu used to offer both and do nothing.
+    @Test("Delete and Duplicate are offered only where the object accepts them")
+    func rowEditsFollowTheGate() {
+        let refused = makeAdapter(type: .postgresql, objectKind: .materializedView)
+        #expect(refused.model.configuration.commands.isDisjoint(with: [.deleteRows, .duplicateRows]))
+        #expect(refused.gridRowMenuItems(for: [row(0)], clickedRow: row(0)).last?.isSeparatorItem == false)
 
-        #expect(rowView.menu(for: try rightClick()) == nil)
-        #expect(rowView.contextMenu(for: try rightClick()) == nil)
-        #expect(rowView.contextMenu(target: .row) == nil)
+        let accepted = makeAdapter()
+        #expect(accepted.model.configuration.commands.isSuperset(of: [.deleteRows, .duplicateRows, .undoDelete]))
     }
 
-    /// A materialized view refuses `DROP COLUMN` and `ADD COLUMN`. The menu used to offer Delete and
-    /// Duplicate on its columns anyway, and choosing either did nothing at all.
-    @Test("Delete and Duplicate appear only where the object accepts them")
-    func rowEditsFollowTheGate() {
-        let refused = makeRowView()
-        refused.canDelete = false
-        refused.canDuplicate = false
-        let refusedItems = titles(refused.contextMenu(target: .row))
-        #expect(!refusedItems.contains(String(localized: "Delete")))
-        #expect(!refusedItems.contains(String(localized: "Duplicate")))
-        #expect(refusedItems.last != "")
-
-        let deleteOnly = makeRowView(tab: .indexes)
-        deleteOnly.canDelete = true
-        deleteOnly.canDuplicate = false
-        let deleteOnlyItems = titles(deleteOnly.contextMenu(target: .row))
-        #expect(deleteOnlyItems.contains(String(localized: "Delete")))
-        #expect(!deleteOnlyItems.contains(String(localized: "Duplicate")))
-
-        let accepted = makeRowView()
-        let acceptedItems = titles(accepted.contextMenu(target: .row))
-        #expect(acceptedItems.contains(String(localized: "Delete")))
-        #expect(acceptedItems.contains(String(localized: "Duplicate")))
+    @Test("Open names the clicked foreign key's table, also inside a multi-row selection")
+    func openFollowsTheClickedRow() {
+        let manager = StructureChangeManager()
+        var first = EditableForeignKeyDefinition.placeholder()
+        first.referencedTable = "customers"
+        var second = EditableForeignKeyDefinition.placeholder()
+        second.referencedTable = "products"
+        manager.addForeignKey(first)
+        manager.addForeignKey(second)
+        let adapter = makeAdapter(tab: .foreignKeys, manager: manager)
+        let openCustomers = String(format: String(localized: "Open %@"), "customers")
+        let openProducts = String(format: String(localized: "Open %@"), "products")
+
+        #expect(titles(adapter.gridRowMenuItems(for: [row(0)], clickedRow: row(0))).contains(openCustomers))
+
+        let selection = titles(adapter.structureRowMenuItems(for: [row(0), row(1)], clickedRow: row(1)))
+        #expect(selection.contains(openProducts))
+        #expect(!selection.contains(openCustomers))
+    }
+
+    @Test("Move Column moves the clicked column, also inside a multi-row selection")
+    func moveFollowsTheClickedRow() throws {
+        let manager = StructureChangeManager()
+        manager.loadSchema(
+            tableName: "orders",
+            columns: [
+                ColumnInfo(name: "id", dataType: "INT", isNullable: false, isPrimaryKey: true),
+                ColumnInfo(name: "total", dataType: "INT", isNullable: true, isPrimaryKey: false),
+                ColumnInfo(name: "note", dataType: "TEXT", isNullable: true, isPrimaryKey: false)
+            ],
+            indexes: [],
+            foreignKeys: [],
+            primaryKey: ["id"]
+        )
+        let adapter = makeAdapter(manager: manager)
+        try #require(adapter.model.configuration.rowReorder.isEnabled)
+        var moved: (from: Int, to: Int)?
+        adapter.moveRowHandler = { moved = ($0, $1) }
+
+        let items = adapter.structureRowMenuItems(for: [row(0), row(1), row(2)], clickedRow: row(2))
+        let up = try #require(items.first { $0.title == String(localized: "Move Column Up") })
+        let down = try #require(items.first { $0.title == String(localized: "Move Column Down") })
+        #expect(up.action != nil)
+        #expect(down.action == nil)
+
+        let target = try #require(up.target as? StructureMenuTarget)
+        target.runAction()
+        #expect(moved?.from == 2)
+        #expect(moved?.to == ColumnMove.dropIndex(movingRow: 2, .up))
+    }
+
+    @Test("A deleted row elsewhere in the selection leaves the schema items in place")
+    func deletedRowInSelectionKeepsTheItems() throws {
+        let manager = StructureChangeManager()
+        manager.loadSchema(
+            tableName: "orders",
+            columns: [
+                ColumnInfo(name: "id", dataType: "INT", isNullable: false, isPrimaryKey: true),
+                ColumnInfo(name: "total", dataType: "INT", isNullable: true, isPrimaryKey: false),
+                ColumnInfo(name: "note", dataType: "TEXT", isNullable: true, isPrimaryKey: false)
+            ],
+            indexes: [],
+            foreignKeys: [],
+            primaryKey: ["id"]
+        )
+        let adapter = makeAdapter(manager: manager)
+        adapter.gridDeleteRows([row(1)])
+        try #require(manager.deleteInsertState(for: 1, tab: .columns).isDeleted)
+        let selection = [row(0), row(1), row(2)]
+
+        let items = titles(adapter.gridRowMenuItems(for: selection, clickedRow: row(0)))
+        #expect(items.contains(String(localized: "Copy Name")))
+        #expect(items.contains(String(localized: "Copy Definition")))
+        #expect(items.contains(String(localized: "Copy As")))
+        #expect(titles(adapter.structureRowMenuItems(for: selection, clickedRow: row(2))).contains(String(localized: "Copy Name")))
+        #expect(adapter.structureRowMenuItems(for: selection, clickedRow: row(1)).isEmpty)
+    }
+
+    @Test("The empty space below the rows offers the sub-tab's own Add")
+    func emptySpaceOffersAdd() {
+        let columns = makeAdapter(tab: .columns)
+        #expect(titles(columns.gridEmptySpaceMenu()?.items ?? []) == [String(localized: "Add Column")])
+
+        let indexes = makeAdapter(tab: .indexes)
+        #expect(titles(indexes.gridEmptySpaceMenu()?.items ?? []) == [String(localized: "Add Index")])
+
+        let view = makeAdapter(type: .postgresql, objectKind: .view)
+        #expect(view.gridEmptySpaceMenu() == nil)
     }
 }
diff --git a/apple/TableProTests/Views/Structure/TriggerListGridTests.swift b/apple/TableProTests/Views/Structure/TriggerListGridTests.swift
index 1def47235f..454c1e451d 100644
--- a/apple/TableProTests/Views/Structure/TriggerListGridTests.swift
+++ b/apple/TableProTests/Views/Structure/TriggerListGridTests.swift
@@ -7,6 +7,7 @@ import AppKit
 import Foundation
 import SwiftUI
 @testable import TablePro
+import TableProPluginKit
 import Testing
 
 @MainActor
@@ -25,11 +26,23 @@ struct TriggerListGridTests {
         list.map(\.name)
     }
 
-    private func load(_ grid: StructureListGridModel<TriggerInfo.ID>, _ state: TriggerInspectorState, key: Int) {
+    private func load(_ grid: StructureListGridModel<TriggerInfo.ID>, _ state: TriggerInspectorState) {
         let rows = state.displayed(triggers).map {
             StructureListRow(id: $0.id, values: TriggerListColumns.values(for: $0, showsEnabled: true))
         }
-        _ = grid.ensureLoaded(key: key, columns: TriggerListColumns.titles(showsEnabled: true)) { rows }
+        grid.load(
+            columns: TriggerListColumns.titles(showsEnabled: true),
+            rows: rows,
+            defaultWidths: TriggerListColumns.widths(showsEnabled: true),
+            minimumWidths: TriggerListColumns.minimumWidths(showsEnabled: true),
+            databaseType: .mysql,
+            sortState: state.sortState
+        )
+        grid.syncSelection(state.selectedIDs)
+    }
+
+    private func displayRows(_ grid: StructureListGridModel<TriggerInfo.ID>, of ids: Set<TriggerInfo.ID>) -> IndexSet {
+        IndexSet(ids.compactMap { id in grid.rowID(for: id).flatMap { grid.model.displayIndex(of: $0) } })
     }
 
     @Test("The list opens sorted by name, ascending")
@@ -109,46 +122,72 @@ struct TriggerListGridTests {
         }
     }
 
-    private func tableView(in view: NSView?) -> NSTableView? {
+    private func tableView(in view: NSView?) -> DataGridTableView? {
         guard let view else { return nil }
-        if let tableView = view as? KeyHandlingTableView { return tableView }
+        if let tableView = view as? DataGridTableView, tableView.paneKind == .main { return tableView }
         return view.subviews.lazy.compactMap { self.tableView(in: $0) }.first
     }
 
     @Test("The list's columns carry their minimum widths into the grid")
-    func gridColumnsCarryTheirMinimums() throws {
+    func gridColumnsCarryTheirMinimums() async throws {
         let window = ThemeTestFixture.host(
             TriggerListPane(triggers: triggers, databaseType: .mysql, state: TriggerInspectorState()),
             size: NSSize(width: 700, height: 300)
         )
+        defer { window.contentView = nil }
+        for _ in 0 ..< 10 {
+            window.contentView?.layoutSubtreeIfNeeded()
+            await withCheckedContinuation { continuation in
+                DispatchQueue.main.async { continuation.resume() }
+            }
+        }
         let grid = try #require(tableView(in: window.contentView))
-        let presented = grid.tableColumns.filter { $0.identifier != ColumnIdentitySchema.rowNumberIdentifier && !$0.isHidden }
+        let presented = grid.tableColumns.filter { $0.identifier != DataGridPane.rowNumberIdentifier }
         let minimums = Dictionary(uniqueKeysWithValues: presented.map { ($0.headerCell.stringValue, $0.minWidth) })
 
         let titles = TriggerListColumns.titles(showsEnabled: true)
         #expect(minimums == Dictionary(uniqueKeysWithValues: zip(titles, TriggerListColumns.minimumWidths(showsEnabled: true))))
-        withExtendedLifetime(window) {}
     }
 
     @Test("A selected trigger keeps its row through a sort")
-    func selectionFollowsTheTriggerThroughASort() {
+    func selectionFollowsTheTriggerThroughASort() throws {
         let state = TriggerInspectorState()
         let grid = StructureListGridModel<TriggerInfo.ID>()
-        load(grid, state, key: 1)
-        state.select(grid.ids(atDisplayRows: [1]))
+        grid.onSelect = { state.select($0) }
+        load(grid, state)
+        let second = try #require(grid.model.rowID(at: 1))
+        grid.model.selectRows([second])
         #expect(state.selectedTrigger(triggers)?.name == "trg_b")
 
         state.sortState = sort(0, .descending)
-        load(grid, state, key: 2)
+        load(grid, state)
 
-        #expect(grid.displayRows(of: state.selectedIDs) == [1])
+        #expect(displayRows(grid, of: state.selectedIDs) == [1])
+        #expect(grid.model.selection.affectedRows == [1])
         state.sortState = sort(2, .ascending)
-        load(grid, state, key: 3)
+        load(grid, state)
         #expect(names(state.displayed(triggers)) == ["trg_c", "trg_a", "trg_b"])
-        #expect(grid.displayRows(of: state.selectedIDs) == [2])
+        #expect(displayRows(grid, of: state.selectedIDs) == [2])
+        #expect(grid.model.selection.affectedRows == [2])
         #expect(state.selectedTrigger(triggers)?.name == "trg_b")
     }
 
+    @Test("A header sort goes to the inspector state, which orders the triggers itself")
+    func headerSortReachesTheState() {
+        let state = TriggerInspectorState()
+        let grid = StructureListGridModel<TriggerInfo.ID>()
+        grid.grid.onSortChange = { state.sortState = $0 }
+        load(grid, state)
+        #expect(grid.model.configuration.supportsColumnSort)
+
+        grid.model.setSort(sort(1, .ascending))
+        load(grid, state)
+
+        #expect(state.sortState == sort(1, .ascending))
+        #expect(grid.model.store.sortState == sort(1, .ascending))
+        #expect(grid.model.rows.rows.compactMap { $0.values.first?.asText } == ["trg_a", "trg_c", "trg_b"])
+    }
+
     @Test("Edit and Delete act on one trigger and have none while several are selected")
     func actionTargetIsSingle() {
         let state = TriggerInspectorState()
diff --git a/apple/TableProTests/Views/UsersRoles/PrivilegeScopeOutlineThemeTests.swift b/apple/TableProTests/Views/UsersRoles/PrivilegeScopeOutlineThemeTests.swift
index 60b7353d3e..97159c9167 100644
--- a/apple/TableProTests/Views/UsersRoles/PrivilegeScopeOutlineThemeTests.swift
+++ b/apple/TableProTests/Views/UsersRoles/PrivilegeScopeOutlineThemeTests.swift
@@ -1,11 +1,3 @@
-//
-//  PrivilegeScopeOutlineThemeTests.swift
-//  TableProTests
-//
-//  The privilege scope outline is a content table, so it takes the data grid's colors and text under
-//  a theme and stays exactly AppKit's, row views included, under a default one.
-//
-
 import AppKit
 import Combine
 @testable import TablePro
@@ -13,8 +5,7 @@ import TableProPluginKit
 import TableProTheme
 import Testing
 
-/// Each test adopts a pair on the shared `ThemeEngine` and restores it in a `defer`. The bodies are
-/// synchronous and `@MainActor`, so nothing else on the main actor runs between the two.
+// Each body is synchronous and `@MainActor`, so nothing else runs under the pair it adopts on the shared engine.
 @MainActor
 struct PrivilegeScopeOutlineThemeTests {
     private struct Mounted {
@@ -24,7 +15,7 @@ struct PrivilegeScopeOutlineThemeTests {
         let coordinator: PrivilegeScopeOutlineCoordinator
     }
 
-    /// Never ordered front and never closed: `close()` on a test window over-releases it.
+    // Never ordered front and never closed: `close()` on a test window over-releases it.
     private func mount() throws -> Mounted {
         let viewModel = UsersRolesViewModel(connectionId: UUID(), databaseType: .postgresql)
         viewModel.privilegeTree.showGrantedOnly(scopes: [.database("app"), .database("web")])
@@ -77,7 +68,7 @@ struct PrivilegeScopeOutlineThemeTests {
         }
     }
 
-    @Test("A theme's selection swaps in themed rows and a default theme swaps AppKit's back, keeping the selection")
+    @Test("A theme's background swaps in themed rows and a default theme swaps AppKit's back, keeping the selection")
     func rowClassFollowsTheTheme() throws {
         try ThemeTestFixture.preservingEngine {
             try ThemeTestFixture.adopt([:], appearance: .light)
@@ -92,7 +83,7 @@ struct PrivilegeScopeOutlineThemeTests {
             let subscription = mounted.coordinator.viewModel.$selectedScopes.dropFirst().sink { _ in published += 1 }
             defer { subscription.cancel() }
 
-            try ThemeTestFixture.adopt([.gridSelection: "#C8E1FF"], appearance: .light)
+            try ThemeTestFixture.adopt([.gridBackground: "#FAFAFA"], appearance: .light)
             let themed = try #require(mounted.outline.rowView(atRow: 1, makeIfNecessary: true) as? ThemeTableRowView)
             #expect(themed.chrome === chrome)
             #expect(mounted.outline.selectedRowIndexes == IndexSet(integer: 1))
@@ -106,25 +97,21 @@ struct PrivilegeScopeOutlineThemeTests {
         }
     }
 
-    @Test("Both columns are records cells, told when their row sits on the theme's selection")
-    func cellsFollowTheThemedSelection() throws {
+    @Test("Both columns are records cells")
+    func bothColumnsAreRecordsCells() throws {
         try ThemeTestFixture.preservingEngine {
-            try ThemeTestFixture.adopt([.gridSelection: "#C8E1FF"], appearance: .light)
+            try ThemeTestFixture.adopt([.gridBackground: "#FAFAFA"], appearance: .light)
             let mounted = try mount()
-            mounted.outline.selectRowIndexes(IndexSet(integer: 0), byExtendingSelection: false)
-            let row = try #require(mounted.outline.rowView(atRow: 0, makeIfNecessary: true) as? ThemeTableRowView)
-            row.isEmphasized = true
 
             for column in 0 ..< mounted.outline.numberOfColumns {
-                let selected = mounted.outline.view(atColumn: column, row: 0, makeIfNecessary: true)
-                let other = mounted.outline.view(atColumn: column, row: 1, makeIfNecessary: true)
-                #expect((selected as? ThemeTableChrome.HostingCell)?.isOnThemedSelection == true)
-                #expect((other as? ThemeTableChrome.HostingCell)?.isOnThemedSelection == false)
+                for row in 0 ..< mounted.outline.numberOfRows {
+                    #expect(mounted.outline.view(atColumn: column, row: row, makeIfNecessary: true) is ThemeTableChrome.HostingCell)
+                }
             }
         }
     }
 
-    @Test("Under a theme the outline takes the grid's background, stripes and selection, and gets its own back")
+    @Test("Under a theme the outline takes the grid's background and stripes, keeps AppKit's selection, and gets its own back")
     func themeAppliesAndRestores() throws {
         try ThemeTestFixture.preservingEngine {
             try ThemeTestFixture.adopt([:], appearance: .light)
@@ -135,13 +122,12 @@ struct PrivilegeScopeOutlineThemeTests {
             try ThemeTestFixture.adopt([
                 .gridBackground: "#FAFAFA",
                 .gridAlternateRow: "#F0F0F0",
-                .gridSelection: "#C8E1FF",
             ], appearance: .light)
             #expect(try hex(mounted.outline.backgroundColor) == "#FAFAFA")
             #expect(!mounted.outline.usesAlternatingRowBackgroundColors)
             #expect(try hex(chrome.rowBackgroundColor(forRow: 0)) == "#FAFAFA")
             #expect(try hex(chrome.rowBackgroundColor(forRow: 1)) == "#F0F0F0")
-            #expect(try hex(chrome.selectionColor(emphasized: true)) == "#C8E1FF")
+            #expect(chrome.selectionColor(emphasized: true) == nil)
 
             try ThemeTestFixture.adopt([:], appearance: .light)
             #expect(mounted.outline.backgroundColor == background)
diff --git a/apple/TableProUITests/DataFileWindowUITests.swift b/apple/TableProUITests/DataFileWindowUITests.swift
index 913e309f90..9dadf9249e 100644
--- a/apple/TableProUITests/DataFileWindowUITests.swift
+++ b/apple/TableProUITests/DataFileWindowUITests.swift
@@ -57,7 +57,7 @@ final class DataFileWindowUITests: UITestCase {
         "xr8AAAD3AQAAGAAAAAAAAAAAAAAAgAFwBAAAeGwvd29ya3NoZWV0cy9zaGVldDIueG1sUEsFBgAAAAAGAAYAiwEAAGUFAAAAAA=="
     ].joined()
 
-    // Measured from the first row's own frame, so it holds at any row height, and past the row-number gutter.
+    // Measured from the first row's own frame, so it holds at any row height, and past the row numbers.
     private func rowPoint(in grid: XCUIElement, row: Int) -> XCUICoordinate {
         let firstRow = grid.tableRows.firstMatch.frame
         let dy = firstRow.minY - grid.frame.minY + firstRow.height * (CGFloat(row) + 0.5)
diff --git a/apple/TableProUITests/GridFindUITests.swift b/apple/TableProUITests/GridFindUITests.swift
new file mode 100644
index 0000000000..c9e4611ba1
--- /dev/null
+++ b/apple/TableProUITests/GridFindUITests.swift
@@ -0,0 +1,52 @@
+import XCTest
+
+// A match becomes the grid's cell cursor, so the row that holds it is the selected row. Of album's titles only
+// East (row 3) and West (row 4) hold "st".
+final class GridFindUITests: UITestCase {
+    func testFindStepsThroughMatchesAndEscapeHandsTheKeyboardBack() throws {
+        let (launch, grid) = try launchWithFixtureTable("album")
+        let window = launch.window
+        let app = launch.app
+        XCTAssertTrue(grid.waitForValue("North", row: 1, column: 2), "album must open on its first row")
+        grid.clickCell(row: 1, column: 2)
+
+        app.typeShortcut(.find)
+        let field = window.descendants(matching: .any).matching(identifier: "grid-find-field").firstMatch
+        XCTAssertTrue(
+            waitForPredicate(timeout: 10) { self.holdsKeyboardFocus(field) },
+            "Cmd+F must open the grid's find bar with the keyboard in its field"
+        )
+        app.typeText("st")
+
+        let count = window.staticTexts.matching(identifier: "grid-find-count").firstMatch
+        let rows = grid.element.tableRows
+        XCTAssertTrue(
+            waitForPredicate(timeout: 10) { self.text(of: count) == "1 of 2" && rows.element(boundBy: 2).isSelected },
+            "The first match must be East on row 3, the counter reads '\(text(of: count))'"
+        )
+
+        app.typeKey(.return, modifierFlags: [])
+        XCTAssertTrue(
+            waitForPredicate(timeout: 10) {
+                self.text(of: count) == "2 of 2" && rows.element(boundBy: 3).isSelected && !rows.element(boundBy: 2).isSelected
+            },
+            "Return must move to West on row 4, the counter reads '\(text(of: count))'"
+        )
+
+        // The search field clears on the first Escape and closes the bar on the second (#1490).
+        app.typeKey(.escape, modifierFlags: [])
+        XCTAssertTrue(waitForPredicate(timeout: 10) { field.exists && self.text(of: count).isEmpty }, "The first Escape must clear the term")
+        app.typeKey(.escape, modifierFlags: [])
+        XCTAssertTrue(waitForPredicate(timeout: 10) { !field.exists }, "The second Escape in the field must close the find bar")
+        XCTAssertTrue(
+            waitForPredicate(timeout: 10) { self.holdsKeyboardFocus(grid.element) },
+            "Closing the find bar must hand the keyboard back to the grid"
+        )
+    }
+
+    // A SwiftUI text publishes its string as the value on some builds and as the label on others.
+    private func text(of element: XCUIElement) -> String {
+        guard element.exists else { return "" }
+        return (element.value as? String).flatMap { $0.isEmpty ? nil : $0 } ?? element.label
+    }
+}
diff --git a/apple/TableProUITests/HeaderSortUITests.swift b/apple/TableProUITests/HeaderSortUITests.swift
index a9bf7f0802..def8d88801 100644
--- a/apple/TableProUITests/HeaderSortUITests.swift
+++ b/apple/TableProUITests/HeaderSortUITests.swift
@@ -1,8 +1,9 @@
 import XCTest
 
 final class HeaderSortUITests: UITestCase {
-    // album's titles put the server order, ascending and descending on three different first rows.
-    func testHeaderSortCyclesBothDirectionsAndDontSortSurvivesAReload() throws {
+    // album's titles put the server order, ascending and descending on three different first rows. Artist 2
+    // holds South then East, so a title key behind artist_id shows as East on row 2.
+    func testHeaderClicksFlipTheSortOptionClickAddsAKeyAndDontSortSurvivesAReload() throws {
         let (launch, grid) = try launchWithFixtureTable("album")
         XCTAssertTrue(grid.waitForValue("North", row: 1, column: 2), "album must open in the order the server sent")
 
@@ -13,13 +14,30 @@ final class HeaderSortUITests: UITestCase {
         XCTAssertTrue(grid.waitForValue("West", row: 1, column: 2), "The second click must sort descending")
 
         grid.clickHeader("title")
+        XCTAssertTrue(
+            grid.waitForValue("Down", row: 1, column: 2),
+            "A third click must flip back to ascending, never return to the server's order"
+        )
+
+        grid.clickHeader("artist_id")
         XCTAssertTrue(
             grid.waitForValue("North", row: 1, column: 2),
-            "A third click must return to the order the server sent"
+            "A plain click on another header must replace the title sort with artist_id"
+        )
+
+        grid.clickHeader("title", modifiers: .option)
+        XCTAssertTrue(
+            waitForPredicate(timeout: 20) {
+                grid.value(row: 1, column: 2) == "North" && grid.value(row: 2, column: 2) == "East"
+            },
+            "Option-click must add title behind artist_id, row 2 reads '\(grid.value(row: 2, column: 2) ?? "nil")'"
         )
 
         grid.clickHeader("title")
-        XCTAssertTrue(grid.waitForValue("Down", row: 1, column: 2), "A fourth click must sort ascending again")
+        XCTAssertTrue(
+            grid.waitForValue("Down", row: 1, column: 2),
+            "A plain click on the second key must sort by title alone"
+        )
 
         grid.clickHeader("title", rightClick: true)
         let dontSort = contextMenuItem("Don't Sort", in: launch.app)
diff --git a/apple/TableProUITests/ResultStatusBarUITests.swift b/apple/TableProUITests/ResultStatusBarUITests.swift
index 250164172a..930e28c880 100644
--- a/apple/TableProUITests/ResultStatusBarUITests.swift
+++ b/apple/TableProUITests/ResultStatusBarUITests.swift
@@ -17,7 +17,7 @@ final class ResultStatusBarUITests: UITestCase {
         XCTAssertTrue(grid.tableRows.element(boundBy: 2).waitToExist(timeout: 10), "The result must lay out three rows")
         let summary = window.buttons["result-status-selection-summary"].firstMatch
 
-        // A plain click selects a row, not a cell, so Shift-click has to take its anchor from the focused cell.
+        // A plain click selects the cell, the anchor a Shift-click extends from.
         millisecondsCell(row: 0, in: grid, of: window).click()
         XCTAssertTrue(
             waitForPredicate(timeout: 10) { grid.tableRows.element(boundBy: 0).isSelected },
@@ -27,6 +27,17 @@ final class ResultStatusBarUITests: UITestCase {
         XCUIElement.perform(withKeyModifiers: .shift) { third.click() }
         expectSummary(summary, count: 3, digits: "916900", after: "Shift-click from row 1 to row 3")
 
+        // The menu of a cell outside the selection acts on that cell and leaves the selection where it is.
+        XCTAssertTrue(grid.tableRows.element(boundBy: 3).waitToExist(timeout: 10), "The result must lay out a fourth row")
+        millisecondsCell(row: 3, in: grid, of: window).rightClick()
+        XCTAssertTrue(window.menus.firstMatch.waitToExist(timeout: 10), "A right-click on a cell must open its menu")
+        app.typeKey(.escape, modifierFlags: [])
+        XCTAssertTrue(
+            waitForPredicate(timeout: 5) { !window.menus.firstMatch.exists },
+            "Escape must close the cell's menu"
+        )
+        expectSummary(summary, count: 3, digits: "916900", after: "A right-click outside the selection")
+
         millisecondsCell(row: 0, in: grid, of: window).click()
         XCTAssertTrue(
             waitForPredicate(timeout: 10) { !self.summary(summary, reads: 3, digits: "916900") },
diff --git a/apple/TableProUITests/Support/AppShortcut.swift b/apple/TableProUITests/Support/AppShortcut.swift
index 7cc4670abb..b15d4f453f 100644
--- a/apple/TableProUITests/Support/AppShortcut.swift
+++ b/apple/TableProUITests/Support/AppShortcut.swift
@@ -17,6 +17,7 @@ internal enum AppShortcut {
     case pinResult
     case save
     case undo
+    case find
     case selectAll
     case addRow
     case deleteRow
@@ -46,6 +47,7 @@ internal enum AppShortcut {
         case .pinResult: ("p", [.command, .option])
         case .save: ("s", .command)
         case .undo: ("z", .command)
+        case .find: ("f", .command)
         case .selectAll: ("a", .command)
         case .addRow: ("n", [.command, .shift])
         case .deleteRow: (XCUIKeyboardKey.delete.rawValue, .command)
diff --git a/apple/TableProUITests/Support/UITestCase+FixtureGrid.swift b/apple/TableProUITests/Support/UITestCase+FixtureGrid.swift
index ec39528953..894b212b9f 100644
--- a/apple/TableProUITests/Support/UITestCase+FixtureGrid.swift
+++ b/apple/TableProUITests/Support/UITestCase+FixtureGrid.swift
@@ -2,7 +2,8 @@ import SQLite3
 import XCTest
 
 // AppKit wraps each cell view in an AXCell that repeats its label and carries no value, so a cell is the
-// cell view, matched by its identifier whatever its type: static text, a combo box for a picker.
+// grid's stand-in view, matched by its identifier whatever its role: static text, a combo box for a picker.
+// The label's row and column count from 1: the row number on screen, page offset included, and the display position.
 internal struct FixtureGrid {
     internal let element: XCUIElement
     internal let app: XCUIApplication
@@ -10,7 +11,7 @@ internal struct FixtureGrid {
 
     internal func cell(row: Int, column: Int) -> XCUIElement {
         element.descendants(matching: .any)
-            .matching(identifier: "DataGridCellAccessibilityView")
+            .matching(identifier: "data-grid-cell")
             .matching(NSPredicate(format: "label BEGINSWITH %@", "Row \(row), column \(column): "))
             .firstMatch
     }
@@ -63,14 +64,17 @@ internal struct FixtureGrid {
         app.typeKey(.return, modifierFlags: [])
     }
 
-    internal func clickHeader(_ column: String, rightClick: Bool = false) {
+    // A plain click sorts by the column alone, an Option-click adds it as another sort key.
+    internal func clickHeader(_ column: String, modifiers: XCUIElement.KeyModifierFlags = [], rightClick: Bool = false) {
         let header = header(column)
         XCTAssertTrue(header.waitToExist(timeout: 20), "The grid must publish a \(column) header")
         let target = point(inside: header.frame)
         if rightClick {
             target.rightClick()
-        } else {
+        } else if modifiers.isEmpty {
             target.click()
+        } else {
+            XCUIElement.perform(withKeyModifiers: modifiers) { target.click() }
         }
     }
 }
diff --git a/apple/TableProUITests/Support/UITestCase.swift b/apple/TableProUITests/Support/UITestCase.swift
index 096953a040..b8597b1fe3 100644
--- a/apple/TableProUITests/Support/UITestCase.swift
+++ b/apple/TableProUITests/Support/UITestCase.swift
@@ -164,6 +164,7 @@ internal class UITestCase: XCTestCase {
             .firstMatch
     }
 
+    // The main table, which publishes every column: the frozen pane over its leading edge is hidden from accessibility.
     internal func dataGrid(in window: XCUIElement) -> XCUIElement {
         window.tables.matching(identifier: "data-grid").firstMatch
     }
diff --git a/apple/changelog.d/3833.changed.1.md b/apple/changelog.d/3833.changed.1.md
new file mode 100644
index 0000000000..c9861bc279
--- /dev/null
+++ b/apple/changelog.d/3833.changed.1.md
@@ -0,0 +1 @@
+The data grid header, selection and selected cell use the system colors and follow Accent and focus.
diff --git a/apple/changelog.d/3833.changed.2.md b/apple/changelog.d/3833.changed.2.md
new file mode 100644
index 0000000000..541bdd60c6
--- /dev/null
+++ b/apple/changelog.d/3833.changed.2.md
@@ -0,0 +1 @@
+Find works in every data grid, with Match Case, Whole Words, Regular Expression, a column scope and Replace.
diff --git a/apple/changelog.d/3833.changed.3.md b/apple/changelog.d/3833.changed.3.md
new file mode 100644
index 0000000000..0a745b6bbc
--- /dev/null
+++ b/apple/changelog.d/3833.changed.3.md
@@ -0,0 +1 @@
+A cell value with a line break or over 256 characters opens in an editor anchored to the cell.
diff --git a/apple/changelog.d/3833.changed.4.md b/apple/changelog.d/3833.changed.4.md
new file mode 100644
index 0000000000..faf154254e
--- /dev/null
+++ b/apple/changelog.d/3833.changed.4.md
@@ -0,0 +1 @@
+Right-clicking a cell outside the selection acts on that cell and leaves the selection where it was.
diff --git a/apple/changelog.d/3833.changed.5.md b/apple/changelog.d/3833.changed.5.md
new file mode 100644
index 0000000000..f1c767cdbf
--- /dev/null
+++ b/apple/changelog.d/3833.changed.5.md
@@ -0,0 +1 @@
+Frozen columns sort, resize and reorder from their own headers at any scroll position.
diff --git a/apple/changelog.d/3833.changed.md b/apple/changelog.d/3833.changed.md
new file mode 100644
index 0000000000..efb59506c9
--- /dev/null
+++ b/apple/changelog.d/3833.changed.md
@@ -0,0 +1 @@
+Clicking a sorted column header reverses the sort; Option-click adds a sort key and Don't Sort is in the header menu.
diff --git a/apple/changelog.d/3833.fixed.1.md b/apple/changelog.d/3833.fixed.1.md
new file mode 100644
index 0000000000..c5306a91d7
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.1.md
@@ -0,0 +1 @@
+Switching tabs or Structure sub-tabs with a cell open could save the edit into the other tab.
diff --git a/apple/changelog.d/3833.fixed.2.md b/apple/changelog.d/3833.fixed.2.md
new file mode 100644
index 0000000000..37476a2e3f
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.2.md
@@ -0,0 +1 @@
+An edit, delete or paste under a value filter could land on a different row.
diff --git a/apple/changelog.d/3833.fixed.3.md b/apple/changelog.d/3833.fixed.3.md
new file mode 100644
index 0000000000..eb68f03caf
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.3.md
@@ -0,0 +1 @@
+Find Next selected the matching row but left the cell cursor in the previous column.
diff --git a/apple/changelog.d/3833.fixed.4.md b/apple/changelog.d/3833.fixed.4.md
new file mode 100644
index 0000000000..be78b4cc70
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.4.md
@@ -0,0 +1 @@
+Display As on a query result went back to the default format after Load More or a switch to another view.
diff --git a/apple/changelog.d/3833.fixed.5.md b/apple/changelog.d/3833.fixed.5.md
new file mode 100644
index 0000000000..51c010a3d3
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.5.md
@@ -0,0 +1 @@
+A temporary table or the Structure tab could change a table's saved column widths and order.
diff --git a/apple/changelog.d/3833.fixed.6.md b/apple/changelog.d/3833.fixed.6.md
new file mode 100644
index 0000000000..85e42222cb
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.6.md
@@ -0,0 +1 @@
+Copy Rows, Copy with Headers and Copy as JSON did nothing in a data file window.
diff --git a/apple/changelog.d/3833.fixed.7.md b/apple/changelog.d/3833.fixed.7.md
new file mode 100644
index 0000000000..396f620bec
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.7.md
@@ -0,0 +1 @@
+VoiceOver numbered rows from 1 on every page and did not name the column of the cell being edited.
diff --git a/apple/changelog.d/3833.fixed.md b/apple/changelog.d/3833.fixed.md
new file mode 100644
index 0000000000..913d159f5e
--- /dev/null
+++ b/apple/changelog.d/3833.fixed.md
@@ -0,0 +1 @@
+After rows reloaded, the grid could show no selection while Delete and the inspector still acted on the old rows.
diff --git a/apple/changelog.d/3833.removed.md b/apple/changelog.d/3833.removed.md
new file mode 100644
index 0000000000..6ca41449bd
--- /dev/null
+++ b/apple/changelog.d/3833.removed.md
@@ -0,0 +1 @@
+Themes no longer color the data grid header, selection, selected text or focus border.