@sheetwrite/wasm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sheetwrite contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# @sheetwrite/wasm
+
+Sheetwrite's Rust/WASM columnar store and calculation engine. Most consumers receive it transitively through `@sheetwrite/core` or a framework adapter.
+
+```ts
+import { load } from "@sheetwrite/wasm";
+
+await load();
+```
+
+The package boundary selects a browser loader with no Node imports or a Node loader that reads the co-located binary. `load(source?)` accepts `BufferSource | URL | string | Request | WebAssembly.Module`, shares concurrent same-source initialization, rejects conflicting concurrent sources, retries after failure, and no-ops after success. `isLoaded()` is the authoritative readiness check.
+
+`@sheetwrite/wasm/wasm` remains the explicit raw-asset escape hatch for unsupported or custom bundlers; ordinary consumers should use zero-argument initialization.
+
+## Build
+
+```sh
+bun run build
+```

package/loader-browser.mjs

@@ -0,0 +1,14 @@
+import { createLoader } from "./loader-state.mjs";
+import init from "./pkg/sheetwrite_wasm.js";
+
+export * from "./pkg/sheetwrite_wasm.js";
+
+const loader = createLoader(async (source) => {
+  if (source === undefined) {
+    await init();
+    return;
+  }
+  await init({ module_or_path: source });
+});
+
+export const { load, isLoaded } = loader;

package/loader-node.mjs

@@ -0,0 +1,17 @@
+import { readFile } from "node:fs/promises";
+import { createLoader } from "./loader-state.mjs";
+import init, { initSync } from "./pkg/sheetwrite_wasm.js";
+
+export * from "./pkg/sheetwrite_wasm.js";
+
+const loader = createLoader(async (source) => {
+  if (source !== undefined) {
+    await init({ module_or_path: source });
+    return;
+  }
+
+  const url = new URL("./pkg/sheetwrite_wasm_bg.wasm", import.meta.url);
+  initSync({ module: await readFile(url) });
+});
+
+export const { load, isLoaded } = loader;

package/loader-state.mjs

@@ -0,0 +1,54 @@
+const DIFFERENT_SOURCE_IN_FLIGHT =
+  "Sheetwrite: concurrent load() with a different source while initialization is in flight";
+const DIFFERENT_SOURCE_AFTER_INIT =
+  "Sheetwrite: load() called with a different source after initialization; keeping the first module.";
+
+/**
+ * Own the environment-neutral initialization lifecycle.
+ *
+ * @param {(source: BufferSource | URL | string | Request | WebAssembly.Module | undefined) => Promise<void>} initialize
+ */
+export function createLoader(initialize) {
+  let ready = false;
+  /** @type {Promise<void> | null} */
+  let inFlight = null;
+  /** @type {unknown} */
+  let selectedSource;
+
+  /**
+   * @param {BufferSource | URL | string | Request | WebAssembly.Module} [source]
+   */
+  async function load(source) {
+    if (ready) {
+      if (source !== undefined && source !== selectedSource) {
+        console.warn(DIFFERENT_SOURCE_AFTER_INIT);
+      }
+      return;
+    }
+
+    if (inFlight) {
+      if (source !== undefined && source !== selectedSource) {
+        throw new Error(DIFFERENT_SOURCE_IN_FLIGHT);
+      }
+      return inFlight;
+    }
+
+    selectedSource = source;
+    inFlight = initialize(source);
+
+    try {
+      await inFlight;
+      ready = true;
+    } catch (error) {
+      inFlight = null;
+      selectedSource = undefined;
+      throw error;
+    }
+  }
+
+  function isLoaded() {
+    return ready;
+  }
+
+  return { load, isLoaded };
+}

package/loader.d.ts

@@ -0,0 +1,24 @@
+export * from "./pkg/sheetwrite_wasm.js";
+
+/** Sources accepted by asynchronous initialization: a fetchable URL/request/response, raw module bytes, or a precompiled `WebAssembly.Module`. */
+export type { InitInput } from "./pkg/sheetwrite_wasm.js";
+
+/** Result of module initialization: the instantiated exports plus the shared linear memory. */
+export type { InitOutput } from "./pkg/sheetwrite_wasm.js";
+
+/** Sources accepted by synchronous initialization: raw module bytes or a precompiled `WebAssembly.Module`. */
+export type { SyncInitInput } from "./pkg/sheetwrite_wasm.js";
+
+/**
+ * Initialize the WASM module. Idempotent and re-entrant: concurrent
+ * same-source callers share one in-flight init; a concurrent different-source
+ * call rejects; a different-source call after success warns and no-ops; a
+ * rejected init is retryable. When `source` is omitted the loader picks the
+ * right strategy for the runtime.
+ */
+export declare function load(
+ source?: BufferSource | URL | string | Request | WebAssembly.Module,
+): Promise<void>;
+
+/** Whether the WASM module has finished initializing. */
+export declare function isLoaded(): boolean;

package/loader.mjs

@@ -0,0 +1 @@
+export * from "./loader-browser.mjs";

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@sheetwrite/wasm",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Sheetwrite columnar store and data engine (Rust/WASM).",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chh-ay/Sheetwrite.git",
+    "directory": "packages/wasm"
+  },
+  "homepage": "https://chh-ay.github.io/Sheetwrite/",
+  "bugs": {
+    "url": "https://github.com/chh-ay/Sheetwrite/issues"
+  },
+  "keywords": [
+    "spreadsheet",
+    "wasm",
+    "rust",
+    "columnar",
+    "formula-engine"
+  ],
+  "main": "./loader.mjs",
+  "module": "./loader.mjs",
+  "types": "./loader.d.ts",
+  "exports": {
+    ".": {
+      "types": "./loader.d.ts",
+      "browser": "./loader-browser.mjs",
+      "node": "./loader-node.mjs",
+      "default": "./loader-browser.mjs"
+    },
+    "./wasm": "./pkg/sheetwrite_wasm_bg.wasm"
+  },
+  "files": [
+    "loader.mjs",
+    "loader-browser.mjs",
+    "loader-node.mjs",
+    "loader-state.mjs",
+    "loader.d.ts",
+    "pkg/sheetwrite_wasm.js",
+    "pkg/sheetwrite_wasm.d.ts",
+    "pkg/sheetwrite_wasm_bg.wasm",
+    "pkg/sheetwrite_wasm_bg.wasm.d.ts"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "wasm-pack build --target web --out-dir pkg",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "clean": "rm -rf pkg target"
+  }
+}

package/pkg/sheetwrite_wasm.d.ts

@@ -0,0 +1,415 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Result of a single-cell read.
+ */
+export class CellOut {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly kind: number;
+    readonly num: number;
+    readonly string: string | undefined;
+    readonly style: number;
+}
+
+/**
+ * The workbook-wide store: every sheet, one string pool.
+ */
+export class CellStore {
+    free(): void;
+    [Symbol.dispose](): 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;
+    addRows(sheet: number, at: number, count: number): void;
+    /**
+     * Allocate a sheet grid and return its numeric handle.
+     */
+    addSheet(n_cols: number, row_count: number): number;
+    /**
+     * Column aggregate over numeric cells. op: 0 sum, 1 avg, 2 min, 3 max, 4 count.
+     */
+    aggregate(sheet: number, col: number, op: number): number;
+    beginPageLoad(): void;
+    /**
+     * Capture a dense rectangle into an opaque store-local history resource.
+     */
+    captureRange(sheet: number, r0: number, c0: number, rows: number, cols: number): RangeSnapshot | undefined;
+    /**
+     * 0 unloaded, 1 loaded-empty, 2 loaded-value, 3 dirty local edit.
+     */
+    cellState(sheet: number, row: number, col: number): number;
+    clearCell(sheet: number, row: number, col: number, style: number): void;
+    /**
+     * Clear a rectangle while independently controlling contents and style.
+     */
+    clearRange(sheet: number, r0: number, c0: number, r1: number, c1: number, contents: boolean, style: boolean): boolean;
+    colCount(sheet: number): number;
+    /**
+     * Ctrl+Arrow destination: from `(row, col)` stepping by `(d_row, d_col)`
+     * (exactly one of them ±1), return the destination row (vertical moves) or
+     * column (horizontal moves), Google Sheets semantics:
+     *
+     * - current and adjacent cell non-empty → end of the contiguous non-empty
+     *   run;
+     * - otherwise → the next non-empty cell in that direction;
+     * - nothing ahead → the sheet edge.
+     */
+    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;
+    distinctValues(sheet: number, col: number, limit: number): DistinctColumn;
+    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;
+    formulaSource(sheet: number, row: number, col: number): string | undefined;
+    /**
+     * Single-cell read for interactions/tests — never the render hot path.
+     */
+    getCell(sheet: number, row: number, col: number): CellOut;
+    /**
+     * One bulk read of a rectangular window for the renderer. Returns
+     * contiguous typed arrays (row-major over `rows x cols`) plus the unique
+     * strings referenced by the window, so the host paints without crossing
+     * the boundary per cell.
+     */
+    getWindow(sheet: number, row_start: number, row_end: number, cols: Uint32Array): WindowView;
+    /**
+     * Bulk read of an explicit row list (sorted/filtered views) — same output
+     * shape as `get_window`, rows taken from `rows` rather than a range.
+     */
+    getWindowRows(sheet: number, rows: Uint32Array, cols: Uint32Array): WindowView;
+    insertCols(sheet: number, at: number, count: number): void;
+    isFullyLoaded(sheet: number): boolean;
+    isPaged(sheet: number): boolean;
+    isSheetAlive(sheet: number): boolean;
+    markRangeClean(sheet: number, start_row: number, end_row: number, start_col: number, end_col: number): void;
+    constructor();
+    /**
+     * `[chunks, loaded cells, dirty cells, allocated bytes, fully loaded]`.
+     */
+    pagedStats(sheet: number): Float64Array;
+    pinRange(sheet: number, start_row: number, end_row: number, cols: Uint32Array): void;
+    poolStrings(ids: Uint32Array): string[];
+    /**
+     * `[contains cache constructions, owned distinct strings]`.
+     */
+    queryResourceStats(): Float64Array;
+    rangeFullyLoaded(sheet: number, r0: number, c0: number, r1: number, c1: number): boolean;
+    /**
+     * Unique style ids present in a rectangle; cost stays inside WASM.
+     */
+    rangeStyleIds(sheet: number, r0: number, c0: number, r1: number, c1: number): Uint32Array;
+    /**
+     * Recompute formulas affected by cells changed since the last call.
+     *
+     * 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.
+     */
+    recompute(sheet: number): 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;
+    /**
+     * Remap styles over a rectangle using parallel old/new id tables.
+     */
+    remapRangeStyles(sheet: number, r0: number, c0: number, r1: number, c1: number, old_ids: Uint32Array, new_ids: Uint32Array): boolean;
+    removeCols(sheet: number, at: number, count: number): void;
+    removeNamedRange(name: string, scope: number): boolean;
+    removeRows(sheet: number, at: number, count: number): void;
+    /**
+     * Tombstone a stable sheet handle and invalidate every formula reference to it.
+     */
+    removeSheet(sheet: number): boolean;
+    /**
+     * Rename a live stable sheet handle and rewrite every resolved formula AST reference.
+     */
+    renameSheet(sheet: number, id: string, name: string): boolean;
+    resetQueryResourceStats(): void;
+    /**
+     * Restore a captured block at a destination of the same dimensions.
+     */
+    restoreRange(sheet: number, r0: number, c0: number, snapshot: RangeSnapshot): boolean;
+    rowCount(sheet: number): number;
+    /**
+     * Cell coordinates whose text matches `query`, as a flat `[row, col, ...]`
+     * list. Scans the requested columns column-major (cache-local), then sorts
+     * row-major so search navigation runs top-to-bottom, left-to-right.
+     */
+    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.
+     */
+    setBlock(sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, texts: string[], styles: Uint32Array): boolean;
+    setBool(sheet: number, row: number, col: number, value: boolean, style: number): void;
+    /**
+     * Bulk-load one column with numbers starting at `start_row`.
+     */
+    setColumnNumbers(sheet: number, col: number, start_row: number, values: Float64Array, style: number): void;
+    /**
+     * Bulk-load one column with strings starting at `start_row`.
+     */
+    setColumnStrings(sheet: number, col: number, start_row: number, values: string[], style: number): void;
+    /**
+     * Bulk-load one column of strings from a single concatenated buffer plus
+     * per-row lengths in UTF-16 code units (the JS `string.length` unit).
+     * One boundary decode and one Rust allocation for the whole column,
+     * instead of one per row — the dominant ingest cost for text columns.
+     */
+    setColumnStringsPacked(sheet: number, col: number, start_row: number, buf: string, utf16_lens: Uint32Array, style: number): void;
+    /**
+     * 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.
+     */
+    setConditionalRules(sheet: number, kinds: Uint8Array, bounds: Uint32Array, nums: Float64Array, strs: string[], flags: Uint8Array): void;
+    /**
+     * Parse and store an arithmetic 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.
+     */
+    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;
+    setNumber(sheet: number, row: number, col: number, value: number, style: number): void;
+    setSheetName(sheet: number, id: string, name: string): void;
+    setString(sheet: number, row: number, col: number, value: string, style: number): void;
+    snapshotNumbers(snapshot: RangeSnapshot): Float64Array;
+    snapshotTexts(snapshot: RangeSnapshot): string[];
+    /**
+     * Stable row order sorted by a column. Returns a data-row permutation.
+     */
+    sortRows(sheet: number, col: number, ascending: boolean): Uint32Array;
+    sortRowsMulti(sheet: number, cols: Uint32Array, ascending: Uint8Array, candidates: 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;
+}
+
+/**
+ * Distinct-value scan result for one column: parallel kind/number/text
+ * arrays whose buffers are surrendered once through the `take*` accessors.
+ */
+export class DistinctColumn {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Surrenders the per-value kind tags (number/string/boolean codes); the
+     * column keeps an empty buffer afterwards.
+     */
+    takeKinds(): Uint8Array;
+    /**
+     * Surrenders the numeric values aligned with the `takeKinds` tags.
+     */
+    takeNumbers(): Float64Array;
+    /**
+     * Surrenders the distinct strings aligned with the `takeKinds` tags.
+     */
+    takeTexts(): string[];
+}
+
+/**
+ * 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.
+ */
+export class RangeSnapshot {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    byteLength(): number;
+    formulaOffsets(): Uint32Array;
+    formulaSources(): string[];
+    kinds(): Uint8Array;
+    styleIds(): Uint32Array;
+}
+
+/**
+ * A bulk window of resolved cells, row-major over `n_rows x n_cols`.
+ */
+export class WindowView {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Consume and return per-cell conditional-format rule bitmasks; empty
+     * when the sheet has no rules.
+     */
+    takeCondMatches(): Uint32Array;
+    /**
+     * Consume and return the per-cell tag array: 0 empty, 1 number, 2 string.
+     */
+    takeKinds(): Uint8Array;
+    /**
+     * Consume and return per-cell numeric payloads (valid where kind == 1).
+     */
+    takeNumbers(): Float64Array;
+    /**
+     * Consume and return per-cell GLOBAL string-pool ids; `u32::MAX` means none.
+     */
+    takeStringIds(): Uint32Array;
+    /**
+     * Consume and return per-cell indices into `strings` (string cells only).
+     */
+    takeStringIndex(): Int32Array;
+    /**
+     * Consume and return unique strings referenced by this window.
+     */
+    takeStrings(): string[];
+    /**
+     * Consume and return the unique global style-dictionary ids referenced by
+     * this window, in local-index order; the host maps each to a `CellStyle`.
+     */
+    takeStyleDict(): Uint32Array;
+    /**
+     * Consume and return per-cell WINDOW-LOCAL style indices into the dict.
+     */
+    takeStyleIndex(): Uint32Array;
+    readonly nCols: number;
+    readonly nRows: number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_cellout_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;
+    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_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_beginPageLoad: (a: number) => void;
+    readonly cellstore_captureRange: (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_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_distinctValues: (a: number, b: number, c: number, d: number) => number;
+    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_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_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_markRangeClean: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly cellstore_new: () => number;
+    readonly cellstore_pagedStats: (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_recomputeVolatile: (a: number, b: 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_renameSheet: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    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_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;
+    readonly cellstore_setColumnStringsPacked: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly cellstore_setConditionalRules: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+    readonly cellstore_setFormula: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    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_setString: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    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_styleIdAt: (a: number, b: number, c: number, d: 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_formulaOffsets: (a: number) => [number, number];
+    readonly rangesnapshot_formulaSources: (a: number) => [number, number];
+    readonly rangesnapshot_kinds: (a: number) => [number, number];
+    readonly rangesnapshot_styleIds: (a: number) => [number, number];
+    readonly windowview_nCols: (a: number) => number;
+    readonly windowview_nRows: (a: number) => number;
+    readonly windowview_takeCondMatches: (a: number) => [number, number];
+    readonly windowview_takeStringIds: (a: number) => [number, number];
+    readonly windowview_takeStringIndex: (a: number) => [number, number];
+    readonly windowview_takeStrings: (a: number) => [number, number];
+    readonly windowview_takeStyleDict: (a: number) => [number, number];
+    readonly windowview_takeStyleIndex: (a: number) => [number, number];
+    readonly windowview_takeKinds: (a: number) => [number, number];
+    readonly windowview_takeNumbers: (a: number) => [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 __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;