@rozie-ui/data-table-solid 0.7.4 → 0.8.0

package/src/DataTable.tsx

@@ -4,7 +4,9 @@ import { Key } from '@solid-primitives/keyed';
 import { __rozieInjectStyle, createControllableSignal, parseInlineStyle, rozieAttr, rozieClass, rozieContext, rozieDisplay, rozieSelectValue } from '@rozie/runtime-solid';
 import Popover from '@rozie-ui/popover-solid';
 import { isSafeKey, wrapAggregationFn, indexDefsById, editorKindWarning, collectGroupableLeafDefs } from './helpers/columnDefUtils';
+import { columnRuleKeys } from './helpers/columnRuleUtils';
 import { applyUpdater, clamp, focusables } from './helpers/indexMath';
+import { resolveFollow, sameIdSequence } from './helpers/activeFollow';
 import { escapeTsvField, parseTsv, tileGridToBox, tileIndex } from './helpers/tsvGrid';
 import { replaceRowValue, indexOfRowIn, replaceRowValues } from './helpers/rowValueUtils';
 import { createTable, getCoreRowModel, getSortedRowModel, getFilteredRowModel, getPaginationRowModel, getExpandedRowModel, getGroupedRowModel,
@@ -28,6 +30,7 @@ getFacetedUniqueValues as makeFacetedUniqueValues, getFacetedMinMaxValues as mak
 // guard so they never execute when off — the import token is the only static virtual-core
 // presence. NO per-framework adapter (the codegen guard forbids @tanstack/<fw>-virtual).
 import { Virtualizer, elementScroll, observeElementRect, observeElementOffset, measureElement } from '@tanstack/virtual-core';
+import { createHoldController, viewStatesEqual, CLEAN_VIEW_STATE } from './helpers/heldView';
 
 // table-core instance — top-level `let` referenced from hooks → React hoists to
 // useRef (hoistModuleLet). NULL until $onMount: createTable lives in $onMount so its
@@ -102,6 +105,12 @@ export interface DataTableHistoryChangePayload {
   canUndo: boolean;
   canRedo: boolean;
 }
+/** The held-view state (`holdView`): whether the view is held right now, and how many rows the held view disagrees with. */
+export interface DataTableViewState {
+  held: boolean;
+  filterMismatches: number;
+  sortMismatches: number;
+}
 /** The `range-change` payload: the new range corners (both `null` when the range cleared). */
 export type DataTableRangeChangePayload = DataTableRange;
 /** The `row-activate` payload. `row` is the original data object and `index` its position in the rendered model. */
@@ -545,7 +554,7 @@ interface DataTableProps {
   defaultData?: any[];
   onDataChange?: (data: any[]) => void;
   /**
-   * Config-array column fallback (lower precedence than `<Column>` children). Each entry: `{ id?, field, header?, sortable?, filterable?, pinned?, width? }`. Columns may come from this array, from `<Column>` children, or both (id-keyed last-write-wins union). A `pinned` value of `'left'` or `'right'` is applied once as the table's initial `columnPinning` state — identical to `<Column pinned>` — which also REORDERS that column, since table-core orders visible cells `[left-pinned, center, right-pinned]`. A consumer who has already expressed a pin (an initial two-way `columnPinning` model value or an interactive pin) owns the slice and this declaration is ignored.
+   * Config-array column fallback (lower precedence than `<Column>` children). Each entry: `{ id?, field, header?, sortable?, filterable?, filterFn?, sortingFn?, pinned?, width? }` (`filterFn`/`sortingFn` take a table-core built-in name or a custom function). Columns may come from this array, from `<Column>` children, or both (id-keyed last-write-wins union). A `pinned` value of `'left'` or `'right'` is applied once as the table's initial `columnPinning` state — identical to `<Column pinned>` — which also REORDERS that column, since table-core orders visible cells `[left-pinned, center, right-pinned]`. A consumer who has already expressed a pin (an initial two-way `columnPinning` model value or an interactive pin) owns the slice and this declaration is ignored.
    */
   columns?: any[];
   /**
@@ -666,6 +675,10 @@ interface DataTableProps {
    * The maximum number of undo steps retained (oldest evicted past this depth). Only consulted when `undoable` is `true`.
    */
   undoLimit?: number;
+  /**
+   * When `true`, the table holds its current view through its own writes (edit, paste, fill, cut, clear, the boolean toggle, undo and redo): rows keep the membership and order they had before the write and new values render in place, so an edited row does not jump or vanish under an active sort or filter. The view is re-derived (and both mismatch counts reset to 0) when `sorting`, `columnFilters` or `globalFilter` change, when `refreshView()` is called, when the dataset is swapped externally, or when `holdView` is toggled. Paging, page size, column visibility/order/pinning/sizing and expanding rows move through the held rows; a table write or `refreshView()` never changes the page (a sort, filter or grouping change returns to the first page). Falls back to live behaviour (with one console warning) while grouping is active, in `manual` mode, or with tree data (`getSubRows`). Passing a fresh `data` array that did not come from the table (for example reloading from the server after a save) is an external swap: it re-derives the view and clears undo history. Track mismatches with `view-state-change` / `getViewState()`.
+   */
+  holdView?: boolean;
   /**
    * Opt-in windowing grammar: `false` (default, off — byte-identical to a non-virtual table) | `true` or `'rows'` (vertical row windowing; `true` is byte-behavior-identical to every existing consumer, zero churn) | `'columns'` (horizontal column windowing) | `'both'` (both axes windowed). Row windowing renders only the visible slice of rows inside a bounded `rdt-scroll` container (with leading/trailing spacer rows preserving total scroll height), windowing over the full filtered + sorted (pre-pagination) model and suppressing the client pagination chrome. Column windowing renders only the visible slice of leaf columns inside the same `rdt-scroll` container. An unrecognised string behaves as `false`.
    */
@@ -698,6 +711,7 @@ interface DataTableProps {
   onSelectionChange?: (payload: RowSelectionState) => void;
   onSortChange?: (payload: SortingState) => void;
   onVisibilityChange?: (payload: VisibilityState) => void;
+  onViewStateChange?: (payload: DataTableViewState) => void;
   onVisibleRangeChange?: (payload: DataTableVisibleRangeChangePayload) => void;
   // D-131: default slot resolved via children() at body top
   children?: JSX.Element;
@@ -751,13 +765,15 @@ export interface DataTableHandle {
   canUndo: () => boolean;
   canRedo: () => boolean;
   clearHistory: () => void;
+  refreshView: () => void;
+  getViewState: () => DataTableViewState;
 }
 
 export default function DataTable(_props: DataTableProps): JSX.Element {
-  const _merged = mergeProps({ columns: (() => [])() as any[], selectionMode: 'none', manual: false, rowCount: null, pageCount: null, expandable: false, getRowId: null, getSubRows: null, groupable: false, stickyHeader: false, interactionMode: 'table', singleClickEdit: false, undoable: false, undoLimit: 100, virtual: false, estimateRowHeight: 40, autoMeasure: false, maxHeight: '' }, _props);
-  const [local, attrs] = splitProps(_merged, ['data', 'columns', 'selectionMode', 'sorting', 'globalFilter', 'columnFilters', 'pagination', 'manual', 'rowCount', 'pageCount', 'expandable', 'expanded', 'getRowId', 'getSubRows', 'groupable', 'grouping', 'rowSelection', 'columnVisibility', 'columnSizing', 'columnOrder', 'columnPinning', 'stickyHeader', 'interactionMode', 'singleClickEdit', 'undoable', 'undoLimit', 'virtual', 'estimateRowHeight', 'autoMeasure', 'maxHeight', 'children', 'ref', 'onActivecellChange', 'onCellEditCommit', 'onExpandChange', 'onFilterChange', 'onGroupChange', 'onHistoryChange', 'onPageChange', 'onPinChange', 'onRangeChange', 'onReorderChange', 'onResizeChange', 'onRowActivate', 'onRowEditCommit', 'onSelectionChange', 'onSortChange', 'onVisibilityChange', 'onVisibleRangeChange', 'groupBarSlot', 'selectAllSlot', 'placeholderSlot', 'selectCellSlot', 'detailSlot', 'colHeaderSlot', 'filterSlot', 'cellSlot', 'editorSlot', 'slots']);
+  const _merged = mergeProps({ columns: (() => [])() as any[], selectionMode: 'none', manual: false, rowCount: null, pageCount: null, expandable: false, getRowId: null, getSubRows: null, groupable: false, stickyHeader: false, interactionMode: 'table', singleClickEdit: false, undoable: false, undoLimit: 100, holdView: false, virtual: false, estimateRowHeight: 40, autoMeasure: false, maxHeight: '' }, _props);
+  const [local, attrs] = splitProps(_merged, ['data', 'columns', 'selectionMode', 'sorting', 'globalFilter', 'columnFilters', 'pagination', 'manual', 'rowCount', 'pageCount', 'expandable', 'expanded', 'getRowId', 'getSubRows', 'groupable', 'grouping', 'rowSelection', 'columnVisibility', 'columnSizing', 'columnOrder', 'columnPinning', 'stickyHeader', 'interactionMode', 'singleClickEdit', 'undoable', 'undoLimit', 'holdView', 'virtual', 'estimateRowHeight', 'autoMeasure', 'maxHeight', 'children', 'ref', 'onActivecellChange', 'onCellEditCommit', 'onExpandChange', 'onFilterChange', 'onGroupChange', 'onHistoryChange', 'onPageChange', 'onPinChange', 'onRangeChange', 'onReorderChange', 'onResizeChange', 'onRowActivate', 'onRowEditCommit', 'onSelectionChange', 'onSortChange', 'onVisibilityChange', 'onViewStateChange', 'onVisibleRangeChange', 'groupBarSlot', 'selectAllSlot', 'placeholderSlot', 'selectCellSlot', 'detailSlot', 'colHeaderSlot', 'filterSlot', 'cellSlot', 'editorSlot', 'slots']);
   const resolved = () => local.children;
-  onMount(() => { local.ref?.({ sortColumn, clearSorting, toggleRowExpanded, expandAll, collapseAll, getExpandedRows, applyGrouping, clearGrouping, getFacetedUniqueValues, getFacetedMinMaxValues, getColumnDefs, toggleAllRows, clearSelection, getSelectedRows, setPage, setRowsPerPage, toggleColumnVisibility, applyColumnOrder, resetColumnSizing, pinColumn, focusCell, getActiveCell, clearActiveCell, scrollToRow, getScrollElement, getRowIndexRelativeToPage, editCell, commitEditing, editRow, getSelectedRange, cut, undo, redo, canUndo, canRedo, clearHistory }); });
+  onMount(() => { local.ref?.({ sortColumn, clearSorting, toggleRowExpanded, expandAll, collapseAll, getExpandedRows, applyGrouping, clearGrouping, getFacetedUniqueValues, getFacetedMinMaxValues, getColumnDefs, toggleAllRows, clearSelection, getSelectedRows, setPage, setRowsPerPage, toggleColumnVisibility, applyColumnOrder, resetColumnSizing, pinColumn, focusCell, getActiveCell, clearActiveCell, scrollToRow, getScrollElement, getRowIndexRelativeToPage, editCell, commitEditing, editRow, getSelectedRange, cut, undo, redo, canUndo, canRedo, clearHistory, refreshView, getViewState }); });
 
   const __ctx_data_table_columns = rozieContext("data-table:columns");
   const [data, setData] = createControllableSignal<any[]>(_props as unknown as Record<string, unknown>, 'data', []);
@@ -832,7 +848,9 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
   // Server-side page-count sources (#2): re-feed when the consumer's rowCount/pageCount
   // changes at runtime (e.g. a server response updates the total) so getPageCount() and the
   // Next button availability track the new total.
-  local.rowCount, local.pageCount, rowSelection(), expanded(), local.expandable, grouping(), local.groupable, columnVisibility(), columnSizing(), columnOrder(), columnPinning(), local.selectionMode, (data() || []).length, // Phase 51 req-4: key on the data REFERENCE (both sinks) so a committed edit re-feeds
+  local.rowCount, local.pageCount, rowSelection(), expanded(), local.expandable, grouping(), local.groupable, columnVisibility(), columnSizing(), columnOrder(), columnPinning(), local.selectionMode,
+  // Held view: toggling holdView re-derives (reFeed → setActive).
+  local.holdView, (data() || []).length, // Phase 51 req-4: key on the data REFERENCE (both sinks) so a committed edit re-feeds
   // even when the fresh array is the SAME length (a single-cell edit replaces one row
   // object → new array ref, identical length → the .length key alone would miss it). The
   // controlled path observes $props.data; the uncontrolled path observes $data.dataDefault.
@@ -871,6 +889,8 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
     // call. One-shot and self-latching — see seedColumnPinning() in stateAssembly.rzts.
     seedColumnPinning();
     // Build the table instance HERE so the closures below capture the live `table`.
+    const cols0 = tableColumns();
+    lastColumnSig = columnSetSignature(cols0);
     table = createTable({
       // Plain value (NOT a `get data()` getter): an object-literal getter rebinds
       // `this` to the options object, and the Angular/Lit emitters resolve $props via
@@ -881,11 +901,12 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       // currentData() = the bound prop when controlled, else the uncontrolled $data.dataDefault
       // (Phase 51 req-4 — so a committed edit's writeData re-feed is observed either way).
       data: feedData(),
-      columns: tableColumns(),
+      columns: cols0,
       state: currentState(),
       getCoreRowModel: getCoreRowModel(),
-      getSortedRowModel: getSortedRowModel(),
-      getFilteredRowModel: getFilteredRowModel(),
+      // Held view: the wrapped factories, ALWAYS (see holdCtrl's declaration).
+      getSortedRowModel: heldSortedRowModel,
+      getFilteredRowModel: heldFilteredRowModel,
       getPaginationRowModel: getPaginationRowModel(),
       // Expandable rows (phase 50, D-04): the expanded row model is supplied UNCONDITIONALLY
       // (mirrors the other models) — inert when `expanded` is empty + no getSubRows
@@ -970,6 +991,42 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       // satisfies the strict bundled-leaf tsc (deferred-items strict-tsc #2 close).
       onStateChange: () => {}
     });
+    // Page index (final review #1). table-core's autoResetPageIndex (on by default unless
+    // manualPagination) queues `table.resetPageIndex()` in a microtask whenever the core,
+    // filtered, sorted or grouped memo recomputes — which includes every table write (new data)
+    // and refreshView()'s state copy — so a write on page 2 jumped back to page 1 and left the
+    // active cell on another record. The page reset is explicit instead: reFeed returns to page 1
+    // on a sort / columnFilters / globalFilter / grouping change. An external data swap keeps the
+    // page (the #4 overflow clamp in refreshRowModel still pulls it back when the new data has
+    // fewer pages): the swap is detected on different ticks per target (reFeed vs
+    // maybeClearHistoryOnExternalSwap), so a reset there would race the auto-reset's re-write.
+    // The queued auto-reset is NOT switched off (autoResetPageIndex: false): its pagination write
+    // is a re-render tick that several React/Solid paths have come to rely on (measured: B23/WR-01
+    // relocated-row focus, the column-virtual window, header tab stop, editor focus return all
+    // regress without it — the focus polls run before the framework commits the re-sorted rows).
+    // So it is kept, but it re-writes the CURRENT page (table-core's fed state — fresh on every
+    // target, and already page 1 after an explicit reset) instead of turning to page 1.
+    table.resetPageIndex = () => {
+      if (!table) return;
+      const pg = table.getState().pagination;
+      writePagination({
+        pageIndex: pg.pageIndex,
+        pageSize: pg.pageSize
+      });
+    };
+    // Held view: seed the sort/filter references the table was built with, so the first reFeed
+    // (often the first write's own data re-feed) does not misread them as a view change and
+    // release a just-captured hold.
+    const st0 = currentState();
+    lastHoldSorting = st0.sorting;
+    lastHoldColumnFilters = st0.columnFilters;
+    lastHoldGlobalFilter = st0.globalFilter;
+    lastPageGrouping = st0.grouping;
+    syncHoldActive(st0);
+    // Seed the external-swap baseline with the mount-time dataset, so the first re-feed after an
+    // early write (before any maybeClearHistoryOnExternalSwap ran) cannot misread the initial,
+    // unstamped `$props.data` as a swap and release a just-captured hold.
+    lastPropsData = data();
     refreshRowModel = () => {
       if (!table) return;
       // Capture fresh locals; never write a $data key then re-read it in the same fn
@@ -999,15 +1056,32 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       // through here) — guarded internally on colsWindowed() && colVirtualizer, so this is a no-op
       // on every other path.
       remeasureColumnWindow();
-      // D-05: on every data change (re-sort/filter/paginate/page-size — all re-pull here),
-      // clamp the active cell to the new bounds (same indices, clamped if the grid shrank;
-      // no row-id following, no top-bounce). isGrid()-gated so 'table' mode is untouched.
-      // B8/B23: pass the FRESH bounds derived from `nextRows` (NOT $data.rows, which is the
+      // Part 3 + D-05: on every data change (re-sort/filter/paginate/page-size/writes — all
+      // re-pull here) the active cell FOLLOWS its record by row id; where it cannot (paging,
+      // expand/collapse, an external swap) it falls back to the D-05 clamp (same indices, clamped
+      // if the grid shrank), and a record that left the view after a view change or a table write
+      // parks on its column header (followActiveCell, gridKeydownHandlers.rzts). isGrid()-gated so
+      // 'table' mode is untouched.
+      // B8/B23: pass the FRESH bounds and ids derived from `nextRows` (NOT $data.rows, which is the
       // async-stale useState snapshot on React) so a filter-to-fewer clamps the active cell AND
-      // the range corners on React too — never re-reading the pre-change model.
+      // the range corners on React too — never re-reading the pre-change model. The follow flags
+      // are plain `let`s, read and cleared here (ROZ138-safe).
       const nextRowCount = nextRows.length;
       const nextColCount = nextRows.length ? nextRows[0].getVisibleCells().length : nextGroups.length ? (nextGroups[nextGroups.length - 1].headers || []).length : 0;
-      clampActiveCell(nextRowCount, nextColCount);
+      const nextIds = nextRows.map((r: any) => r.id);
+      const fedData = table.options.data;
+      const dataChanged = fedData !== lastFedData;
+      lastFedData = fedData;
+      const viewChangeOrWrite = pendingViewChange || pendingWrite && dataChanged;
+      // Final review #8: new data that is NOT one of our writes (an external swap) without
+      // `getRowId` — the row ids are source indices, meaningless across the swap, so following
+      // them could land the active cell (or an open editor) on an unrelated record. Don't follow:
+      // the D-05 clamp keeps today's position. Reads table.options (fresh on every target).
+      const swapWithoutIds = dataChanged && !pendingWrite && !pendingViewChange && table.options.getRowId == null;
+      pendingViewChange = false;
+      if (dataChanged) pendingWrite = false;
+      followActiveCell(swapWithoutIds ? null : prevRowIds, nextIds, viewChangeOrWrite, nextRowCount, nextColCount, pendingEditFollow != null);
+      prevRowIds = nextIds;
       // #4: clamp a pageIndex that now points PAST the last page. When the consumer holds
       // pagination.pageIndex (controlled) and shrinks the data (filter / replace) so there are
       // fewer pages, the body renders blank ("Page 6 of 3" with Next disabled). Read table-core's
@@ -1021,11 +1095,11 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       //     the clamp back through the pagination prop, the re-feed re-enters here with
       //     pageIndex === pc - 1, so `pageIndex > pc - 1` is false → no re-emit; a consumer that
       //     ignores the event triggers no further re-feed, so it stays a single emit either way.
-      //   • No fight with table-core's autoResetPageIndex: that reset only fires on table-core's OWN
-      //     setX mutations, which this fully-controlled-state architecture never calls (filters/data
-      //     flow through setOptions), so reading the live state here can only fire on a genuine
-      //     overflow — if the index is already valid we stay silent (uncontrolled self-heals too,
-      //     writing paginationDefault, with no regression since table-core does not auto-clamp here).
+      //   • table-core's auto page reset no longer turns the page (table.resetPageIndex is
+      //     overridden after createTable): the sort/filter/grouping page reset is explicit (reFeed),
+      //     and a table write, refreshView() or an external swap never turns the page. This
+      //     clamp therefore only fires on a genuine overflow — if the index is already valid we stay silent (uncontrolled self-heals too,
+      //     writing paginationDefault).
       const pgState = table.getState().pagination;
       const pc = table.getPageCount();
       if (pc > 0 && pgState.pageIndex > pc - 1) {
@@ -1051,6 +1125,13 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       // across selection changes; a microtask defer covers React's post-render DOM patch.
       syncIndeterminate();
       if (typeof queueMicrotask !== 'undefined') queueMicrotask(syncIndeterminate);else Promise.resolve().then(syncIndeterminate);
+      // Held view: edge-triggered view-state-change (only when held/filterMismatches/
+      // sortMismatches changed). lastViewState is a plain `let` (ROZ138-safe).
+      const vs = holdCtrl.viewState(table);
+      if (!viewStatesEqual(vs, lastViewState)) {
+        lastViewState = vs;
+        _props.onViewStateChange?.(vs);
+      }
     };
 
     // initial pull
@@ -1378,6 +1459,91 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
   let redoStack: unknown[] = [];
   let restoringHistory: boolean = false;
 
+  // ── Held view (`holdView`) ─────────────────────────────────────────────────────────────
+  // ONE hold controller per instance (helpers/heldView.ts) and the two wrapped row-model
+  // factories built ONCE from it, so createTable and every reFeed setOptions pass the SAME
+  // function references (a fresh wrapper per re-feed would rebuild table-core's memoized
+  // stage). Both wrapped factories are passed ALWAYS — not only while holding — because the
+  // sort-mismatch count is only correct when wrapSorted observes the live sort. While the
+  // controller is not holding, the wrappers return the base model unchanged (same identity),
+  // so a table without `holdView` is behaviour-identical. Top-level `const`s: React lowers each
+  // to a `useMemo(..., [])` (one instance per component). NOT `let`: React hoists a `let` to
+  // `useRef(init)` and does not rewrite a sibling hoisted `let` read inside that initializer to
+  // `.current`, so `let heldX = holdCtrl.wrapX(...)` would call `wrapX` on the ref object.
+  const holdCtrl = createHoldController();
+  const heldFilteredRowModel = holdCtrl.wrapFiltered(getFilteredRowModel());
+  const heldSortedRowModel = holdCtrl.wrapSorted(getSortedRowModel());
+  // Set when the view was re-derived (a sort/filter change, refreshView()) and by writeData on
+  // every table write; consumed by the active-cell follow (Task 5). Plain `let`s, NOT $data —
+  // written and read inside refreshRowModel's call graph (ROZ138 / React stale reads).
+  let pendingViewChange = false;
+  let pendingWrite = false;
+  // Part 3 (active cell follows its record): the visible row ids at the end of the last
+  // refreshRowModel, and the data array that refresh fed. pendingWrite is consumed only by the
+  // refresh whose fed data CHANGED — in controlled `r-model:data` mode writeData's own
+  // $data.dataDefault write re-feeds the OLD `$props.data` first, and the parent's echo arrives
+  // a pass later; consuming the flag on that first, unchanged pass would turn the write's
+  // vanished row into a clamp instead of a park.
+  let prevRowIds: string[] | null = null;
+  let lastFedData: unknown = null;
+  // The last emitted view-state-change payload (refreshRowModel edge-triggers the emit).
+  let lastViewState = CLEAN_VIEW_STATE;
+  // reFeed bookkeeping: the sort/filter references fed last time (a change releases the hold)
+  // and the one-shot fallback warning latch.
+  let lastHoldSorting: unknown = null;
+  let lastHoldColumnFilters: unknown = null;
+  let lastHoldGlobalFilter: unknown = null;
+  let holdFallbackWarned = false;
+  // The grouping reference fed last time (a change returns to page 1 — see table.resetPageIndex).
+  let lastPageGrouping: unknown = null;
+  // The column-set signature fed last time (see columnSetSignature / reFeed).
+  let lastColumnSig = '';
+  // A signature of the column set as table-core's sort / filter stages see it: each column's id
+  // and whether it can sort / filter (groups flattened, iteratively — no self-recursive const,
+  // which React lowers to a useCallback). table-core memoizes those stages on the sorting /
+  // columnFilters references and the upstream model only, NOT on the column defs; a stage that
+  // first ran before a sorted/filtered column existed (a <Column> child registering after the
+  // first pull, the norm on React/Solid/Lit) silently skipped that sort/filter and stays cached.
+  function columnSetSignature(defs: any) {
+    let sig = '';
+    const stack = (defs || []).slice().reverse();
+    while (stack.length) {
+      const d = stack.pop();
+      if (!d) continue;
+      sig += String(d.id) + (d.enableSorting ? '+' : '') + (d.enableColumnFilter ? '*' : '') + '|';
+      if (Array.isArray(d.columns)) for (let i = d.columns.length - 1; i >= 0; i--) stack.push(d.columns[i]);
+    }
+    return sig;
+  }
+  // The last `$props.data` reference maybeClearHistoryOnExternalSwap examined (seeded in
+  // $onMount). Declared up here, before reFeed, so reFeed can call isExternalSwap() without a
+  // forward reference (React useCallback ordering).
+  let lastPropsData: unknown = null;
+  // Read-only: has `$props.data` changed to a reference we did NOT write since the last
+  // maybeClearHistoryOnExternalSwap? (reFeed uses it to release a held view before its refresh.)
+  function isExternalSwap() {
+    const pd = data();
+    if (pd === lastPropsData) return false;
+    return !(pd != null && (pd as any)[DATA_WRITE_TOKEN_KEY] != null);
+  }
+  // Whether the hold applies for state `st`: holdView on, and not one of the live-behaviour
+  // fallbacks (grouping active, `manual`, tree data). Called from $onMount (before the first
+  // pull) and from every reFeed; warns once when holdView is on but cannot hold.
+  function syncHoldActive(st: any) {
+    const wanted = local.holdView === true;
+    const active = wanted && local.manual !== true && local.getSubRows == null && !(st.grouping || []).length;
+    // A setActive that RELEASES a hold (holdView on→off, or a fallback flipping the controller
+    // inactive while it was holding) re-derives the live view: for the active-cell follow that
+    // is a view change (a record the live view drops parks on its header).
+    const wasHolding = holdCtrl.isHolding();
+    holdCtrl.setActive(active);
+    if (wasHolding && !holdCtrl.isHolding()) pendingViewChange = true;
+    if (wanted && !active && !holdFallbackWarned) {
+      holdFallbackWarned = true;
+      console.warn('[rozie-data-table] holdView falls back to live behaviour while grouping is active, in manual mode, or with tree data (getSubRows); the view is not held.');
+    }
+  }
+
   // Grouping auto-expand latch (phase 50 req-4): when grouping is ACTIVE and the consumer
   // has not bound `expanded` and has not yet toggled any group, group-header rows default to
   // EXPANDED (so the grouped subtree is visible — the standard grouped-grid affordance + the
@@ -1671,6 +1837,8 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       // a custom fn defensively wrapped (T-50-04).
       groupable: c.groupable !== false,
       aggregationFn: wrapAggregationFn(c.aggregationFn),
+      // Per-column filterFn/sortingFn (built-in name or custom fn); absent when unset.
+      ...columnRuleKeys(c, id),
       pinned: c.pinned != null ? c.pinned : '',
       width: c.width != null ? c.width : '',
       // A-01 — `width` alone is inert; table-core sizes from `size`. Spread so an
@@ -1761,6 +1929,7 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
         // Grouping (phase 50 reqs 4-7) — same shape as the config branch (D-05 / T-50-04).
         groupable: spec.groupable !== false,
         aggregationFn: wrapAggregationFn(spec.aggregationFn),
+        ...columnRuleKeys(spec, id),
         pinned: spec.pinned != null ? spec.pinned : '',
         width: spec.width != null ? spec.width : '',
         // A-01 — see buildConfigDef; same mapping for the <Column> registry branch.
@@ -2074,6 +2243,14 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       recordSnapshot(currentData());
       emitHistoryChangeIfEdged(prevU, prevR);
     }
+    // Held view (`holdView`): freeze the view as it is BEFORE this write (a no-op when the
+    // controller is inactive or already holding), then note which source rows this write
+    // replaced (the sort-mismatch count). Outside the `!restoringHistory` branch on purpose:
+    // undo/redo replays are table writes too. pendingWrite is consumed by the active-cell
+    // follow.
+    if (table) holdCtrl.capture(table);
+    holdCtrl.noteWrite(currentData() || [], Array.isArray(next) ? next : []);
+    pendingWrite = true;
     const fresh = Array.isArray(next) ? next.slice() : next;
     try {
       Object.defineProperty(fresh, DATA_WRITE_TOKEN_KEY, {
@@ -3602,6 +3779,18 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
     if (local.selectionMode === 'none') return false;
     return lazyRowsActive() ? (row: any) => !rowIsLazyPlaceholder(row) : true;
   }
+  // Funnel a pagination write the table makes on its own (reFeed's page reset). writePagination is echo-guarded by `programmatic`: a re-feed that runs
+  // synchronously INSIDE another slice's funnel (a header filter input on the fine-grained
+  // targets) would have it silently dropped, so defer it to a microtask then.
+  function writePaginationSoon(next: any) {
+    if (!programmatic) {
+      writePagination(next);
+      return;
+    }
+    const run = () => writePagination(next);
+    if (typeof queueMicrotask !== 'undefined') queueMicrotask(run);else Promise.resolve().then(run);
+  }
+
   // Push fresh options into table-core + re-pull the row model. Extracted so BOTH the
   // re-feed $watch (above) and the Lit data-change $onUpdate (below) call it.
   function reFeed() {
@@ -3612,11 +3801,78 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
     // TRANSIENTLY-STALE `$props.data` and wrongly wipe a just-recorded edit's history. The reset is
     // keyed on the `$props.data` REFERENCE actually changing instead — see the $onUpdate backstop
     // below (`maybeClearHistoryOnExternalSwap`), which runs on all six targets.
+    //
+    // Held view: decide whether the hold applies (it falls back to live behaviour under
+    // grouping, `manual`, and tree data), and re-derive on a sort/filter change. Fresh locals
+    // only — the state object is read once here and passed to setOptions below.
+    const st0 = currentState();
+    syncHoldActive(st0);
+    let st = st0;
+    // Page reset (table-core's auto reset no longer turns the page — see table.resetPageIndex): a sort / filter / grouping change
+    // returns to page 1. The first page is fed to table-core in THIS re-feed (a fresh state
+    // object), so the re-derive — and the active-cell follow, which resolves against the current
+    // page — already sees page 1; writePagination (after the refresh, below) carries it to the
+    // consumer's pagination model. Skipped when already on page 1 (no spurious page-change) and
+    // under `manual` (table-core never auto-reset there either).
+    let pageReset: {
+      pageIndex: number;
+      pageSize: number;
+    } | null = null;
+    const groupingChanged = st0.grouping !== lastPageGrouping;
+    lastPageGrouping = st0.grouping;
+    const viewChanged = st0.sorting !== lastHoldSorting || st0.columnFilters !== lastHoldColumnFilters || st0.globalFilter !== lastHoldGlobalFilter;
+    if (viewChanged) {
+      lastHoldSorting = st0.sorting;
+      lastHoldColumnFilters = st0.columnFilters;
+      lastHoldGlobalFilter = st0.globalFilter;
+      holdCtrl.release();
+      pendingViewChange = true;
+    }
+    if ((viewChanged || groupingChanged) && local.manual !== true && st0.pagination && st0.pagination.pageIndex !== 0) {
+      pageReset = {
+        pageIndex: 0,
+        pageSize: st0.pagination.pageSize
+      };
+      st = {
+        ...st0,
+        pagination: pageReset
+      };
+    }
+    // The column set changed (a <Column> registered, a `columns` entry was added, a column became
+    // sortable/filterable): table-core's sort and filter stages do not key on column defs, so a
+    // sort or filter that referenced a column which did not exist yet stays skipped (an initial
+    // `sorting` was ignored on React/Solid/Lit). Feed shallow copies of both arrays — the same
+    // memo invalidation refreshView() uses — so they re-run against the new columns. Not a view
+    // change: the hold (if any) is kept and the page is not reset.
+    const cols = tableColumns();
+    const colSig = columnSetSignature(cols);
+    if (colSig !== lastColumnSig) {
+      lastColumnSig = colSig;
+      st = {
+        ...st,
+        sorting: [...(st.sorting || [])],
+        columnFilters: [...(st.columnFilters || [])]
+      };
+    }
+    // An external swap releases the hold BEFORE this re-feed's refresh, so the one
+    // view-state-change it emits is already the re-derived state (never a stale held count
+    // measured against the new dataset). Only the hold is touched here — the history clear and
+    // the lastPropsData bookkeeping stay in maybeClearHistoryOnExternalSwap (keyed on the
+    // `$props.data` reference; see its comment). isExternalSwap() is read-only and compares
+    // against that same lastPropsData, so a transiently-stale `$props.data` (the reference
+    // already recorded) never reads as a swap.
+    if (holdCtrl.isHolding() && isExternalSwap()) holdCtrl.release();
+    // An external swap is a reset, not one of our writes: drop a write flag the echo never
+    // consumed (one-way `data`, no r-model), so the swap keeps the D-05 clamp fallback.
+    if (pendingWrite && isExternalSwap()) pendingWrite = false;
     table.setOptions((prev: any) => ({
       ...prev,
       data: feedData(),
-      columns: tableColumns(),
-      state: currentState(),
+      columns: cols,
+      state: st,
+      // Held view: the SAME wrapped factory references every re-feed (see holdCtrl).
+      getFilteredRowModel: heldFilteredRowModel,
+      getSortedRowModel: heldSortedRowModel,
       enableRowSelection: rowSelectionOption(),
       enableMultiRowSelection: local.selectionMode === 'multiple',
       // Re-pass the server-side page-count sources (#2) so a RUNTIME rowCount/pageCount change
@@ -3670,6 +3926,7 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       onColumnSizingInfoChange: onColumnSizingInfoChangeCb
     }));
     if (refreshRowModel) refreshRowModel();
+    if (pageReset) writePaginationSoon(pageReset);
   }
 
   // LIT (+ any fine-grained target whose effect-tracked watch does NOT observe the plain
@@ -3694,14 +3951,24 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
   // non-data tick (sort/filter/pagination) never touches `$props.data` → never clears. Called from
   // BOTH the coarse re-feed watch AND the $onUpdate backstop (Lit's @property `data` the effect-
   // tracked watch can't observe); both are ref-gated so the redundant call is an idempotent no-op.
-  let lastPropsData: unknown = null;
   function maybeClearHistoryOnExternalSwap() {
     const pd = data();
     if (pd === lastPropsData) return; // $props.data did not change → not an external swap
     lastPropsData = pd;
-    if (!local.undoable) return;
     if (pd != null && (pd as any)[DATA_WRITE_TOKEN_KEY] != null) return; // descends from our write → keep
-    clearHistory();
+    // An external swap is a reset, not one of our writes: drop a write flag no echo consumed
+    // (one-way `data`). Here AND in reFeed, so it holds whichever of the two runs first on a
+    // target (Lit's $onUpdate and React's/Solid's effect order run this one before reFeed, after
+    // which reFeed's isExternalSwap() already reads false).
+    pendingWrite = false;
+    // A genuine external swap (runs regardless of `undoable`): it re-derives a held view (a
+    // backstop — reFeed normally released it already, before its own refresh) …
+    if (holdCtrl.isHolding()) {
+      holdCtrl.release();
+      if (refreshRowModel) refreshRowModel();
+    }
+    // … and clears undo history (only meaningful when `undoable`).
+    if (local.undoable) clearHistory();
   }
   let lastData: any = null;
   let lastDataLen = -1;
@@ -4450,6 +4717,32 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
   // DataTable.rozie) — so DataTable.rozie's $expose references them BY NAME with zero
   // indirection. This file stays the seam for verbs that need a rename/adapter, not a mandatory
   // stop for every $expose entry.
+  // Held view (`holdView`). refreshView() re-derives the view from the current filters and
+  // sort and resets both mismatch counts. It works with holdView off too: it forces custom
+  // filter/sort functions to re-run. table-core's filter and sort stages memoize on the
+  // columnFilters/sorting array REFERENCES (not on the column defs or the functions), and
+  // release() alone touches neither — so feed table-core SHALLOW COPIES of both arrays, which
+  // invalidates those memos. The next reFeed restores the original references (one harmless
+  // extra recompute). pendingViewChange is the component-scope `let` the active-cell follow
+  // consumes.
+  function refreshView() {
+    holdCtrl.release();
+    pendingViewChange = true;
+    if (!table) return;
+    table.setOptions((p: any) => ({
+      ...p,
+      state: {
+        ...p.state,
+        columnFilters: [...(p.state.columnFilters || [])],
+        sorting: [...(p.state.sorting || [])]
+      }
+    }));
+    if (refreshRowModel) refreshRowModel();
+  }
+  function getViewState() {
+    return holdCtrl.viewState(table);
+  }
+
   // interactionMode gate. 'grid' lights up roving nav; 'table' (default) is byte-behaviorally
   // identical to phase 48 (roles fall back to the literals, tabindex drops).
   function isGrid() {
@@ -5492,6 +5785,7 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
     if (!tgt || !tgt.closest) return;
     const cellEl = tgt.closest('[data-grid-cell]');
     if (!cellEl) return;
+    activeCellEngaged = true;
     const rowAttr = cellEl.getAttribute('data-row');
     const colAttr = cellEl.getAttribute('data-col-index');
     if (rowAttr == null || colAttr == null) return;
@@ -5788,11 +6082,100 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
     if (typeof requestAnimationFrame === 'function') requestAnimationFrame(tryFocus);else setTimeout(tryFocus, 0);
   }
 
-  // D-05: clamp the active cell to bounds on every underlying-data change (re-sort, filter,
-  // pagination, page-size). KEEP the same indices; clamp ONLY when the grid shrank — NO
-  // row-id following, NO bounce-to-top on a filter keystroke. Gated by isGrid() so 'table'
-  // mode is entirely untouched. Invoked at the rowModelVer bump path (refreshRowModel).
-  function clampActiveCell(rowCount: any, colCount: any) {
+  // followOpenEditors: when a re-derive changed the rows under an open single-cell editor or
+  // full-row editor, re-address it to its record's new index (re-seating editor focus there),
+  // or — when the record left the view — close it WITHOUT writing (its draft belonged to a record
+  // that is no longer on screen; the active cell, on the same record, parks). Returns true when an
+  // editor is still open on a moved record (it, not the cell, owns DOM focus).
+  function followOpenEditors(prevIds: any, nextIds: any) {
+    if (!prevIds || sameIdSequence(prevIds, nextIds)) return false;
+    let owns = false;
+    const er = editingRow();
+    if (er >= 0) {
+      const ef = resolveFollow(prevIds, er, nextIds, true);
+      if (ef.kind === 'move') {
+        setEditingRow(ef.index);
+        focusEditorWhenReady(ef.index, editingCol(), false);
+        owns = true;
+      } else if (ef.kind !== 'stay') {
+        // Latch the session (an unmount blur must not commit the stale draft) and tear down.
+        committedThisSession = true;
+        editTransition = true;
+        endEdit();
+        editTransition = false;
+      }
+    }
+    const rr = editingRowIndex();
+    if (rr != null && rr >= 0) {
+      const rf = resolveFollow(prevIds, rr, nextIds, true);
+      if (rf.kind === 'move') {
+        setEditingRowIndex(rf.index);
+        owns = true;
+      } else if (rf.kind !== 'stay') {
+        editTransition = true;
+        endRowEdit();
+        editTransition = false;
+      }
+    }
+    return owns;
+  }
+
+  // The row id at a visible index / the visible index of a row id, read off table-core's LIVE
+  // model (windowSource — the same index space as $data.rows), never the React-stale $data.rows.
+  function rowIdInModel(index: any) {
+    const row = windowSource()[index];
+    return row ? row.id : null;
+  }
+  function modelIndexOfRowId(id: any) {
+    const rows = windowSource();
+    for (let i = 0; i < rows.length; i++) if (rows[i].id === id) return i;
+    return -1;
+  }
+
+  // Part 3 (design 2026-11-06): the active cell follows its RECORD across every re-derive.
+  // refreshRowModel hands over the previous and next visible row ids (fresh locals — never the
+  // React-stale $data.rows) and whether the rows changed because of a view change (sort /
+  // columnFilters / globalFilter / refreshView / a holdView release) or one of the table's own
+  // writes. resolveFollow (helpers/activeFollow.ts) decides:
+  //   • stay / clamp → the D-05 clamp below, unchanged (clamp = the row is gone after navigation
+  //     or a reset: paging, page size, expand/collapse, an external data swap);
+  //   • move → re-seat the active row at the record's new index;
+  //   • park → the record left the view after a view change / write: park on its column header.
+  // Skipped while a header is active (nothing to follow), on an empty model (B6 owns that), and
+  // before the active cell was ever engaged (it is still just the D-04 entry cell, not a record).
+  // The range is cleared when such a change altered row membership or order — a rectangle
+  // cannot follow rows that are no longer adjacent. Cleared AFTER the clamp so clampRange's
+  // (React-stale) corner write can never resurrect it. While the view is held the ids keep
+  // their order, so the range stays.
+  function followActiveCell(prevIds: any, nextIds: any, viewChangeOrWrite: any, rowCount: any, colCount: any, editFollowPending = false) {
+    // An OPEN editor stays on the record it was opened for (its editing pair is index-addressed
+    // over the visible rows). Done first so the active-cell move below knows the editor owns focus.
+    // NOT grid-gated: the editCell / editRow verbs open editors in 'table' mode too (final review
+    // #2); only the active-cell part below is grid-only.
+    const editorOwnsFocus = followOpenEditors(prevIds, nextIds);
+    if (!isGrid()) return;
+    let follow: any = null;
+    if (activeCellEngaged && rowCount > 0 && !activeIsHeader() && !gridEmptyFallback) {
+      follow = resolveFollow(prevIds, activeRow(), nextIds, viewChangeOrWrite);
+    }
+    // Final review #3: a view change or a table write that EMPTIES the grid — B6 parks the
+    // active cell on the header fallback; when DOM focus was on the vanished body cell, move it
+    // there too (never to <body>).
+    const focusEmptyPark = rowCount <= 0 && viewChangeOrWrite;
+    clampActiveCell(rowCount, colCount, follow, editFollowPending || editorOwnsFocus, focusEmptyPark);
+    if (viewChangeOrWrite && !sameIdSequence(prevIds, nextIds)) clearRange();
+  }
+
+  // D-05 (now the FALLBACK of the Part 3 follow — see followActiveCell above): clamp the active
+  // cell to bounds on an underlying-data change whose record could not be followed for a
+  // navigation / reset reason (paging, page size, expand/collapse, an external data swap), and
+  // on every change that left it in place. KEEP the same indices; clamp ONLY when the grid shrank
+  // — NO bounce-to-top. Where the record CAN be found it is followed first (`follow.kind ===
+  // 'move'`), and a record that left the view after a view change or a table write parks on its
+  // column header (`'park'`) instead of falling through to whichever row now holds its index.
+  // Gated by isGrid() so 'table' mode is entirely untouched. Invoked at the rowModelVer bump
+  // path (refreshRowModel → followActiveCell).
+  function clampActiveCell(rowCount: any, colCount: any, follow: any = null, editFollowPending = false, focusEmptyPark = false) {
     if (!isGrid()) return;
     // B8/B23 React-stale guard: the bounds come from the FRESH model the caller (refreshRowModel)
     // just derived and passes in — NEVER re-read $data.rows here. `$data.rows = nextRows` is an
@@ -5816,6 +6199,8 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
     let recoverFocus = false;
     let doomedRow = -1;
     let doomedCol = 0;
+    // Part 3: is DOM focus on ANY body cell of this grid (the follow re-focuses only then)?
+    let focusOnBody = false;
     if (gridRoot) {
       const rootNode = gridRoot.getRootNode ? gridRoot.getRootNode() : null;
       const focusedEl = rootNode ? rootNode.activeElement : null;
@@ -5824,6 +6209,7 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
         const fRowAttr = focusedCell.getAttribute('data-row');
         const fColAttr = focusedCell.getAttribute('data-col-index');
         if (fRowAttr != null && fRowAttr !== '__header') {
+          focusOnBody = true;
           const fr = parseInt(fRowAttr, 10);
           const fc = parseInt(fColAttr, 10);
           if (Number.isFinite(fr) && fr > rowN - 1) {
@@ -5857,6 +6243,11 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       // Moving DOM focus here would steal focus AND — on React — the fallback's @focusin
       // (setActiveIsHeader true) races the next clear-filter re-seat, leaving the tab-stop stuck on
       // the header. Focus recovery is for a shrink that leaves a VALID BODY cell to land on (below).
+      // The one exception (final review #3, `focusEmptyPark`): a view change or a table write
+      // emptied the grid while DOM focus was ON a body cell (or a just-committed edit expects it
+      // back) — that focus is about to drop to <body>, so move it to the header fallback cell
+      // (the roving tab stop). Never steals focus that is elsewhere.
+      if (focusEmptyPark && (focusOnBody || editFollowPending)) recoverGridFocus('__header', 0, headerLeafLevel());
       return;
     }
     // B6 recovery: the body model returned. If we were parked on the empty-grid header fallback,
@@ -5867,6 +6258,43 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       setActiveIsHeader(false);
       setActiveRow(0);
     }
+    // Part 3 move: the record is still in the view at a NEW index — follow it. Emit the new
+    // position (consumers tracking the active cell would otherwise hold a stale index) and, when
+    // DOM focus was on a body cell of this grid, re-focus at the new position (which also scrolls
+    // it into view). A pending B23 edit-follow owns focus instead (refreshRowModel resolves the
+    // same row by identity). Fresh locals only — no $data re-read after the writes (ROZ138).
+    if (follow && follow.kind === 'move') {
+      const nextRow = follow.index;
+      setActiveRow(nextRow);
+      clampRange(rowN - 1, colN - 1);
+      _props.onActivecellChange?.({
+        rowIndex: toAbsRow(nextRow),
+        colIndex: col,
+        isHeader: false
+      });
+      if (focusOnBody && !editFollowPending) focusCellWhenReady(nextRow, col);
+      return;
+    }
+    // Part 3 park: the record left the view after a view change or one of the table's own
+    // writes. Park on the column's leaf header (keeping the column) rather than falling through
+    // to whichever record now sits at the old index — a typed character then lands on a header
+    // and edits nothing. NOT the B6 empty-grid fallback (no gridEmptyFallback): this park is
+    // user-visible and sticky until the person navigates. When DOM focus was on the vanished
+    // cell (or a just-committed edit expects focus back), move focus to that header so it never
+    // drops to <body> (the B25 problem).
+    if (follow && follow.kind === 'park') {
+      const level = headerLeafLevel();
+      setActiveIsHeader(true);
+      setActiveHeaderLevel(level);
+      clampRange(rowN - 1, colN - 1);
+      _props.onActivecellChange?.({
+        rowIndex: null,
+        colIndex: col,
+        isHeader: true
+      });
+      if (focusOnBody || editFollowPending) recoverGridFocus('__header', col, level);
+      return;
+    }
     if (!activeIsHeader()) {
       const lastRow = rowN - 1;
       const maxRow = lastRow < 0 ? 0 : lastRow;
@@ -6019,6 +6447,11 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
   // already read reactive $data synchronously). A top-level reassigned `let` referenced from the
   // refreshRowModel/clampActiveCell chain → React hoists to useRef → persists per-instance.
   let gridEmptyFallback = false;
+  // Part 3: has the active cell ever been placed on a grid cell (a focusin on a cell — click, Tab-in,
+  // keyboard nav, focusCell)? Until then the active cell is only the D-04 ENTRY cell, not a record
+  // cursor, so a mount-time re-derive (columns registering, grouping engaging) must not drag it off
+  // row 0 by following whichever record happened to sit there. Plain `let` (ROZ138-safe).
+  let activeCellEngaged = false;
 
   // ══ Cell-range selection (phase 51 plan 04 / req-7 / D-07) ═══════════════════════════════
   // A rectangular cell range over the FULL visible model, addressed BY INDEX PAIRS
@@ -7355,6 +7788,12 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
     // A new edit session starts — reset the sync idempotency latch so THIS session's eventual
     // commit is not silently no-op'd by a PRIOR session's already-set latch.
     committedThisSession = false;
+    // A pointerdown OUTSIDE the grid that happened BEFORE this editor opened (a toolbar button
+    // that calls the editCell verb) is not a click-away from it. Left set, onEditorBlur would
+    // consume it on the first null-relatedTarget blur of this editor — e.g. the blur Solid/Lit
+    // fire when a keyed re-render MOVES the editor's row (a re-sort under the open editor) —
+    // and commit-and-close the editor (final review #2, measured on solid + lit).
+    outsidePointerDown = false;
     setInvalid('');
     // Single-cell and full-row edit are mutually exclusive (D-06): entering a single-cell
     // editor clears any row-edit state so isEditing never resolves both modes for one cell.
@@ -8166,15 +8605,28 @@ export default function DataTable(_props: DataTableProps): JSX.Element {
       const fromRow = editingRow();
       const fromCol = editingCol();
       const target = e.shiftKey ? prevEditableCell(fromRow, fromCol) : nextEditableCell(fromRow, fromCol);
+      // Part 3 (2026-11-06 design): the advance targets a RECORD, not an index. The commit below
+      // can re-sort / re-filter the rows (a write under an active sort or filter on the edited
+      // column), so capture the target row's id now — from table-core's live model, which agrees
+      // with the rendered rows before the write — and resolve its index again after the commit.
+      const targetRowId = target ? rowIdInModel(target.row) : null;
       // skipFocusReturn=true: don't bounce focus back to the committed cell — we advance
       // straight into the next editable cell's editor below. Use the RETURN value (not a
       // re-read of $data.editingRow — async-stale on React) to gate the advance: a validation
       // failure returns false and keeps the editor open (the user must fix the value first).
       const committed = commitEdit(undefined, true);
-      if (committed && target) {
-        setActiveRow(target.row);
+      // Where the target record is NOW: on targets whose re-derive runs synchronously inside the
+      // write this is already the re-derived index; elsewhere the model has not re-derived yet,
+      // the index is unchanged, and the refresh that follows moves the open editor and the active
+      // cell with the record (followActiveCell). -1: the record already left the view — open
+      // nothing (the refresh parked the active cell on its header).
+      const advanceRow = targetRowId != null ? modelIndexOfRowId(targetRowId) : -1;
+      if (committed && target && advanceRow >= 0) {
+        setActiveRow(advanceRow);
         setActiveColIndex(target.col);
-        beginEdit(target.row, target.col, null);
+        beginEdit(advanceRow, target.col, null);
+      } else if (committed && target) {
+        // The target record left the view: nothing to advance into.
       } else if (committed) {
         // B5: no editable cell in the Tab direction (grid start/end) — keep focus INSIDE the
         // grid by returning it to the just-committed cell instead of letting it drop to <body>.