@svgrid/grid 3.0.5 → 3.0.7

package/dist/core.js

@@ -130,14 +130,54 @@ export function tableFeatures(features) {
  * text; set a column's type or supply your own comparator to override.
  */
 export const sortFns = {
-    auto: (a, b) => String(a).localeCompare(String(b)),
-    number: (a, b) => Number(a ?? 0) - Number(b ?? 0),
-    date: (a, b) => {
-        const aa = new Date(a).getTime();
-        const bb = new Date(b).getTime();
-        return aa - bb;
-    },
+    auto: (a, b) => compareAutoValues(a, b),
+    number: (a, b) => compareNumericKeys(numberSortKey(a), numberSortKey(b)),
+    date: (a, b) => compareNumericKeys(dateSortKey(a), dateSortKey(b)),
 };
+/** Null, undefined and the empty string: the values every built-in sort puts first. */
+function isBlankSortValue(value) {
+    return value == null || value === '';
+}
+/**
+ * Sort key for the `number` comparator. Blanks and anything that does not
+ * coerce to a number ('n/a', a placeholder) become -Infinity, so they sort
+ * together ahead of every number instead of producing NaN. A NaN key made the
+ * comparator inconsistent - NaN compared equal to everything while the numbers
+ * around it did not - and `Array.prototype.sort` then returned a visibly
+ * unsorted column (#104).
+ */
+function numberSortKey(value) {
+    if (isBlankSortValue(value))
+        return -Infinity;
+    const n = Number(value);
+    return Number.isNaN(n) ? -Infinity : n;
+}
+/** Sort key for the `date` comparator; blanks and invalid dates sort first. */
+function dateSortKey(value) {
+    if (isBlankSortValue(value))
+        return -Infinity;
+    const t = new Date(value).getTime();
+    return Number.isNaN(t) ? -Infinity : t;
+}
+/**
+ * The `auto` comparator: blanks first, then numbers in numeric order, then
+ * everything else as collated text. Ordering by kind before value keeps it
+ * transitive on mixed columns - comparing a number to a string as text
+ * instead would give 2 < 10, 10 < '1a' and '1a' < 2, a cycle.
+ */
+function compareAutoValues(a, b) {
+    const aBlank = isBlankSortValue(a);
+    const bBlank = isBlankSortValue(b);
+    if (aBlank || bBlank)
+        return aBlank === bBlank ? 0 : aBlank ? -1 : 1;
+    const aNum = typeof a === 'number';
+    const bNum = typeof b === 'number';
+    if (aNum && bNum)
+        return compareNumericKeys(numberSortKey(a), numberSortKey(b));
+    if (aNum !== bNum)
+        return aNum ? -1 : 1;
+    return compareCollatedKeys(String(a), String(b));
+}
 /**
  * Built-in match functions, named by {@link ColumnFilter}'s `fn`.
  * `includesString` is case-insensitive substring; `equals` is strict identity.
@@ -165,6 +205,19 @@ export const filterFns = {
 const ROW_CTX = Symbol('svgrid.row.ctx');
 const ROW_VALUES = Symbol('svgrid.row.values');
 const ROW_CELLS = Symbol('svgrid.row.cells');
+// Where the filtered stage last put this row: the generation of that full
+// filter and the row's index in its output. Lets a tick swap a replaced row
+// into place without re-filtering everything (see createFilteredRowModel).
+const ROW_FILTER_GEN = Symbol('svgrid.row.filterGen');
+const ROW_FILTER_POS = Symbol('svgrid.row.filterPos');
+// Stamped on the rows a sort repair drops, so the merge skips them with one
+// property read per row instead of a Set lookup (3 ms per 100k rows).
+const ROW_SORT_DROPPED = Symbol('svgrid.row.sortDropped');
+// The key(s) the last full sort computed for a row: the key itself for a
+// one-clause sort, an array for several. Read by the repair path so a tick
+// never recomputes a kept row's key.
+const ROW_SORT_KEY = Symbol('svgrid.row.sortKey');
+let sortDropGeneration = 0;
 /**
  * The methods every base row carries, defined ONCE and assigned by reference.
  *
@@ -276,17 +329,32 @@ export function createCoreRowModel() {
  * `columnFilteringFeature`; without it there are no filters to apply.
  */
 export function createFilteredRowModel() {
+    /**
+     * The last full filter, so a tick can repair it. When `getRowModel`
+     * reports which rows were replaced (`replacedRowsOf`) and the filter state
+     * and columns are the same objects as last time, each replacement is tested
+     * on its own: a row that stays in keeps its slot, a row that stays out
+     * stays out, and a row whose membership flips sends the whole thing back
+     * through the full pass, because an insertion has to land in data order.
+     * Positions come from stamps on the rows (ROW_FILTER_GEN / ROW_FILTER_POS)
+     * written by the full pass; no map is built.
+     */
+    let cache = null;
+    let generation = 0;
     return ({ table, rows }) => {
         const filters = table.getState().columnFilters ?? [];
-        if (!filters.length)
+        if (!filters.length) {
+            cache = null;
             return rows;
+        }
+        const columns = table.getAllColumns();
         // Resolve each filter's match function once, outside the row loop.
         const compiled = filters.map((filter) => ({
             id: filter.id,
             value: filter.value,
             fn: filter.fn ? filterFns[filter.fn] : filterFns.includesString,
         }));
-        return rows.filter((row) => {
+        const passes = (row) => {
             for (let i = 0; i < compiled.length; i++) {
                 const filter = compiled[i];
                 // `getCellValueByColumnId` rather than `getAllCells().find(...)`.
@@ -299,7 +367,56 @@ export function createFilteredRowModel() {
                     return false;
             }
             return true;
-        });
+        };
+        if (cache && cache.filters === filters && cache.columns === columns) {
+            if (cache.input === rows)
+                return cache.output;
+            const replaced = replacedRowsOf(table);
+            if (replaced && rows.length === cache.input.length) {
+                let out = null;
+                let ok = true;
+                for (let i = 0; i < rows.length && ok; i++) {
+                    const prev = cache.input[i];
+                    const next = rows[i];
+                    if (next === prev)
+                        continue;
+                    if (replaced.get(prev) !== next) {
+                        ok = false;
+                        break;
+                    }
+                    const wasIn = prev[ROW_FILTER_GEN] === cache.gen;
+                    const isIn = passes(next);
+                    if (wasIn !== isIn) {
+                        ok = false;
+                        break;
+                    }
+                    if (!isIn)
+                        continue;
+                    out ?? (out = cache.output.slice());
+                    const pos = prev[ROW_FILTER_POS];
+                    out[pos] = next;
+                    next[ROW_FILTER_GEN] = cache.gen;
+                    next[ROW_FILTER_POS] = pos;
+                }
+                if (ok) {
+                    const output = out ?? cache.output;
+                    cache = { ...cache, input: rows, output };
+                    return output;
+                }
+            }
+        }
+        const gen = ++generation;
+        const output = [];
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            if (!passes(row))
+                continue;
+            row[ROW_FILTER_GEN] = gen;
+            row[ROW_FILTER_POS] = output.length;
+            output.push(row);
+        }
+        cache = { input: rows, output, filters, columns, gen };
+        return output;
     };
 }
 /**
@@ -542,6 +659,19 @@ export function flattenTreeData(data, options) {
 export function createExpandedRowModel() {
     return ({ table, rows }) => {
         const expanded = table.getState().expanded ?? {};
+        // Nothing expanded means every collapsed row hides its children and the
+        // output is the input, element for element. Returning it as is keeps the
+        // array identity the stages downstream and the render window key on, and
+        // skips a 100k-element copy per data change on a flat grid.
+        let anyExpanded = false;
+        for (const id in expanded) {
+            if (expanded[id]) {
+                anyExpanded = true;
+                break;
+            }
+        }
+        if (!anyExpanded)
+            return rows;
         const flattened = [];
         const visit = (row) => {
             flattened.push(row);
@@ -560,11 +690,58 @@ export function createExpandedRowModel() {
  * override the built-in {@link sortFns} - useful for locale-aware or
  * domain-specific ordering.
  */
+/**
+ * Which rows the last `getRowModel` rebuild replaced, old row -> new row, for
+ * the duration of the pipeline run that follows it.
+ *
+ * A live feed replaces a few hundred row objects in a hundred-thousand-row
+ * array and hands the grid the new array. The base rows are rebuilt reusing
+ * every row whose data object is the same (see `getRowModel`), so the rebuild
+ * knows exactly which rows are new. The filtered and sorted stages read that
+ * here and repair their previous output instead of recomputing it, when the
+ * replacements are few and nothing else changed. Cleared after the run; a
+ * stage that reads it outside a run sees null and does the full work.
+ *
+ * Keyed on the grid object in a WeakMap rather than carried on the public
+ * `SvGrid` type, so the stage signature stays `({ table, rows }) => rows`.
+ */
+const replacedRowsByGrid = new WeakMap();
+/** The rows `getRowModel` replaced in the rebuild this pipeline run follows, or null. */
+export function replacedRowsOf(table) {
+    return replacedRowsByGrid.get(table) ?? null;
+}
+/**
+ * The sorting stage of the row pipeline: orders the rows by the grid's
+ * `sorting` state with the built-in comparators (or the `localSortFns` map
+ * handed in), stable, equal keys keeping their data order. A tick that
+ * replaces a few rows out of many is repaired incrementally rather than
+ * re-sorted (see the note inside). Registered by `rowSortingFeature`; an app
+ * only calls this to install its own comparator set.
+ */
 export function createSortedRowModel(localSortFns = sortFns) {
-    return function sortedRowModelStage({ table, rows }) {
-        const sorting = table.getState().sorting ?? [];
-        if (!sorting.length)
-            return rows;
+    /**
+     * What the last full sort produced, kept so a tick can repair it.
+     *
+     * A live feed replaces a few hundred row objects out of a hundred thousand
+     * and hands the grid a new array. Re-sorting all of it costs the same as
+     * the first sort did (115-149 ms in the browser for 100k rows, see
+     * docs/help/benchmarks.md); the order it would produce differs from the
+     * previous one only where the replaced rows land. So the previous output
+     * is kept, with its sort keys aligned to it, and when `getRowModel` says
+     * which rows were replaced (see `replacedRowsOf`) the stage drops those,
+     * sorts the replacements among themselves and merges them back in one
+     * linear pass: O(n + k log k) instead of O(n log n) key builds and
+     * comparisons.
+     *
+     * The repair is only attempted when everything else is the same object as
+     * last time - the sorting state, the columns, and every input row except
+     * the replaced ones - and it produces exactly what the full sort would:
+     * equal keys fall back to the data index, which is the order a stable sort
+     * over data-ordered input keeps.
+     */
+    let cache = null;
+    const MISSING_KEY = Symbol('svgrid.sort.missing-key');
+    function fullSort(rows, sorting, allColumns) {
         // Resolve every clause ONCE, before sorting.
         //
         // This used to live inside the comparator, so `getAllColumns().find(...)`
@@ -572,7 +749,6 @@ export function createSortedRowModel(localSortFns = sortFns) {
         // 1,528,947 array scans, and a three-clause sort made 3,933,751 (measured;
         // `pnpm bench --case=sort-1col`). The comparator is called O(n log n)
         // times, so anything inside it that is not O(1) sets the cost of the sort.
-        const allColumns = table.getAllColumns();
         const clauses = [];
         for (const clause of sorting) {
             const column = allColumns.find((col) => col.id === clause.id);
@@ -599,17 +775,43 @@ export function createSortedRowModel(localSortFns = sortFns) {
             const n = rows.length;
             let keys = new Array(n);
             let compare;
+            let keyOf;
+            let autoMode;
             if (comparator === sortFns.number) {
+                keyOf = (row) => numberSortKey(row.getCellValueByColumnId(columnId));
                 for (let i = 0; i < n; i++)
-                    keys[i] = Number(rows[i].getCellValueByColumnId(columnId) ?? 0);
+                    keys[i] = keyOf(rows[i]);
                 compare = compareNumericKeys;
             }
             else if (comparator === sortFns.date) {
-                for (let i = 0; i < n; i++) {
-                    keys[i] = new Date(rows[i].getCellValueByColumnId(columnId)).getTime();
-                }
+                keyOf = (row) => dateSortKey(row.getCellValueByColumnId(columnId));
+                for (let i = 0; i < n; i++)
+                    keys[i] = keyOf(rows[i]);
+                compare = compareNumericKeys;
+            }
+            else if (comparator === sortFns.auto && (autoMode = autoSortMode(rows, columnId)) === 'number') {
+                // A column with no declared type whose values are all numbers. Sorting
+                // it as text put 10 before 2 (#104).
+                keyOf = (row) => {
+                    const value = row.getCellValueByColumnId(columnId);
+                    // A text value arriving in a tick changes the mode; only a full sort
+                    // can place it.
+                    return typeof value === 'number' || isBlankSortValue(value)
+                        ? numberSortKey(value)
+                        : MISSING_KEY;
+                };
+                for (let i = 0; i < n; i++)
+                    keys[i] = keyOf(rows[i]);
                 compare = compareNumericKeys;
             }
+            else if (autoMode === 'mixed') {
+                // Numbers and text in one column. Rare, so no key tricks: the raw
+                // values through the pairwise comparator, which orders by kind first.
+                keyOf = (row) => row.getCellValueByColumnId(columnId);
+                for (let i = 0; i < n; i++)
+                    keys[i] = keyOf(rows[i]);
+                compare = compareAutoValues;
+            }
             else if (comparator === sortFns.auto) {
                 const strings = new Array(n);
                 // Decide whether ranking is worth attempting BEFORE paying for it.
@@ -632,7 +834,7 @@ export function createSortedRowModel(localSortFns = sortFns) {
                     const sample = new Set();
                     let sampled = 0;
                     for (let i = 0; i < n; i += stride) {
-                        sample.add(String(rows[i].getCellValueByColumnId(columnId)));
+                        sample.add(autoTextKey(rows[i].getCellValueByColumnId(columnId)));
                         sampled++;
                     }
                     // Only attempt ranking when the sample suggests real repetition.
@@ -640,7 +842,7 @@ export function createSortedRowModel(localSortFns = sortFns) {
                         distinct = new Set();
                 }
                 for (let i = 0; i < n; i++) {
-                    const s = String(rows[i].getCellValueByColumnId(columnId));
+                    const s = autoTextKey(rows[i].getCellValueByColumnId(columnId));
                     strings[i] = s;
                     if (distinct) {
                         distinct.add(s);
@@ -669,21 +871,35 @@ export function createSortedRowModel(localSortFns = sortFns) {
                     for (let i = 0; i < n; i++)
                         keys[i] = rankOf.get(strings[i]);
                     compare = compareNumericKeys;
+                    // A replacement whose text is not among the ranked values has no
+                    // rank; the repair path treats that as "sort everything again".
+                    keyOf = (row) => {
+                        const value = row.getCellValueByColumnId(columnId);
+                        // A number arriving in a tick makes the column mixed; resort fully.
+                        if (typeof value === 'number')
+                            return MISSING_KEY;
+                        return rankOf.get(autoTextKey(value)) ?? MISSING_KEY;
+                    };
                 }
                 else {
                     keys = strings;
                     compare = compareCollatedKeys;
+                    keyOf = (row) => {
+                        const value = row.getCellValueByColumnId(columnId);
+                        return typeof value === 'number' ? MISSING_KEY : autoTextKey(value);
+                    };
                 }
             }
             else {
+                keyOf = (row) => row.getCellValueByColumnId(columnId);
                 for (let i = 0; i < n; i++)
-                    keys[i] = rows[i].getCellValueByColumnId(columnId);
+                    keys[i] = keyOf(rows[i]);
                 compare = comparator;
             }
-            clauses.push({ keys, desc: clause.desc, compare });
+            clauses.push({ keys, desc: clause.desc, compare, keyOf });
         }
         if (!clauses.length)
-            return rows;
+            return null;
         // Sort an index array, then materialise. `Array.prototype.sort` is stable,
         // so equal keys keep their original relative order exactly as the previous
         // `[...rows].sort(...)` did.
@@ -730,18 +946,203 @@ export function createSortedRowModel(localSortFns = sortFns) {
         const sorted = new Array(rows.length);
         for (let i = 0; i < order.length; i++)
             sorted[i] = rows[order[i]];
-        return sorted;
+        // Each row keeps its key(s), so a later tick can place a replacement
+        // among the kept rows without reading any of them again. One property
+        // write per row; an array per row only when there are several clauses.
+        if (clauses.length === 1) {
+            const keys = clauses[0].keys;
+            for (let i = 0; i < rows.length; i++)
+                rows[i][ROW_SORT_KEY] = keys[i];
+        }
+        else {
+            for (let i = 0; i < rows.length; i++) {
+                const per = new Array(clauses.length);
+                for (let k = 0; k < clauses.length; k++)
+                    per[k] = clauses[k].keys[i];
+                rows[i][ROW_SORT_KEY] = per;
+            }
+        }
+        return { sorted, clauses: clauses.map(({ desc, compare, keyOf }) => ({ desc, compare, keyOf })) };
+    }
+    /**
+     * The previous output with the replaced rows swapped for their
+     * replacements, in sorted position. Null when the input is not the cached
+     * input plus replacements, or a replacement has no incremental key.
+     *
+     * Every row carries the key(s) the last full sort computed for it
+     * (ROW_SORT_KEY: the key itself for one clause, an array for several), so
+     * the merge moves row references and nothing else. At 100k rows the loop
+     * that also copied an aligned key array cost 3.7 ms; this one is the
+     * reference copy alone.
+     */
+    function repair(rows, replaced) {
+        const c = cache;
+        if (rows.length !== c.input.length)
+            return null;
+        // Which rows of THIS stage's input changed. The map may name rows a
+        // stage upstream filtered out; only the ones that reach here matter.
+        const dropGen = ++sortDropGeneration;
+        const added = [];
+        for (let i = 0; i < rows.length; i++) {
+            const prev = c.input[i];
+            const next = rows[i];
+            if (next === prev)
+                continue;
+            if (replaced.get(prev) !== next)
+                return null;
+            prev[ROW_SORT_DROPPED] = dropGen;
+            added.push(next);
+        }
+        if (!added.length)
+            return c.output;
+        const clauses = c.clauses;
+        const single = clauses.length === 1;
+        for (let j = 0; j < added.length; j++) {
+            const row = added[j];
+            if (single) {
+                const key = clauses[0].keyOf(row);
+                if (key === MISSING_KEY)
+                    return null;
+                row[ROW_SORT_KEY] = key;
+            }
+            else {
+                const keys = new Array(clauses.length);
+                for (let k = 0; k < clauses.length; k++) {
+                    const key = clauses[k].keyOf(row);
+                    if (key === MISSING_KEY)
+                        return null;
+                    keys[k] = key;
+                }
+                row[ROW_SORT_KEY] = keys;
+            }
+        }
+        // Keys first, then the data index: the tie-break a stable sort over
+        // data-ordered input applies, so the merge lands where a full sort would.
+        const prevOut = c.output;
+        const compareRows = single
+            ? (() => {
+                const { compare, desc } = clauses[0];
+                return (a, b) => {
+                    const r = compare(a[ROW_SORT_KEY], b[ROW_SORT_KEY]);
+                    if (r !== 0)
+                        return desc ? -r : r;
+                    return a.index - b.index;
+                };
+            })()
+            : (a, b) => {
+                const ka = a[ROW_SORT_KEY];
+                const kb = b[ROW_SORT_KEY];
+                for (let k = 0; k < clauses.length; k++) {
+                    const clause = clauses[k];
+                    const r = clause.compare(ka[k], kb[k]);
+                    if (r !== 0)
+                        return clause.desc ? -r : r;
+                }
+                return a.index - b.index;
+            };
+        // Sort the replacements among themselves (k log k)...
+        added.sort(compareRows);
+        // ...find where each one goes in the previous output by binary search
+        // (k log n comparisons, against the dropped rows too - they are skipped
+        // below, which does not move an insertion point)...
+        const n = prevOut.length;
+        const insertAt = new Array(added.length);
+        let lo = 0;
+        for (let j = 0; j < added.length; j++) {
+            // Monotone: the replacements are sorted, so each search starts where
+            // the previous one landed.
+            const row = added[j];
+            let hi = n;
+            while (lo < hi) {
+                const mid = (lo + hi) >>> 1;
+                if (compareRows(row, prevOut[mid]) < 0)
+                    hi = mid;
+                else
+                    lo = mid + 1;
+            }
+            insertAt[j] = lo;
+        }
+        // ...then one linear pass that only moves references.
+        const out = new Array(rows.length);
+        let w = 0;
+        let j = 0;
+        let nextInsert = insertAt[0] ?? -1;
+        for (let i = 0; i < n; i++) {
+            while (nextInsert === i) {
+                out[w++] = added[j++];
+                nextInsert = j < added.length ? insertAt[j] : -1;
+            }
+            const prev = prevOut[i];
+            if (prev[ROW_SORT_DROPPED] === dropGen)
+                continue;
+            out[w++] = prev;
+        }
+        while (j < added.length)
+            out[w++] = added[j++];
+        return out;
+    }
+    return function sortedRowModelStage({ table, rows }) {
+        const sorting = table.getState().sorting ?? [];
+        if (!sorting.length) {
+            cache = null;
+            return rows;
+        }
+        const columns = table.getAllColumns();
+        if (cache && cache.sorting === sorting && cache.columns === columns) {
+            if (cache.input === rows)
+                return cache.output;
+            const replaced = replacedRowsOf(table);
+            if (replaced) {
+                const repaired = repair(rows, replaced);
+                if (repaired) {
+                    cache = { ...cache, input: rows, output: repaired };
+                    return repaired;
+                }
+            }
+        }
+        const full = fullSort(rows, sorting, columns);
+        if (!full) {
+            cache = null;
+            return rows;
+        }
+        cache = { input: rows, output: full.sorted, sorting, columns, clauses: full.clauses };
+        return full.sorted;
     };
 }
 /**
- * Numeric key comparison for the built-in `number` and `date` comparators.
- * Subtraction rather than `<`/`>` on purpose: it reproduces the originals
- * exactly, NaN included. An unparseable date or a non-numeric value yields NaN,
- * and the sort spec turns a NaN comparison result into 0 (SortCompare coerces
- * it), which is the behaviour callers already depend on.
+ * Numeric key comparison for the built-in `number`, `date` and numeric
+ * `auto` comparators. Keys are never NaN (blanks and unparseable values map to
+ * -Infinity), but two -Infinity keys subtract to NaN, so equal keys return 0
+ * explicitly: the multi-clause sort reads any non-zero result, NaN included,
+ * as decided and would skip the next clause.
  */
 function compareNumericKeys(a, b) {
-    return a - b;
+    return a === b ? 0 : a - b;
+}
+/** Text key for the `auto` comparator: blanks become '' so they collate first. */
+function autoTextKey(value) {
+    return isBlankSortValue(value) ? '' : String(value);
+}
+/**
+ * How the `auto` comparator should treat a column: 'number' when every
+ * non-blank value is a number, 'mixed' when numbers share it with anything
+ * else, 'text' otherwise. One pass, stopping as soon as the answer is known.
+ */
+function autoSortMode(rows, columnId) {
+    let numbers = false;
+    let other = false;
+    for (let i = 0; i < rows.length; i++) {
+        const value = rows[i].getCellValueByColumnId(columnId);
+        if (isBlankSortValue(value))
+            continue;
+        if (typeof value === 'number')
+            numbers = true;
+        else
+            other = true;
+        if (numbers && other)
+            return 'mixed';
+    }
+    return numbers ? 'number' : 'text';
 }
 /**
  * Text key comparison for the built-in `auto` comparator.
@@ -788,6 +1189,8 @@ export function createSvGridCore(options) {
     let cachedBaseRowsInput = null;
     let cachedBaseRowsColumns = null;
     let cachedBaseRows = [];
+    /** Old row -> new row for the rebuild the next pipeline run follows; see `replacedRowsOf`. */
+    let replacedRows = null;
     let cachedRowCtx = null;
     let cachedRowModel = null;
     let cachedRowModelBaseRows = null;
@@ -968,7 +1371,11 @@ export function createSvGridCore(options) {
         },
         getRowModel() {
             const columns = grid.getAllColumns();
-            if (cachedBaseRowsInput !== options.data || cachedBaseRowsColumns !== columns) {
+            // Read once. `options.data` is a getter when <SvGrid> drives the engine
+            // (a $state.raw signal), and the rebuild below touched it twice per row:
+            // 200k tracked reads per 100k-row tick, 11 ms of a 65 ms tick.
+            const data = options.data;
+            if (cachedBaseRowsInput !== data || cachedBaseRowsColumns !== columns) {
                 // Same columns as last time: the shared context still describes them,
                 // and a row whose data object sits at the same index can keep its
                 // row object. A row model that streams blocks hands the grid a new
@@ -978,7 +1385,11 @@ export function createSvGridCore(options) {
                 // an app may have changed the object in place before passing a new
                 // array - that is the case the old rebuild covered by accident.
                 const previous = cachedBaseRowsColumns === columns && cachedRowCtx ? cachedBaseRows : null;
-                cachedBaseRowsInput = options.data;
+                // Same length as last time: a replacement, not an add or remove, so
+                // each new row stands in for the old row at its index and the stages
+                // can repair rather than recompute. Anything else is structural.
+                replacedRows = previous && previous.length === data.length ? new Map() : null;
+                cachedBaseRowsInput = data;
                 cachedBaseRowsColumns = columns;
                 // O(1) column-id → index lookup so getCellValueByColumnId doesn't do
                 // a linear `findIndex` on every cell read (was O(rows × cells × cols)).
@@ -1001,11 +1412,11 @@ export function createSvGridCore(options) {
                     };
                     cachedRowCtx = rowCtx;
                 }
-                cachedBaseRows = new Array(options.data.length);
+                cachedBaseRows = new Array(data.length);
                 const getRowId = options.getRowId;
                 const m = BASE_ROW_METHODS;
-                for (let index = 0; index < options.data.length; index++) {
-                    const original = options.data[index];
+                for (let index = 0; index < data.length; index++) {
+                    const original = data[index];
                     const kept = previous?.[index];
                     if (kept && kept.original === original) {
                         kept[ROW_VALUES] = null;
@@ -1013,6 +1424,10 @@ export function createSvGridCore(options) {
                         cachedBaseRows[index] = kept;
                         continue;
                     }
+                    // Past a quarter of the rows the merge stops being cheaper than a
+                    // sort with the ranking pass; let the stages do the full work.
+                    if (replacedRows && replacedRows.size * 4 >= data.length)
+                        replacedRows = null;
                     // `_values` and `_cells` stay null until something reads them - a
                     // 100k-row grid showing twenty rows must not materialise every row's
                     // values or cell objects to paint.
@@ -1024,6 +1439,10 @@ export function createSvGridCore(options) {
                         [ROW_CTX]: rowCtx,
                         [ROW_VALUES]: null,
                         [ROW_CELLS]: null,
+                        [ROW_FILTER_GEN]: 0,
+                        [ROW_FILTER_POS]: -1,
+                        [ROW_SORT_DROPPED]: 0,
+                        [ROW_SORT_KEY]: undefined,
                         getCanExpand: m.getCanExpand,
                         getIsExpanded: m.getIsExpanded,
                         toggleExpanded: m.toggleExpanded,
@@ -1033,7 +1452,17 @@ export function createSvGridCore(options) {
                         getCellValueByColumnId: m.getCellValueByColumnId,
                     };
                     cachedBaseRows[index] = row;
+                    if (replacedRows && kept)
+                        replacedRows.set(kept, row);
                 }
+                // A new array with every object the same is the documented way to
+                // say "I changed rows in place, re-read them" (docs/help/cells/
+                // view-refresh.md). Nothing was replaced, so there is nothing to
+                // repair around: the stages recompute from the current values. A
+                // repair assumes the rows it keeps are unchanged in value as well as
+                // identity, which is the immutable-update contract a tick follows.
+                if (replacedRows && replacedRows.size === 0)
+                    replacedRows = null;
             }
             // Only the slices a pipeline stage actually READS belong in this key.
             //
@@ -1075,10 +1504,19 @@ export function createSvGridCore(options) {
                 pipeline.expandedRowModel,
                 pipeline.paginatedRowModel,
             ];
-            ordered.forEach((fn) => {
-                if (fn)
-                    rows = fn({ table: grid, rows });
-            });
+            // The stages read the replacements through `replacedRowsOf` while the
+            // run lasts; a stage that runs outside one sees null.
+            replacedRowsByGrid.set(grid, replacedRows);
+            try {
+                ordered.forEach((fn) => {
+                    if (fn)
+                        rows = fn({ table: grid, rows });
+                });
+            }
+            finally {
+                replacedRowsByGrid.set(grid, null);
+                replacedRows = null;
+            }
             cachedPipeline = options._rowModels;
             cachedSlices = currentSlices;
             cachedRowModelBaseRows = cachedBaseRows;