@sheetwrite/wasm 0.4.0 → 0.5.0

package/loader-browser.mjs

@@ -1,5 +1,6 @@
 import { createLoader } from "./loader-state.mjs";
 import init from "./pkg/sheetwrite_wasm.js";
+import { adoptPublishedModule, createInstance } from "./pkg/sheetwrite_wasm_factory.js";
 
 export * from "./pkg/sheetwrite_wasm.js";
 
@@ -12,3 +13,11 @@ const loader = createLoader(async (source) => {
 });
 
 export const { load, isLoaded } = loader;
+
+/** Create an independently collectible engine, optionally reusing compiled code. */
+export async function createEngine(source) {
+  const engine = createInstance();
+  await engine.init(source === undefined ? undefined : { module_or_path: source });
+  await loader.adopt(source, () => adoptPublishedModule(engine.getModule()));
+  return engine;
+}

package/loader-node.mjs

@@ -1,6 +1,8 @@
 import { readFile } from "node:fs/promises";
+
 import { createLoader } from "./loader-state.mjs";
 import init, { initSync } from "./pkg/sheetwrite_wasm.js";
+import { adoptPublishedModule, createInstance } from "./pkg/sheetwrite_wasm_factory.js";
 
 export * from "./pkg/sheetwrite_wasm.js";
 
@@ -15,3 +17,20 @@ const loader = createLoader(async (source) => {
 });
 
 export const { load, isLoaded } = loader;
+
+/** Create an independently collectible engine, optionally reusing compiled code. */
+export async function createEngine(source) {
+  const engine = createInstance();
+
+  if (source === undefined) {
+    engine.initSync({
+      module: await readFile(new URL("./pkg/sheetwrite_wasm_bg.wasm", import.meta.url)),
+    });
+  } else {
+    await engine.init({ module_or_path: source });
+  }
+
+  await loader.adopt(source, () => adoptPublishedModule(engine.getModule()));
+
+  return engine;
+}

package/loader-state.mjs

@@ -23,6 +23,7 @@ export function createLoader(initialize) {
       if (source !== undefined && source !== selectedSource) {
         console.warn(DIFFERENT_SOURCE_AFTER_INIT);
       }
+
       return;
     }
 
@@ -30,6 +31,7 @@ export function createLoader(initialize) {
       if (source !== undefined && source !== selectedSource) {
         throw new Error(DIFFERENT_SOURCE_IN_FLIGHT);
       }
+
       return inFlight;
     }
 
@@ -50,5 +52,28 @@ export function createLoader(initialize) {
     return ready;
   }
 
-  return { load, isLoaded };
+  /**
+   * Mark the published exports ready from an engine instance that already compiled the module.
+   * A load() in flight wins; `publish` runs only when this call makes the loader ready.
+   *
+   * @param {BufferSource | URL | string | Request | WebAssembly.Module | undefined} source
+   * @param {() => void} publish
+   */
+  async function adopt(source, publish) {
+    if (inFlight) {
+      try {
+        await inFlight;
+      } catch {
+        // A failed load() leaves the loader free for this instance to adopt.
+      }
+    }
+
+    if (ready) return;
+
+    publish();
+    selectedSource = source;
+    ready = true;
+  }
+
+  return { load, isLoaded, adopt };
 }

package/loader.d.ts

@@ -1,3 +1,5 @@
+import type * as WasmExports from "./pkg/sheetwrite_wasm.js";
+
 export * from "./pkg/sheetwrite_wasm.js";
 
 /** Sources accepted by asynchronous initialization: a fetchable URL/request/response, raw module bytes, or a precompiled `WebAssembly.Module`. */
@@ -22,3 +24,18 @@ export declare function load(
 
 /** Whether the WASM module has finished initializing. */
 export declare function isLoaded(): boolean;
+
+/** Engine objects and caches owned by one independently collectible WASM instance. */
+export type EngineInstance = Omit<typeof WasmExports, "default"> & {
+  getModule(): WebAssembly.Module;
+
+  getMemory(): WebAssembly.Memory;
+
+  /** Drop all glue roots after releasing owned resources. This instance is then unusable. */
+  retire(): void;
+
+  functionNames?: () => string[];
+};
+
+/** Initialize a fresh engine; a compiled module can be reused without retaining its memory. */
+export declare function createEngine(source?: Parameters<typeof load>[0]): Promise<EngineInstance>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sheetwrite/wasm",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Sheetwrite columnar store and data engine (Rust/WASM).",
   "license": "MIT",
@@ -39,6 +39,7 @@
     "loader-state.mjs",
     "loader.d.ts",
     "pkg/sheetwrite_wasm.js",
+    "pkg/sheetwrite_wasm_factory.js",
     "pkg/sheetwrite_wasm.d.ts",
     "pkg/sheetwrite_wasm_bg.wasm",
     "pkg/sheetwrite_wasm_bg.wasm.d.ts"
@@ -49,7 +50,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "wasm-pack build --target web --out-dir pkg",
+    "build": "wasm-pack build --target web --out-dir pkg && bun ../../scripts/wasm-factory.ts .",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "clean": "rm -rf pkg target"
   }

package/pkg/sheetwrite_wasm.d.ts

@@ -14,6 +14,27 @@ export class CellOut {
     readonly style: number;
 }
 
+/**
+ * Resolved values of a sparse coordinate batch, one entry per requested cell.
+ *
+ * Every list holds one entry per cell, in the requested order. Text is stored
+ * once: `text_index` names the cell's entry in `strings`, or `-1` when the cell
+ * has no text, exactly like [`CellOut::string`] reports it.
+ */
+export class CellSnapshot {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly kinds: Uint8Array;
+    readonly numbers: Float64Array;
+    readonly strings: string[];
+    readonly styles: Uint32Array;
+    /**
+     * Entry in [`Self::strings`] per cell, or `-1` for a cell without text.
+     */
+    readonly textIndex: Int32Array;
+}
+
 /**
  * The workbook-wide store: every sheet, one string pool.
  */
@@ -30,6 +51,11 @@ export class CellStore {
      * Allocate a sheet grid and return its numeric handle.
      */
     addSheet(n_cols: number, row_count: number): number;
+    /**
+     * Whether a source rectangle can replace its spill cells without cutting
+     * an installed spill away from its anchor. No owner window crosses WASM.
+     */
+    admitSourceRange(sheet: number, r0: number, c0: number, r1: number, c1: number): boolean;
     /**
      * Column aggregate over numeric cells. op: 0 sum, 1 avg, 2 min, 3 max, 4 count.
      */
@@ -57,6 +83,15 @@ export class CellStore {
      * follow the caller's row-major coordinate order.
      */
     captureSourcesForRows(sheet: number, rows: Uint32Array, cols: Uint32Array): SourceSnapshot | undefined;
+    /**
+     * Resolved values of a sparse coordinate list in one batched read.
+     *
+     * `rows` and `cols` are absolute coordinates and must have the same length;
+     * otherwise the result carries no cells. Every entry reads exactly like
+     * [`Self::get_cell`], so a batched capture reports the values a per-cell
+     * read would.
+     */
+    cellSnapshots(sheet: number, rows: Uint32Array, cols: Uint32Array): CellSnapshot | undefined;
     /**
      * 0 unloaded, 1 loaded-empty, 2 loaded-value, 3 dirty local edit.
      */
@@ -69,7 +104,14 @@ export class CellStore {
     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.
+     * Commit staged user or host sources. Admission metadata must be staged
+     * before this barrier; derived values and string roots are complete on return.
+     * Beginning a page load suppresses local dirty tracking until this commit.
+     */
+    commitSources(): void;
+    /**
+     * Reclaim unreachable text and release growth slack at a transaction barrier.
+     * Raw pool IDs must be discarded when `stringPoolEpoch` changes.
      */
     compactStringStorage(): void;
     /**
@@ -86,8 +128,10 @@ export class CellStore {
     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;
+    /**
+     * Export only live state, not allocator slack or a dependency-index cache.
+     */
+    exportMemoryState(): Uint8Array;
     /**
      * Data-row indices whose column text contains `needle` (case-insensitive).
      */
@@ -97,6 +141,20 @@ export class CellStore {
      * Benchmark diagnostic: `[current matrix bytes, peak matrix bytes, allocations]`.
      */
     formulaMatrixResourceStats(): Float64Array;
+    /**
+     * Same-sheet calculation prerequisites for `start_row..end_row` × `cols`,
+     * as flat `[row_start, row_end, col_start, col_end)` rectangles.
+     *
+     * The walk follows each read into the formula cells it reaches, so for
+     * `H = F - G` and `F = D - E` it reports `D`, `E`, `F`, and `G`.
+     * Spill children follow their anchor; attempted spill destinations are also
+     * prerequisites because admission must establish that source cells are empty.
+     * Reads of other sheets are skipped. `max_cells` bounds the walk: a read larger than
+     * the remaining budget is skipped, so one whole-column range cannot make a
+     * window demand the full column. Rectangles are disjoint and ascend by
+     * column, then by row.
+     */
+    formulaReadBands(sheet: number, start_row: number, end_row: number, cols: Uint32Array, max_cells: number): Uint32Array;
     formulaSource(sheet: number, row: number, col: number): string | undefined;
     /**
      * Single-cell read for interactions/tests — never the render hot path.
@@ -104,9 +162,8 @@ export class CellStore {
     getCell(sheet: number, row: number, col: number): CellOut;
     /**
      * One bulk read of a rectangular window for the renderer. Returns
-     * contiguous packed cell data (row-major over `rows x cols`) plus the
-     * unique strings referenced by the window, so the host paints without
-     * crossing the boundary per cell.
+     * contiguous packed cell data (row-major over `rows x cols`) with pool IDs
+     * and window-local formula-error strings, avoiding per-cell boundary reads.
      */
     getWindow(sheet: number, row_start: number, row_end: number, cols: Uint32Array): WindowView;
     /**
@@ -124,10 +181,25 @@ export class CellStore {
      * Packed-string counterpart to [`CellStore::hydrate_page_numbers`].
      */
     hydratePageStringsPacked(sheet: number, col: number, start_row: number, buf: string, utf16_lens: Uint32Array, style: number, protected_offsets: Uint32Array): void;
+    /**
+     * Import into a fresh instance; failure never mutates the source store.
+     */
+    static importMemoryState(bytes: Uint8Array): CellStore;
+    importRangeMemoryState(bytes: Uint8Array, sheet: number, row_start: number, col_start: number): RangeSnapshot;
     insertCols(sheet: number, at: number, count: number): void;
     isFullyLoaded(sheet: number): boolean;
     isPaged(sheet: number): boolean;
     isSheetAlive(sheet: number): boolean;
+    /**
+     * Loaded row runs of one column inside `start_row..end_row`, as flat
+     * `[start, end)` pairs in ascending, disjoint order.
+     *
+     * A row belongs to a run only when [`Self::columns_fully_loaded`] would
+     * report it loaded, so a caller can reconcile a whole column with one call
+     * instead of probing the band row by row. Rows outside the sheet and empty
+     * requests produce no pairs.
+     */
+    loadedSpans(sheet: number, start_row: number, end_row: number, col: number): Uint32Array;
     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;
@@ -145,7 +217,19 @@ export class CellStore {
      * cells and source bytes, never the logical sheet rectangle.
      */
     persistedCellData(sheet: number): Float64Array;
+    /**
+     * Replaces caller-owned persistent pins; empty row ranges leave them unchanged.
+     */
     pinRange(sheet: number, start_row: number, end_row: number, cols: Uint32Array): void;
+    /**
+     * Replaces transient read protection without changing explicit or viewport pins.
+     * Nonempty `rows` are backing row IDs; otherwise `[start_row, end_row)` is used.
+     */
+    pinReadWindow(sheet: number, start_row: number, end_row: number, rows: Uint32Array, cols: Uint32Array): void;
+    /**
+     * Replaces viewport-owned protection independently of transient read pins.
+     */
+    pinViewportBands(sheet: number, bands: Uint32Array): void;
     poolStrings(ids: Uint32Array): string[];
     /**
      * `[contains cache constructions, owned distinct strings]`.
@@ -161,15 +245,9 @@ export class CellStore {
      *
      * The pass first grows the dirty cell set through formula read-sets to find
      * all dependent formulas. It then evaluates only those formulas, using a
-     * per-pass memo table so each formula cell is evaluated at most once even
-     * when many downstream formulas reference it.
+     * per-pass memo table to reuse formula results across dependent reads.
      */
     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.
@@ -211,14 +289,31 @@ export class CellStore {
      */
     search(sheet: number, cols: Uint32Array, query: string, case_insensitive: boolean, whole_cell: boolean): Uint32Array;
     /**
-     * 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
+     * Atomically write one row-major mixed literal/formula/reference block
+     * whose text payload arrives packed instead of once per cell.
+     *
+     * `text_buf` holds the UTF-8 bytes of every `KIND_STRING` cell of `kinds`
+     * in cell-offset order. `text_offsets` carries their byte boundaries: the
+     * n-th string cell owns `text_offsets[n]..text_offsets[n + 1]`, and the
+     * last entry equals the buffer length, so a block without strings passes an
+     * empty buffer and `&[0]`. Literal strings are interned in cell-offset order;
+     * source-owned text slots are consumed without interning. 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, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array): number;
+    setBlockPacked(sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, text_buf: Uint8Array, text_offsets: Uint32Array, 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;
+    /**
+     * Atomically write one column-major mixed literal/formula/reference block
+     * whose text payload arrives packed.
+     *
+     * This is [`Self::set_block_packed`] with the flat input arrays in the
+     * store's own column-major order: cell `(row, col)` sits at
+     * `col * rows + row`, so a columnar import can fill them column by column.
+     * Text packing, source metadata and every status code behave exactly as in
+     * [`Self::set_block_packed`].
+     */
+    setColumnBlockPacked(sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, text_buf: Uint8Array, text_offsets: Uint32Array, styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array): number;
     /**
      * Bulk-load one column with numbers starting at `start_row`.
      */
@@ -244,13 +339,18 @@ export class CellStore {
      */
     setConditionalRules(sheet: number, kinds: Uint8Array, bounds: Uint32Array, nums: Float64Array, strs: string[], flags: Uint8Array): void;
     /**
-     * Parse and store an arithmetic formula at `(row, col)`.
+     * Parse and store a formula at `(row, col)`.
      *
      * Setters only mark cells dirty; they do not recompute formulas. The host
      * calls `recompute(sheet)` once at the transaction barrier so a multi-cell
      * edit performs one dependency-scoped pass instead of one full-sheet pass
-     * per setter. The returned value is the previous cached value until that
-     * barrier recompute runs, and the store facade ignores it for batched edits.
+     * per setter. A successful parse returns the pre-write cached scalar; a
+     * parse rejection returns `0.0`, and a rejected write returns `NaN`.
+     *
+     * The dependency index is invalidated only when the rewrite changes what
+     * the formula reads or whether it produces an array. A constant-only edit
+     * keeps the cached index, so its next recompute visits just the edited
+     * formula and its dependents instead of every formula in the workbook.
      */
     setFormula(sheet: number, row: number, col: number, src: string, style: number): number;
     setNamedRange(name: string, scope: number, sheet: number, row_start: number, col_start: number, row_end: number, col_end: number): boolean;
@@ -292,6 +392,10 @@ export class CellStore {
      * Packed row-major `[anchor_row, anchor_col, ...]` owner coordinates.
      */
     spillOwnerCoordinates(sheet: number, row_start: number, row_end: number, cols: Uint32Array): Uint32Array;
+    /**
+     * Raw string IDs are valid only within this epoch, including window IDs.
+     */
+    stringPoolEpoch(): number;
     /**
      * Current style-dictionary id at a cell; `0` when out of bounds. Used by
      * the host to write derived (reference-shadow) values without disturbing
@@ -328,14 +432,18 @@ export class DistinctColumn {
  * Opaque, store-local history payload for one dense rectangular cell block.
  *
  * The host may retain this object in undo history, but it is deliberately not
- * part of the serialized document protocol. String payloads remain interned in
- * the owning `CellStore`, so snapshots must only be restored into that store.
+ * part of the serialized document protocol. A deduplicated local dictionary
+ * owns captured text independently of the store's pool epoch.
  */
 export class RangeSnapshot {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     byteLength(): number;
+    /**
+     * Transfer packed scalars and the local dictionary, never JS cell patches.
+     */
+    exportMemoryState(sheet: number): Uint8Array;
     formulaOffsets(): Uint32Array;
     formulaSources(): string[];
     kinds(): Uint8Array;
@@ -368,6 +476,7 @@ export class WindowView {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    stringPoolEpoch(): number;
     /**
      * Consume the complete fixed-width window payload. The returned
      * `Uint8Array` is copied by wasm-bindgen into JS-owned memory.
@@ -386,6 +495,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_cellout_free: (a: number, b: number) => void;
+    readonly __wbg_cellsnapshot_free: (a: number, b: number) => void;
     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;
@@ -395,10 +505,16 @@ export interface InitOutput {
     readonly cellout_num: (a: number) => number;
     readonly cellout_string: (a: number) => [number, number];
     readonly cellout_style: (a: number) => number;
+    readonly cellsnapshot_kinds: (a: number) => [number, number];
+    readonly cellsnapshot_numbers: (a: number) => [number, number];
+    readonly cellsnapshot_strings: (a: number) => [number, number];
+    readonly cellsnapshot_styles: (a: number) => [number, number];
+    readonly cellsnapshot_textIndex: (a: number) => [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_admitSourceRange: (a: number, b: number, c: number, d: number, e: number, f: 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;
@@ -407,31 +523,36 @@ export interface InitOutput {
     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_cellSnapshots: (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_commitSources: (a: number) => void;
     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_exportMemoryState: (a: number) => [number, number];
     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_formulaReadBands: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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;
     readonly cellstore_getWindowRows: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly cellstore_hydratePageNumbers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly cellstore_hydratePageStringsPacked: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly cellstore_importMemoryState: (a: any) => number;
+    readonly cellstore_importRangeMemoryState: (a: number, b: any, c: number, d: number, e: number) => number;
     readonly cellstore_insertCols: (a: number, b: number, c: number, d: number) => void;
     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_loadedSpans: (a: number, b: number, c: number, d: number, e: number) => [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];
@@ -440,12 +561,13 @@ export interface InitOutput {
     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_pinReadWindow: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly cellstore_pinViewportBands: (a: number, b: number, c: number, d: 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];
@@ -461,8 +583,9 @@ export interface InitOutput {
     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, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number) => number;
+    readonly cellstore_setBlockPacked: (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_setBool: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly cellstore_setColumnBlockPacked: (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_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;
     readonly cellstore_setColumnStringsPacked: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
@@ -483,12 +606,14 @@ export interface InitOutput {
     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_stringPoolEpoch: (a: 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];
     readonly rangesnapshot_byteLength: (a: number) => number;
+    readonly rangesnapshot_exportMemoryState: (a: number, b: number) => [number, number];
     readonly rangesnapshot_formulaOffsets: (a: number) => [number, number];
     readonly rangesnapshot_formulaSources: (a: number) => [number, number];
     readonly rangesnapshot_kinds: (a: number) => [number, number];
@@ -502,15 +627,16 @@ export interface InitOutput {
     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_takeStrings: (a: number) => [number, number];
+    readonly windowview_stringPoolEpoch: (a: number) => number;
     readonly windowview_takePacked: (a: number) => [number, number];
-    readonly windowview_nRows: (a: number) => number;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-    readonly __externref_table_alloc: () => number;
     readonly __externref_drop_slice: (a: number, b: number) => void;
+    readonly __externref_table_alloc: () => number;
     readonly __wbindgen_start: () => void;
 }