@sheetwrite/wasm 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sheetwrite/wasm",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "Sheetwrite columnar store and data engine (Rust/WASM).",
   "license": "MIT",

package/pkg/sheetwrite_wasm.d.ts

@@ -20,10 +20,11 @@ export class CellOut {
 export class CellStore {
     free(): void;
     [Symbol.dispose](): void;
+    acknowledgeRevision(revision: bigint): void;
     /**
      * Allocate a logical sheet whose cell chunks materialize on page load or edit.
      */
-    addPagedSheet(n_cols: number, row_count: number, chunk_rows: number, byte_budget: number): number;
+    addPagedSheet(n_cols: number, row_count: number, chunk_rows: number, byte_budget: number, max_dirty_cells: number): number;
     addRows(sheet: number, at: number, count: number): void;
     /**
      * Allocate a sheet grid and return its numeric handle.
@@ -33,11 +34,29 @@ export class CellStore {
      * Column aggregate over numeric cells. op: 0 sum, 1 avg, 2 min, 3 max, 4 count.
      */
     aggregate(sheet: number, col: number, op: number): number;
+    beginMutation(): bigint;
     beginPageLoad(): void;
+    canDirtyCell(sheet: number, row: number, col: number): boolean;
     /**
      * Capture a dense rectangle into an opaque store-local history resource.
      */
     captureRange(sheet: number, r0: number, c0: number, rows: number, cols: number): RangeSnapshot | undefined;
+    /**
+     * Capture only persisted references for one sheet. The explicit entry cap
+     * bounds allocation for host-side structural admission simulation.
+     */
+    captureReferences(sheet: number, max_entries: number): SourceSnapshot | undefined;
+    /**
+     * Capture only persisted formula/reference sources in a rectangle. The
+     * returned opaque object is compact in source cardinality, not cell count.
+     */
+    captureSources(sheet: number, r0: number, c0: number, rows: number, cols: number): SourceSnapshot | undefined;
+    /**
+     * Capture persisted formula/reference sources and derived-spill identity
+     * for arbitrary row/column coordinates in one boundary crossing. Offsets
+     * follow the caller's row-major coordinate order.
+     */
+    captureSourcesForRows(sheet: number, rows: Uint32Array, cols: Uint32Array): SourceSnapshot | undefined;
     /**
      * 0 unloaded, 1 loaded-empty, 2 loaded-value, 3 dirty local edit.
      */
@@ -48,6 +67,11 @@ export class CellStore {
      */
     clearRange(sheet: number, r0: number, c0: number, r1: number, c1: number, contents: boolean, style: boolean): boolean;
     colCount(sheet: number): number;
+    columnsFullyLoaded(sheet: number, start_row: number, end_row: number, cols: Uint32Array): boolean;
+    /**
+     * Release geometric growth slack after a bounded bulk ingest.
+     */
+    compactStringStorage(): void;
     /**
      * Ctrl+Arrow destination: from `(row, col)` stepping by `(d_row, d_col)`
      * (exactly one of them ±1), return the destination row (vertical moves) or
@@ -60,13 +84,19 @@ export class CellStore {
      */
     dataEdge(sheet: number, row: number, col: number, d_row: number, d_col: number): number;
     dataEdgeOrdered(sheet: number, order: Uint32Array, row: number, col: number, d_row: number, d_col: number): number;
+    dirtyRevision(sheet: number, row: number, col: number): bigint;
     distinctValues(sheet: number, col: number, limit: number): DistinctColumn;
+    endMutation(): void;
     endPageLoad(): void;
     /**
      * Data-row indices whose column text contains `needle` (case-insensitive).
      */
     filterRows(sheet: number, col: number, needle: string): Uint32Array;
     filterRowsMulti(sheet: number, cols: Uint32Array, kinds: Uint8Array, flags: Uint8Array, nums: Float64Array, num_counts: Uint32Array, text_counts: Uint32Array, value_nums: Float64Array, value_texts: string[]): Uint32Array;
+    /**
+     * Benchmark diagnostic: `[current matrix bytes, peak matrix bytes, allocations]`.
+     */
+    formulaMatrixResourceStats(): Float64Array;
     formulaSource(sheet: number, row: number, col: number): string | undefined;
     /**
      * Single-cell read for interactions/tests — never the render hot path.
@@ -98,12 +128,23 @@ export class CellStore {
     isFullyLoaded(sheet: number): boolean;
     isPaged(sheet: number): boolean;
     isSheetAlive(sheet: number): boolean;
+    markCellCleanRevision(sheet: number, row: number, col: number, revision: bigint): boolean;
     markRangeClean(sheet: number, start_row: number, end_row: number, start_col: number, end_col: number): void;
+    memoryStats(): Float64Array;
     constructor();
+    pagedDirtyCoordinates(sheet: number): Float64Array;
     /**
-     * `[chunks, loaded cells, dirty cells, allocated bytes, fully loaded]`.
+     * `[chunks, loaded cells, dirty cells, clean chunk bytes, fully loaded, dirty bytes]`.
      */
     pagedStats(sheet: number): Float64Array;
+    /**
+     * Sparse persisted-cell records. Each record starts with
+     * `[row, col, kind, number, style, string_id, source_kind, source_length]`.
+     * Formula UTF-8 is packed into little-endian u32 words; references append
+     * one `[sheet, row, col]` triple. The allocation scales with serialized
+     * cells and source bytes, never the logical sheet rectangle.
+     */
+    persistedCellData(sheet: number): Float64Array;
     pinRange(sheet: number, start_row: number, end_row: number, cols: Uint32Array): void;
     poolStrings(ids: Uint32Array): string[];
     /**
@@ -124,11 +165,22 @@ export class CellStore {
      * when many downstream formulas reference it.
      */
     recompute(sheet: number): void;
+    /**
+     * Recompute the union of every dirty sheet once at the host transaction
+     * barrier, including cross-sheet formula and plain-reference dependents.
+     */
+    recomputeChanged(): void;
     /**
      * Explicit volatile barrier. `serial` is a UTC spreadsheet serial using
      * the 1899-12-30 epoch; only TODAY/NOW formulas and their dependents dirty.
      */
     recomputeVolatile(serial: number): boolean;
+    referenceTarget(sheet: number, row: number, col: number): Uint32Array | undefined;
+    /**
+     * Return packed `[source_sheet, source_row, source_col, ...]` references
+     * targeting one sheet, bounded before crossing into the host.
+     */
+    referencesTargeting(target_sheet: number, max_entries: number): Uint32Array | undefined;
     /**
      * Remap styles over a rectangle using parallel old/new id tables.
      */
@@ -140,10 +192,12 @@ export class CellStore {
      * Tombstone a stable sheet handle and invalidate every formula reference to it.
      */
     removeSheet(sheet: number): boolean;
+    removeTable(id: string): boolean;
     /**
      * Rename a live stable sheet handle and rewrite every resolved formula AST reference.
      */
     renameSheet(sheet: number, id: string, name: string): boolean;
+    resetFormulaMatrixResourceStats(): void;
     resetQueryResourceStats(): void;
     /**
      * Restore a captured block at a destination of the same dimensions.
@@ -157,11 +211,13 @@ export class CellStore {
      */
     search(sheet: number, cols: Uint32Array, query: string, case_insensitive: boolean, whole_cell: boolean): Uint32Array;
     /**
-     * Write one row-major typed block in a single boundary call. `kinds` uses
-     * 0 empty / 1 number / 2 string; formulas and references are sparse host
-     * exceptions applied after this literal bulk write.
+     * Atomically write one row-major mixed literal/formula/reference block.
+     * Formula/reference offsets are sparse row-major exceptions. Reference
+     * targets are packed `[sheet_handle, row, col]` triples. The compact
+     * status is `0` success, `1` invalid shape/bounds, `2` invalid or duplicate
+     * source metadata, and `3` paged dirty-capacity rejection.
      */
-    setBlock(sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, texts: string[], styles: Uint32Array): boolean;
+    setBlock(sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, texts: string[], styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array): number;
     setBool(sheet: number, row: number, col: number, value: boolean, style: number): void;
     /**
      * Bulk-load one column with numbers starting at `start_row`.
@@ -181,10 +237,10 @@ export class CellStore {
     /**
      * Replace a sheet's conditional-format rules. Packed columnar encoding,
      * one entry per rule: `kinds` 0 gt / 1 lt / 2 eqNum / 3 eqStr / 4 eqEmpty /
-     * 5 contains; `bounds` = normalized `[r0, c0, r1, c1]` per rule; `nums`
-     * carries the numeric operand; `strs` the text operand; `flags` bit 0 =
-     * match-case for `contains`. Case-insensitive needles are lowercased here
-     * once so the per-cell match never allocates.
+     * 5 contains / 6 boolean formula; `bounds` = normalized `[r0, c0, r1, c1]`
+     * per rule; `nums` carries the numeric operand; `strs` the text/formula
+     * operand; `flags` bit 0 = match-case for `contains`, bit 1 = stop-if-true.
+     * Formula strings are parsed once here, never once per visible cell.
      */
     setConditionalRules(sheet: number, kinds: Uint8Array, bounds: Uint32Array, nums: Float64Array, strs: string[], flags: Uint8Array): void;
     /**
@@ -200,7 +256,20 @@ export class CellStore {
     setNamedRange(name: string, scope: number, sheet: number, row_start: number, col_start: number, row_end: number, col_end: number): boolean;
     setNumber(sheet: number, row: number, col: number, value: number, style: number): void;
     setSheetName(sheet: number, id: string, name: string): void;
+    /**
+     * Write one sparse mixed transaction/page/snapshot block without
+     * allocating by logical rectangle size. Inside `beginPageLoad`, dirty
+     * paged cells are skipped; otherwise the whole sparse write is preflighted.
+     */
+    setSparseBlock(sheet: number, start_row: number, start_col: number, rows: number, cols: number, offsets: Uint32Array, kinds: Uint8Array, numbers: Float64Array, texts: string[], styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array): number;
+    /**
+     * Replace the host-owned merge/protection collision ranges. Packed as
+     * `[row_start, col_start, row_end, col_end, ...]`; invalid input fails
+     * without weakening the old gate.
+     */
+    setSpillBlockers(sheet: number, bounds: Uint32Array): boolean;
     setString(sheet: number, row: number, col: number, value: string, style: number): void;
+    setTable(id: string, name: string, sheet: number, row_start: number, col_start: number, row_end: number, col_end: number, header_row: boolean, totals_row: boolean, column_ids: string[], column_names: string[]): boolean;
     snapshotNumbers(snapshot: RangeSnapshot): Float64Array;
     snapshotTexts(snapshot: RangeSnapshot): string[];
     /**
@@ -208,12 +277,28 @@ export class CellStore {
      */
     sortRows(sheet: number, col: number, ascending: boolean): Uint32Array;
     sortRowsMulti(sheet: number, cols: Uint32Array, ascending: Uint8Array, candidates: Uint32Array): Uint32Array;
+    spillAnchorCol(sheet: number, row: number, col: number): number;
+    /**
+     * Stable spill owner coordinate, or `u32::MAX` when `cell` is not part of
+     * a materialized spill.
+     */
+    spillAnchorRow(sheet: number, row: number, col: number): number;
+    /**
+     * Row-major mask aligned with render-window layout; `1` marks a derived
+     * spill cell and deliberately excludes the anchor.
+     */
+    spillDerivedMask(sheet: number, row_start: number, row_end: number, cols: Uint32Array): Uint8Array;
+    /**
+     * Packed row-major `[anchor_row, anchor_col, ...]` owner coordinates.
+     */
+    spillOwnerCoordinates(sheet: number, row_start: number, row_end: number, cols: Uint32Array): Uint32Array;
     /**
      * Current style-dictionary id at a cell; `0` when out of bounds. Used by
      * the host to write derived (reference-shadow) values without disturbing
      * the cell's style.
      */
     styleIdAt(sheet: number, row: number, col: number): number;
+    wasmCommittedBytes(): number;
 }
 
 /**
@@ -254,9 +339,28 @@ export class RangeSnapshot {
     formulaOffsets(): Uint32Array;
     formulaSources(): string[];
     kinds(): Uint8Array;
+    referenceOffsets(): Uint32Array;
+    referenceTargets(): Uint32Array;
     styleIds(): Uint32Array;
 }
 
+/**
+ * Compact serializable projection of persisted derived-cell sources and spill
+ * identity in one range. Offsets are row-major and sorted; reference targets
+ * are packed `[sheet_handle, row, col]` triples.
+ */
+export class SourceSnapshot {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    byteLength(): number;
+    formulaOffsets(): Uint32Array;
+    formulaSources(): string[];
+    referenceOffsets(): Uint32Array;
+    referenceTargets(): Uint32Array;
+    spillDerived(): Uint8Array;
+}
+
 /**
  * A bulk window of resolved cells, row-major over `n_rows x n_cols`.
  */
@@ -310,27 +414,39 @@ export interface InitOutput {
     readonly __wbg_cellstore_free: (a: number, b: number) => void;
     readonly __wbg_distinctcolumn_free: (a: number, b: number) => void;
     readonly __wbg_rangesnapshot_free: (a: number, b: number) => void;
+    readonly __wbg_sourcesnapshot_free: (a: number, b: number) => void;
     readonly __wbg_windowview_free: (a: number, b: number) => void;
     readonly cellout_kind: (a: number) => number;
     readonly cellout_num: (a: number) => number;
     readonly cellout_string: (a: number) => [number, number];
     readonly cellout_style: (a: number) => number;
-    readonly cellstore_addPagedSheet: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly cellstore_acknowledgeRevision: (a: number, b: bigint) => void;
+    readonly cellstore_addPagedSheet: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly cellstore_addRows: (a: number, b: number, c: number, d: number) => void;
     readonly cellstore_addSheet: (a: number, b: number, c: number) => number;
     readonly cellstore_aggregate: (a: number, b: number, c: number, d: number) => number;
+    readonly cellstore_beginMutation: (a: number) => bigint;
     readonly cellstore_beginPageLoad: (a: number) => void;
+    readonly cellstore_canDirtyCell: (a: number, b: number, c: number, d: number) => number;
     readonly cellstore_captureRange: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly cellstore_captureReferences: (a: number, b: number, c: number) => number;
+    readonly cellstore_captureSources: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly cellstore_captureSourcesForRows: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly cellstore_cellState: (a: number, b: number, c: number, d: number) => number;
     readonly cellstore_clearCell: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cellstore_clearRange: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
     readonly cellstore_colCount: (a: number, b: number) => number;
+    readonly cellstore_columnsFullyLoaded: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly cellstore_compactStringStorage: (a: number) => void;
     readonly cellstore_dataEdge: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly cellstore_dataEdgeOrdered: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly cellstore_dirtyRevision: (a: number, b: number, c: number, d: number) => bigint;
     readonly cellstore_distinctValues: (a: number, b: number, c: number, d: number) => number;
+    readonly cellstore_endMutation: (a: number) => void;
     readonly cellstore_endPageLoad: (a: number) => void;
     readonly cellstore_filterRows: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly cellstore_filterRowsMulti: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number) => [number, number];
+    readonly cellstore_formulaMatrixResourceStats: (a: number) => [number, number];
     readonly cellstore_formulaSource: (a: number, b: number, c: number, d: number) => [number, number];
     readonly cellstore_getCell: (a: number, b: number, c: number, d: number) => number;
     readonly cellstore_getWindow: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
@@ -341,27 +457,36 @@ export interface InitOutput {
     readonly cellstore_isFullyLoaded: (a: number, b: number) => number;
     readonly cellstore_isPaged: (a: number, b: number) => number;
     readonly cellstore_isSheetAlive: (a: number, b: number) => number;
+    readonly cellstore_markCellCleanRevision: (a: number, b: number, c: number, d: number, e: bigint) => number;
     readonly cellstore_markRangeClean: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly cellstore_memoryStats: (a: number) => [number, number];
     readonly cellstore_new: () => number;
+    readonly cellstore_pagedDirtyCoordinates: (a: number, b: number) => [number, number];
     readonly cellstore_pagedStats: (a: number, b: number) => [number, number];
+    readonly cellstore_persistedCellData: (a: number, b: number) => [number, number];
     readonly cellstore_pinRange: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly cellstore_poolStrings: (a: number, b: number, c: number) => [number, number];
     readonly cellstore_queryResourceStats: (a: number) => [number, number];
     readonly cellstore_rangeFullyLoaded: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly cellstore_rangeStyleIds: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly cellstore_recompute: (a: number, b: number) => void;
+    readonly cellstore_recomputeChanged: (a: number) => void;
     readonly cellstore_recomputeVolatile: (a: number, b: number) => number;
+    readonly cellstore_referenceTarget: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly cellstore_referencesTargeting: (a: number, b: number, c: number) => [number, number];
     readonly cellstore_remapRangeStyles: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
     readonly cellstore_removeCols: (a: number, b: number, c: number, d: number) => void;
     readonly cellstore_removeNamedRange: (a: number, b: number, c: number, d: number) => number;
     readonly cellstore_removeRows: (a: number, b: number, c: number, d: number) => void;
     readonly cellstore_removeSheet: (a: number, b: number) => number;
+    readonly cellstore_removeTable: (a: number, b: number, c: number) => number;
     readonly cellstore_renameSheet: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly cellstore_resetFormulaMatrixResourceStats: (a: number) => void;
     readonly cellstore_resetQueryResourceStats: (a: number) => void;
     readonly cellstore_restoreRange: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly cellstore_rowCount: (a: number, b: number) => number;
     readonly cellstore_search: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
-    readonly cellstore_setBlock: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => number;
+    readonly cellstore_setBlock: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number) => number;
     readonly cellstore_setBool: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly cellstore_setColumnNumbers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly cellstore_setColumnStrings: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
@@ -371,12 +496,20 @@ export interface InitOutput {
     readonly cellstore_setNamedRange: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
     readonly cellstore_setNumber: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly cellstore_setSheetName: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly cellstore_setSparseBlock: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number) => number;
+    readonly cellstore_setSpillBlockers: (a: number, b: number, c: number, d: number) => number;
     readonly cellstore_setString: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly cellstore_setTable: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number) => number;
     readonly cellstore_snapshotNumbers: (a: number, b: number) => [number, number];
     readonly cellstore_snapshotTexts: (a: number, b: number) => [number, number];
     readonly cellstore_sortRows: (a: number, b: number, c: number, d: number) => [number, number];
     readonly cellstore_sortRowsMulti: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly cellstore_spillAnchorCol: (a: number, b: number, c: number, d: number) => number;
+    readonly cellstore_spillAnchorRow: (a: number, b: number, c: number, d: number) => number;
+    readonly cellstore_spillDerivedMask: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly cellstore_spillOwnerCoordinates: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly cellstore_styleIdAt: (a: number, b: number, c: number, d: number) => number;
+    readonly cellstore_wasmCommittedBytes: (a: number) => number;
     readonly distinctcolumn_takeKinds: (a: number) => [number, number];
     readonly distinctcolumn_takeNumbers: (a: number) => [number, number];
     readonly distinctcolumn_takeTexts: (a: number) => [number, number];
@@ -384,7 +517,15 @@ export interface InitOutput {
     readonly rangesnapshot_formulaOffsets: (a: number) => [number, number];
     readonly rangesnapshot_formulaSources: (a: number) => [number, number];
     readonly rangesnapshot_kinds: (a: number) => [number, number];
+    readonly rangesnapshot_referenceOffsets: (a: number) => [number, number];
+    readonly rangesnapshot_referenceTargets: (a: number) => [number, number];
     readonly rangesnapshot_styleIds: (a: number) => [number, number];
+    readonly sourcesnapshot_byteLength: (a: number) => number;
+    readonly sourcesnapshot_formulaOffsets: (a: number) => [number, number];
+    readonly sourcesnapshot_formulaSources: (a: number) => [number, number];
+    readonly sourcesnapshot_referenceOffsets: (a: number) => [number, number];
+    readonly sourcesnapshot_referenceTargets: (a: number) => [number, number];
+    readonly sourcesnapshot_spillDerived: (a: number) => [number, number];
     readonly windowview_nCols: (a: number) => number;
     readonly windowview_nRows: (a: number) => number;
     readonly windowview_takeCondMatches: (a: number) => [number, number];

package/pkg/sheetwrite_wasm.js

@@ -70,16 +70,23 @@ export class CellStore {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_cellstore_free(ptr, 0);
     }
+    /**
+     * @param {bigint} revision
+     */
+    acknowledgeRevision(revision) {
+        wasm.cellstore_acknowledgeRevision(this.__wbg_ptr, revision);
+    }
     /**
      * Allocate a logical sheet whose cell chunks materialize on page load or edit.
      * @param {number} n_cols
      * @param {number} row_count
      * @param {number} chunk_rows
      * @param {number} byte_budget
+     * @param {number} max_dirty_cells
      * @returns {number}
      */
-    addPagedSheet(n_cols, row_count, chunk_rows, byte_budget) {
-        const ret = wasm.cellstore_addPagedSheet(this.__wbg_ptr, n_cols, row_count, chunk_rows, byte_budget);
+    addPagedSheet(n_cols, row_count, chunk_rows, byte_budget, max_dirty_cells) {
+        const ret = wasm.cellstore_addPagedSheet(this.__wbg_ptr, n_cols, row_count, chunk_rows, byte_budget, max_dirty_cells);
         return ret >>> 0;
     }
     /**
@@ -111,9 +118,26 @@ export class CellStore {
         const ret = wasm.cellstore_aggregate(this.__wbg_ptr, sheet, col, op);
         return ret;
     }
+    /**
+     * @returns {bigint}
+     */
+    beginMutation() {
+        const ret = wasm.cellstore_beginMutation(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     beginPageLoad() {
         wasm.cellstore_beginPageLoad(this.__wbg_ptr);
     }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {boolean}
+     */
+    canDirtyCell(sheet, row, col) {
+        const ret = wasm.cellstore_canDirtyCell(this.__wbg_ptr, sheet, row, col);
+        return ret !== 0;
+    }
     /**
      * Capture a dense rectangle into an opaque store-local history resource.
      * @param {number} sheet
@@ -127,6 +151,48 @@ export class CellStore {
         const ret = wasm.cellstore_captureRange(this.__wbg_ptr, sheet, r0, c0, rows, cols);
         return ret === 0 ? undefined : RangeSnapshot.__wrap(ret);
     }
+    /**
+     * Capture only persisted references for one sheet. The explicit entry cap
+     * bounds allocation for host-side structural admission simulation.
+     * @param {number} sheet
+     * @param {number} max_entries
+     * @returns {SourceSnapshot | undefined}
+     */
+    captureReferences(sheet, max_entries) {
+        const ret = wasm.cellstore_captureReferences(this.__wbg_ptr, sheet, max_entries);
+        return ret === 0 ? undefined : SourceSnapshot.__wrap(ret);
+    }
+    /**
+     * Capture only persisted formula/reference sources in a rectangle. The
+     * returned opaque object is compact in source cardinality, not cell count.
+     * @param {number} sheet
+     * @param {number} r0
+     * @param {number} c0
+     * @param {number} rows
+     * @param {number} cols
+     * @returns {SourceSnapshot | undefined}
+     */
+    captureSources(sheet, r0, c0, rows, cols) {
+        const ret = wasm.cellstore_captureSources(this.__wbg_ptr, sheet, r0, c0, rows, cols);
+        return ret === 0 ? undefined : SourceSnapshot.__wrap(ret);
+    }
+    /**
+     * Capture persisted formula/reference sources and derived-spill identity
+     * for arbitrary row/column coordinates in one boundary crossing. Offsets
+     * follow the caller's row-major coordinate order.
+     * @param {number} sheet
+     * @param {Uint32Array} rows
+     * @param {Uint32Array} cols
+     * @returns {SourceSnapshot | undefined}
+     */
+    captureSourcesForRows(sheet, rows, cols) {
+        const ptr0 = passArray32ToWasm0(rows, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(cols, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_captureSourcesForRows(this.__wbg_ptr, sheet, ptr0, len0, ptr1, len1);
+        return ret === 0 ? undefined : SourceSnapshot.__wrap(ret);
+    }
     /**
      * 0 unloaded, 1 loaded-empty, 2 loaded-value, 3 dirty local edit.
      * @param {number} sheet
@@ -170,6 +236,25 @@ export class CellStore {
         const ret = wasm.cellstore_colCount(this.__wbg_ptr, sheet);
         return ret >>> 0;
     }
+    /**
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} end_row
+     * @param {Uint32Array} cols
+     * @returns {boolean}
+     */
+    columnsFullyLoaded(sheet, start_row, end_row, cols) {
+        const ptr0 = passArray32ToWasm0(cols, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_columnsFullyLoaded(this.__wbg_ptr, sheet, start_row, end_row, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Release geometric growth slack after a bounded bulk ingest.
+     */
+    compactStringStorage() {
+        wasm.cellstore_compactStringStorage(this.__wbg_ptr);
+    }
     /**
      * Ctrl+Arrow destination: from `(row, col)` stepping by `(d_row, d_col)`
      * (exactly one of them ±1), return the destination row (vertical moves) or
@@ -205,6 +290,16 @@ export class CellStore {
         const ret = wasm.cellstore_dataEdgeOrdered(this.__wbg_ptr, sheet, ptr0, len0, row, col, d_row, d_col);
         return ret >>> 0;
     }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {bigint}
+     */
+    dirtyRevision(sheet, row, col) {
+        const ret = wasm.cellstore_dirtyRevision(this.__wbg_ptr, sheet, row, col);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * @param {number} sheet
      * @param {number} col
@@ -215,6 +310,9 @@ export class CellStore {
         const ret = wasm.cellstore_distinctValues(this.__wbg_ptr, sheet, col, limit);
         return DistinctColumn.__wrap(ret);
     }
+    endMutation() {
+        wasm.cellstore_endMutation(this.__wbg_ptr);
+    }
     endPageLoad() {
         wasm.cellstore_endPageLoad(this.__wbg_ptr);
     }
@@ -267,6 +365,16 @@ export class CellStore {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v9;
     }
+    /**
+     * Benchmark diagnostic: `[current matrix bytes, peak matrix bytes, allocations]`.
+     * @returns {Float64Array}
+     */
+    formulaMatrixResourceStats() {
+        const ret = wasm.cellstore_formulaMatrixResourceStats(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * @param {number} sheet
      * @param {number} row
@@ -395,6 +503,17 @@ export class CellStore {
         const ret = wasm.cellstore_isSheetAlive(this.__wbg_ptr, sheet);
         return ret !== 0;
     }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @param {bigint} revision
+     * @returns {boolean}
+     */
+    markCellCleanRevision(sheet, row, col, revision) {
+        const ret = wasm.cellstore_markCellCleanRevision(this.__wbg_ptr, sheet, row, col, revision);
+        return ret !== 0;
+    }
     /**
      * @param {number} sheet
      * @param {number} start_row
@@ -405,6 +524,15 @@ export class CellStore {
     markRangeClean(sheet, start_row, end_row, start_col, end_col) {
         wasm.cellstore_markRangeClean(this.__wbg_ptr, sheet, start_row, end_row, start_col, end_col);
     }
+    /**
+     * @returns {Float64Array}
+     */
+    memoryStats() {
+        const ret = wasm.cellstore_memoryStats(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     constructor() {
         const ret = wasm.cellstore_new();
         this.__wbg_ptr = ret;
@@ -412,7 +540,17 @@ export class CellStore {
         return this;
     }
     /**
-     * `[chunks, loaded cells, dirty cells, allocated bytes, fully loaded]`.
+     * @param {number} sheet
+     * @returns {Float64Array}
+     */
+    pagedDirtyCoordinates(sheet) {
+        const ret = wasm.cellstore_pagedDirtyCoordinates(this.__wbg_ptr, sheet);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * `[chunks, loaded cells, dirty cells, clean chunk bytes, fully loaded, dirty bytes]`.
      * @param {number} sheet
      * @returns {Float64Array}
      */
@@ -422,6 +560,21 @@ export class CellStore {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
+    /**
+     * Sparse persisted-cell records. Each record starts with
+     * `[row, col, kind, number, style, string_id, source_kind, source_length]`.
+     * Formula UTF-8 is packed into little-endian u32 words; references append
+     * one `[sheet, row, col]` triple. The allocation scales with serialized
+     * cells and source bytes, never the logical sheet rectangle.
+     * @param {number} sheet
+     * @returns {Float64Array}
+     */
+    persistedCellData(sheet) {
+        const ret = wasm.cellstore_persistedCellData(this.__wbg_ptr, sheet);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * @param {number} sheet
      * @param {number} start_row
@@ -494,6 +647,13 @@ export class CellStore {
     recompute(sheet) {
         wasm.cellstore_recompute(this.__wbg_ptr, sheet);
     }
+    /**
+     * Recompute the union of every dirty sheet once at the host transaction
+     * barrier, including cross-sheet formula and plain-reference dependents.
+     */
+    recomputeChanged() {
+        wasm.cellstore_recomputeChanged(this.__wbg_ptr);
+    }
     /**
      * Explicit volatile barrier. `serial` is a UTC spreadsheet serial using
      * the 1899-12-30 epoch; only TODAY/NOW formulas and their dependents dirty.
@@ -504,6 +664,37 @@ export class CellStore {
         const ret = wasm.cellstore_recomputeVolatile(this.__wbg_ptr, serial);
         return ret !== 0;
     }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {Uint32Array | undefined}
+     */
+    referenceTarget(sheet, row, col) {
+        const ret = wasm.cellstore_referenceTarget(this.__wbg_ptr, sheet, row, col);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * Return packed `[source_sheet, source_row, source_col, ...]` references
+     * targeting one sheet, bounded before crossing into the host.
+     * @param {number} target_sheet
+     * @param {number} max_entries
+     * @returns {Uint32Array | undefined}
+     */
+    referencesTargeting(target_sheet, max_entries) {
+        const ret = wasm.cellstore_referencesTargeting(this.__wbg_ptr, target_sheet, max_entries);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Remap styles over a rectangle using parallel old/new id tables.
      * @param {number} sheet
@@ -559,6 +750,16 @@ export class CellStore {
         const ret = wasm.cellstore_removeSheet(this.__wbg_ptr, sheet);
         return ret !== 0;
     }
+    /**
+     * @param {string} id
+     * @returns {boolean}
+     */
+    removeTable(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_removeTable(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
     /**
      * Rename a live stable sheet handle and rewrite every resolved formula AST reference.
      * @param {number} sheet
@@ -574,6 +775,9 @@ export class CellStore {
         const ret = wasm.cellstore_renameSheet(this.__wbg_ptr, sheet, ptr0, len0, ptr1, len1);
         return ret !== 0;
     }
+    resetFormulaMatrixResourceStats() {
+        wasm.cellstore_resetFormulaMatrixResourceStats(this.__wbg_ptr);
+    }
     resetQueryResourceStats() {
         wasm.cellstore_resetQueryResourceStats(this.__wbg_ptr);
     }
@@ -620,9 +824,11 @@ export class CellStore {
         return v3;
     }
     /**
-     * Write one row-major typed block in a single boundary call. `kinds` uses
-     * 0 empty / 1 number / 2 string; formulas and references are sparse host
-     * exceptions applied after this literal bulk write.
+     * Atomically write one row-major mixed literal/formula/reference block.
+     * Formula/reference offsets are sparse row-major exceptions. Reference
+     * targets are packed `[sheet_handle, row, col]` triples. The compact
+     * status is `0` success, `1` invalid shape/bounds, `2` invalid or duplicate
+     * source metadata, and `3` paged dirty-capacity rejection.
      * @param {number} sheet
      * @param {number} start_row
      * @param {number} start_col
@@ -632,9 +838,13 @@ export class CellStore {
      * @param {Float64Array} numbers
      * @param {string[]} texts
      * @param {Uint32Array} styles
-     * @returns {boolean}
+     * @param {Uint32Array} formula_offsets
+     * @param {string[]} formula_sources
+     * @param {Uint32Array} reference_offsets
+     * @param {Uint32Array} reference_targets
+     * @returns {number}
      */
-    setBlock(sheet, start_row, start_col, rows, cols, kinds, numbers, texts, styles) {
+    setBlock(sheet, start_row, start_col, rows, cols, kinds, numbers, texts, styles, formula_offsets, formula_sources, reference_offsets, reference_targets) {
         const ptr0 = passArray8ToWasm0(kinds, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF64ToWasm0(numbers, wasm.__wbindgen_malloc);
@@ -643,8 +853,16 @@ export class CellStore {
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArray32ToWasm0(styles, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.cellstore_setBlock(this.__wbg_ptr, sheet, start_row, start_col, rows, cols, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
-        return ret !== 0;
+        const ptr4 = passArray32ToWasm0(formula_offsets, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArrayJsValueToWasm0(formula_sources, wasm.__wbindgen_malloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArray32ToWasm0(reference_offsets, wasm.__wbindgen_malloc);
+        const len6 = WASM_VECTOR_LEN;
+        const ptr7 = passArray32ToWasm0(reference_targets, wasm.__wbindgen_malloc);
+        const len7 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_setBlock(this.__wbg_ptr, sheet, start_row, start_col, rows, cols, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7);
+        return ret >>> 0;
     }
     /**
      * @param {number} sheet
@@ -704,10 +922,10 @@ export class CellStore {
     /**
      * Replace a sheet's conditional-format rules. Packed columnar encoding,
      * one entry per rule: `kinds` 0 gt / 1 lt / 2 eqNum / 3 eqStr / 4 eqEmpty /
-     * 5 contains; `bounds` = normalized `[r0, c0, r1, c1]` per rule; `nums`
-     * carries the numeric operand; `strs` the text operand; `flags` bit 0 =
-     * match-case for `contains`. Case-insensitive needles are lowercased here
-     * once so the per-cell match never allocates.
+     * 5 contains / 6 boolean formula; `bounds` = normalized `[r0, c0, r1, c1]`
+     * per rule; `nums` carries the numeric operand; `strs` the text/formula
+     * operand; `flags` bit 0 = match-case for `contains`, bit 1 = stop-if-true.
+     * Formula strings are parsed once here, never once per visible cell.
      * @param {number} sheet
      * @param {Uint8Array} kinds
      * @param {Uint32Array} bounds
@@ -787,6 +1005,62 @@ export class CellStore {
         const len1 = WASM_VECTOR_LEN;
         wasm.cellstore_setSheetName(this.__wbg_ptr, sheet, ptr0, len0, ptr1, len1);
     }
+    /**
+     * Write one sparse mixed transaction/page/snapshot block without
+     * allocating by logical rectangle size. Inside `beginPageLoad`, dirty
+     * paged cells are skipped; otherwise the whole sparse write is preflighted.
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} rows
+     * @param {number} cols
+     * @param {Uint32Array} offsets
+     * @param {Uint8Array} kinds
+     * @param {Float64Array} numbers
+     * @param {string[]} texts
+     * @param {Uint32Array} styles
+     * @param {Uint32Array} formula_offsets
+     * @param {string[]} formula_sources
+     * @param {Uint32Array} reference_offsets
+     * @param {Uint32Array} reference_targets
+     * @returns {number}
+     */
+    setSparseBlock(sheet, start_row, start_col, rows, cols, offsets, kinds, numbers, texts, styles, formula_offsets, formula_sources, reference_offsets, reference_targets) {
+        const ptr0 = passArray32ToWasm0(offsets, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(kinds, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(numbers, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayJsValueToWasm0(texts, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(styles, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray32ToWasm0(formula_offsets, wasm.__wbindgen_malloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArrayJsValueToWasm0(formula_sources, wasm.__wbindgen_malloc);
+        const len6 = WASM_VECTOR_LEN;
+        const ptr7 = passArray32ToWasm0(reference_offsets, wasm.__wbindgen_malloc);
+        const len7 = WASM_VECTOR_LEN;
+        const ptr8 = passArray32ToWasm0(reference_targets, wasm.__wbindgen_malloc);
+        const len8 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_setSparseBlock(this.__wbg_ptr, sheet, start_row, start_col, rows, cols, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8);
+        return ret >>> 0;
+    }
+    /**
+     * Replace the host-owned merge/protection collision ranges. Packed as
+     * `[row_start, col_start, row_end, col_end, ...]`; invalid input fails
+     * without weakening the old gate.
+     * @param {number} sheet
+     * @param {Uint32Array} bounds
+     * @returns {boolean}
+     */
+    setSpillBlockers(sheet, bounds) {
+        const ptr0 = passArray32ToWasm0(bounds, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_setSpillBlockers(this.__wbg_ptr, sheet, ptr0, len0);
+        return ret !== 0;
+    }
     /**
      * @param {number} sheet
      * @param {number} row
@@ -799,6 +1073,32 @@ export class CellStore {
         const len0 = WASM_VECTOR_LEN;
         wasm.cellstore_setString(this.__wbg_ptr, sheet, row, col, ptr0, len0, style);
     }
+    /**
+     * @param {string} id
+     * @param {string} name
+     * @param {number} sheet
+     * @param {number} row_start
+     * @param {number} col_start
+     * @param {number} row_end
+     * @param {number} col_end
+     * @param {boolean} header_row
+     * @param {boolean} totals_row
+     * @param {string[]} column_ids
+     * @param {string[]} column_names
+     * @returns {boolean}
+     */
+    setTable(id, name, sheet, row_start, col_start, row_end, col_end, header_row, totals_row, column_ids, column_names) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayJsValueToWasm0(column_ids, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayJsValueToWasm0(column_names, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_setTable(this.__wbg_ptr, ptr0, len0, ptr1, len1, sheet, row_start, col_start, row_end, col_end, header_row, totals_row, ptr2, len2, ptr3, len3);
+        return ret !== 0;
+    }
     /**
      * @param {RangeSnapshot} snapshot
      * @returns {Float64Array}
@@ -853,6 +1153,61 @@ export class CellStore {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v4;
     }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {number}
+     */
+    spillAnchorCol(sheet, row, col) {
+        const ret = wasm.cellstore_spillAnchorCol(this.__wbg_ptr, sheet, row, col);
+        return ret >>> 0;
+    }
+    /**
+     * Stable spill owner coordinate, or `u32::MAX` when `cell` is not part of
+     * a materialized spill.
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {number}
+     */
+    spillAnchorRow(sheet, row, col) {
+        const ret = wasm.cellstore_spillAnchorRow(this.__wbg_ptr, sheet, row, col);
+        return ret >>> 0;
+    }
+    /**
+     * Row-major mask aligned with render-window layout; `1` marks a derived
+     * spill cell and deliberately excludes the anchor.
+     * @param {number} sheet
+     * @param {number} row_start
+     * @param {number} row_end
+     * @param {Uint32Array} cols
+     * @returns {Uint8Array}
+     */
+    spillDerivedMask(sheet, row_start, row_end, cols) {
+        const ptr0 = passArray32ToWasm0(cols, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_spillDerivedMask(this.__wbg_ptr, sheet, row_start, row_end, ptr0, len0);
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    /**
+     * Packed row-major `[anchor_row, anchor_col, ...]` owner coordinates.
+     * @param {number} sheet
+     * @param {number} row_start
+     * @param {number} row_end
+     * @param {Uint32Array} cols
+     * @returns {Uint32Array}
+     */
+    spillOwnerCoordinates(sheet, row_start, row_end, cols) {
+        const ptr0 = passArray32ToWasm0(cols, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cellstore_spillOwnerCoordinates(this.__wbg_ptr, sheet, row_start, row_end, ptr0, len0);
+        var v2 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
     /**
      * Current style-dictionary id at a cell; `0` when out of bounds. Used by
      * the host to write derived (reference-shadow) values without disturbing
@@ -866,6 +1221,13 @@ export class CellStore {
         const ret = wasm.cellstore_styleIdAt(this.__wbg_ptr, sheet, row, col);
         return ret >>> 0;
     }
+    /**
+     * @returns {number}
+     */
+    wasmCommittedBytes() {
+        const ret = wasm.cellstore_wasmCommittedBytes(this.__wbg_ptr);
+        return ret >>> 0;
+    }
 }
 if (Symbol.dispose) CellStore.prototype[Symbol.dispose] = CellStore.prototype.free;
 
@@ -982,6 +1344,24 @@ export class RangeSnapshot {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @returns {Uint32Array}
+     */
+    referenceOffsets() {
+        const ret = wasm.rangesnapshot_referenceOffsets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    referenceTargets() {
+        const ret = wasm.rangesnapshot_referenceTargets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @returns {Uint32Array}
      */
@@ -994,6 +1374,83 @@ export class RangeSnapshot {
 }
 if (Symbol.dispose) RangeSnapshot.prototype[Symbol.dispose] = RangeSnapshot.prototype.free;
 
+/**
+ * Compact serializable projection of persisted derived-cell sources and spill
+ * identity in one range. Offsets are row-major and sorted; reference targets
+ * are packed `[sheet_handle, row, col]` triples.
+ */
+export class SourceSnapshot {
+    static __wrap(ptr) {
+        const obj = Object.create(SourceSnapshot.prototype);
+        obj.__wbg_ptr = ptr;
+        SourceSnapshotFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SourceSnapshotFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sourcesnapshot_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    byteLength() {
+        const ret = wasm.sourcesnapshot_byteLength(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    formulaOffsets() {
+        const ret = wasm.sourcesnapshot_formulaOffsets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {string[]}
+     */
+    formulaSources() {
+        const ret = wasm.sourcesnapshot_formulaSources(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    referenceOffsets() {
+        const ret = wasm.sourcesnapshot_referenceOffsets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    referenceTargets() {
+        const ret = wasm.sourcesnapshot_referenceTargets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    spillDerived() {
+        const ret = wasm.sourcesnapshot_spillDerived(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) SourceSnapshot.prototype[Symbol.dispose] = SourceSnapshot.prototype.free;
+
 /**
  * A bulk window of resolved cells, row-major over `n_rows x n_cols`.
  */
@@ -1159,6 +1616,9 @@ const DistinctColumnFinalization = (typeof FinalizationRegistry === 'undefined')
 const RangeSnapshotFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rangesnapshot_free(ptr, 1));
+const SourceSnapshotFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sourcesnapshot_free(ptr, 1));
 const WindowViewFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_windowview_free(ptr, 1));

package/pkg/sheetwrite_wasm_bg.wasm.d.ts

@@ -5,27 +5,39 @@ export const __wbg_cellout_free: (a: number, b: number) => void;
 export const __wbg_cellstore_free: (a: number, b: number) => void;
 export const __wbg_distinctcolumn_free: (a: number, b: number) => void;
 export const __wbg_rangesnapshot_free: (a: number, b: number) => void;
+export const __wbg_sourcesnapshot_free: (a: number, b: number) => void;
 export const __wbg_windowview_free: (a: number, b: number) => void;
 export const cellout_kind: (a: number) => number;
 export const cellout_num: (a: number) => number;
 export const cellout_string: (a: number) => [number, number];
 export const cellout_style: (a: number) => number;
-export const cellstore_addPagedSheet: (a: number, b: number, c: number, d: number, e: number) => number;
+export const cellstore_acknowledgeRevision: (a: number, b: bigint) => void;
+export const cellstore_addPagedSheet: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const cellstore_addRows: (a: number, b: number, c: number, d: number) => void;
 export const cellstore_addSheet: (a: number, b: number, c: number) => number;
 export const cellstore_aggregate: (a: number, b: number, c: number, d: number) => number;
+export const cellstore_beginMutation: (a: number) => bigint;
 export const cellstore_beginPageLoad: (a: number) => void;
+export const cellstore_canDirtyCell: (a: number, b: number, c: number, d: number) => number;
 export const cellstore_captureRange: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const cellstore_captureReferences: (a: number, b: number, c: number) => number;
+export const cellstore_captureSources: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const cellstore_captureSourcesForRows: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const cellstore_cellState: (a: number, b: number, c: number, d: number) => number;
 export const cellstore_clearCell: (a: number, b: number, c: number, d: number, e: number) => void;
 export const cellstore_clearRange: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
 export const cellstore_colCount: (a: number, b: number) => number;
+export const cellstore_columnsFullyLoaded: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const cellstore_compactStringStorage: (a: number) => void;
 export const cellstore_dataEdge: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const cellstore_dataEdgeOrdered: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+export const cellstore_dirtyRevision: (a: number, b: number, c: number, d: number) => bigint;
 export const cellstore_distinctValues: (a: number, b: number, c: number, d: number) => number;
+export const cellstore_endMutation: (a: number) => void;
 export const cellstore_endPageLoad: (a: number) => void;
 export const cellstore_filterRows: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const cellstore_filterRowsMulti: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number) => [number, number];
+export const cellstore_formulaMatrixResourceStats: (a: number) => [number, number];
 export const cellstore_formulaSource: (a: number, b: number, c: number, d: number) => [number, number];
 export const cellstore_getCell: (a: number, b: number, c: number, d: number) => number;
 export const cellstore_getWindow: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
@@ -36,27 +48,36 @@ export const cellstore_insertCols: (a: number, b: number, c: number, d: number)
 export const cellstore_isFullyLoaded: (a: number, b: number) => number;
 export const cellstore_isPaged: (a: number, b: number) => number;
 export const cellstore_isSheetAlive: (a: number, b: number) => number;
+export const cellstore_markCellCleanRevision: (a: number, b: number, c: number, d: number, e: bigint) => number;
 export const cellstore_markRangeClean: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const cellstore_memoryStats: (a: number) => [number, number];
 export const cellstore_new: () => number;
+export const cellstore_pagedDirtyCoordinates: (a: number, b: number) => [number, number];
 export const cellstore_pagedStats: (a: number, b: number) => [number, number];
+export const cellstore_persistedCellData: (a: number, b: number) => [number, number];
 export const cellstore_pinRange: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const cellstore_poolStrings: (a: number, b: number, c: number) => [number, number];
 export const cellstore_queryResourceStats: (a: number) => [number, number];
 export const cellstore_rangeFullyLoaded: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const cellstore_rangeStyleIds: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const cellstore_recompute: (a: number, b: number) => void;
+export const cellstore_recomputeChanged: (a: number) => void;
 export const cellstore_recomputeVolatile: (a: number, b: number) => number;
+export const cellstore_referenceTarget: (a: number, b: number, c: number, d: number) => [number, number];
+export const cellstore_referencesTargeting: (a: number, b: number, c: number) => [number, number];
 export const cellstore_remapRangeStyles: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
 export const cellstore_removeCols: (a: number, b: number, c: number, d: number) => void;
 export const cellstore_removeNamedRange: (a: number, b: number, c: number, d: number) => number;
 export const cellstore_removeRows: (a: number, b: number, c: number, d: number) => void;
 export const cellstore_removeSheet: (a: number, b: number) => number;
+export const cellstore_removeTable: (a: number, b: number, c: number) => number;
 export const cellstore_renameSheet: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const cellstore_resetFormulaMatrixResourceStats: (a: number) => void;
 export const cellstore_resetQueryResourceStats: (a: number) => void;
 export const cellstore_restoreRange: (a: number, b: number, c: number, d: number, e: number) => number;
 export const cellstore_rowCount: (a: number, b: number) => number;
 export const cellstore_search: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
-export const cellstore_setBlock: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => number;
+export const cellstore_setBlock: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number) => number;
 export const cellstore_setBool: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const cellstore_setColumnNumbers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const cellstore_setColumnStrings: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
@@ -66,12 +87,20 @@ export const cellstore_setFormula: (a: number, b: number, c: number, d: number,
 export const cellstore_setNamedRange: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
 export const cellstore_setNumber: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const cellstore_setSheetName: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const cellstore_setSparseBlock: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number) => number;
+export const cellstore_setSpillBlockers: (a: number, b: number, c: number, d: number) => number;
 export const cellstore_setString: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const cellstore_setTable: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number) => number;
 export const cellstore_snapshotNumbers: (a: number, b: number) => [number, number];
 export const cellstore_snapshotTexts: (a: number, b: number) => [number, number];
 export const cellstore_sortRows: (a: number, b: number, c: number, d: number) => [number, number];
 export const cellstore_sortRowsMulti: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+export const cellstore_spillAnchorCol: (a: number, b: number, c: number, d: number) => number;
+export const cellstore_spillAnchorRow: (a: number, b: number, c: number, d: number) => number;
+export const cellstore_spillDerivedMask: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const cellstore_spillOwnerCoordinates: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const cellstore_styleIdAt: (a: number, b: number, c: number, d: number) => number;
+export const cellstore_wasmCommittedBytes: (a: number) => number;
 export const distinctcolumn_takeKinds: (a: number) => [number, number];
 export const distinctcolumn_takeNumbers: (a: number) => [number, number];
 export const distinctcolumn_takeTexts: (a: number) => [number, number];
@@ -79,7 +108,15 @@ export const rangesnapshot_byteLength: (a: number) => number;
 export const rangesnapshot_formulaOffsets: (a: number) => [number, number];
 export const rangesnapshot_formulaSources: (a: number) => [number, number];
 export const rangesnapshot_kinds: (a: number) => [number, number];
+export const rangesnapshot_referenceOffsets: (a: number) => [number, number];
+export const rangesnapshot_referenceTargets: (a: number) => [number, number];
 export const rangesnapshot_styleIds: (a: number) => [number, number];
+export const sourcesnapshot_byteLength: (a: number) => number;
+export const sourcesnapshot_formulaOffsets: (a: number) => [number, number];
+export const sourcesnapshot_formulaSources: (a: number) => [number, number];
+export const sourcesnapshot_referenceOffsets: (a: number) => [number, number];
+export const sourcesnapshot_referenceTargets: (a: number) => [number, number];
+export const sourcesnapshot_spillDerived: (a: number) => [number, number];
 export const windowview_nCols: (a: number) => number;
 export const windowview_nRows: (a: number) => number;
 export const windowview_takeCondMatches: (a: number) => [number, number];