Runtime ownership — Sheetwrite

Architecture at a glance

Sheetwrite splits cleanly into a data engine (Rust → WASM) and a renderer (canvas). The TypeScript core (@sheetwrite/core) owns the host DOM, the scroll/virtualization math, interactions, and the bridge between the two.

01Host

Lifecycle, persistence, collaboration, and product UI

02TypeScript core

Grid API, transactions, virtualization, interaction, and renderer coordination

03Rust / WASM

Columnar cells, formulas, query scans, snapshots, and packed render windows

Ownership moves downward through narrow contracts; events and resolved windows move upward.

The renderer never owns document cells. Each frame requests one bulk resolved window per painted pane; an unfrozen sheet uses one window, while frozen panes use up to four clipped windows.

GridImpl is the composition root rather than the owner of every subsystem. DocumentController owns document commits and history, DatasourceController owns paged request generations and cancellation, GeometryLayoutController owns row/column indexes and frozen-window mapping, and RenderCoordinator is the sole animation-frame and paint-cache owner. Interaction-specific controllers remain separate. These are internal ownership boundaries; the public API stays the Grid and Store contracts.

Canvas rendering + the WASM columnar store

Cells live in the WASM module as typed columns, not as objects. Each cell has a kind—EMPTY=0, NUMBER=1, STRING=2, BOOLEAN=3, or FORMULA=4—and numeric/string data is held in parallel typed arrays. This keeps memory flat and lets the store hand the renderer a transferable, typed-array-backed window.

Because the engine is columnar and WASM-resident:

A sheet of 100k+ rows costs no DOM nodes and no per-cell JS objects.
The render hot path is a single bulk read, not N cell lookups.
The same snapshot can be transferred to a worker for off-thread painting (see Worker rendering).

Virtualization & scaled scroll

Only the rows intersecting the viewport are ever painted. computeWindow turns the current scroll offset and viewport height into a half-open row range [start, end), padded by overscan rows on each side so a fast scroll reveals already-painted rows:

declare function computeWindowfunction computeWindow(index: unknown, contentTop: number, viewportHeight: number, overscan: number): {
    start: number;
    end: number;
} (+1 overload)function computeWindow(index: unknown, contentTop: number, viewportHeight: number, overscan: number): {
    start: number;
    end: number;
} (+1 overload)function computeWindow(index: unknown, contentTop: number, viewportHeight: number, overscan: number): {
    start: number;
    end: number;
} (+1 overload)(index: unknown, contentTop: number, viewportHeight: number, overscan: number): { start: number; end: number };

Row positions come from an OffsetIndex — a Fenwick (binary-indexed) tree over row heights giving O(log n) scrollTop ↔ row mapping and O(log n) single-row height edits, so variable row heights stay cheap.

Browsers clamp an element's height at an engine-specific ceiling — Chromium sits near 33.5 million CSS pixels at 100% zoom, and the ceiling shrinks with browser zoom and devicePixelRatio. At the default 28px row height that can be barely ~1M rows, so Sheetwrite never trusts a constant: it measures the real clamp with a probe element (re-measuring on zoom changes), pins the DOM sizer to that cap, and ScaledScroll maps the capped scrollbar position linearly onto the real virtual range:

// DOM scrollTop -> content-space offset (identity below the cap)
declare function toContentfunction toContent(scrollTop: number): number (+1 overload)function toContent(scrollTop: number): number (+1 overload)function toContent(scrollTop: number): number (+1 overload)(scrollTop: number): number;
// content-space offset -> DOM scrollTop
declare function toScrollfunction toScroll(contentOffset: number): number (+1 overload)function toScroll(contentOffset: number): number (+1 overload)function toScroll(contentOffset: number): number (+1 overload)(contentOffset: number): number;

Below the cap the mapping is the identity; above it, scrolling stays smooth while the few-pixel-per-row resolution loss is invisible at that scale.

The Store contract

A grid talks to its data through the Store interface. The two reads are deliberately different:

Method	Use
`getVisibleWindow(sheet, rows, cols)`	The render hot path. Returns one `VisibleWindowView` for a whole rectangle. The renderer paints from this and must never read cell-by-cell.
`getCell(addr)`	A single-cell read for interactions, API reads, and tests — never per frame. Returns `{ resolved, style }`.

VisibleWindowView is backed by typed arrays (values, styleIds: Uint32Array, a shared styles dictionary) so it is worker-transferable, and it is valid only until the next store mutation or window refresh.

The full interface:

interface StoreContract {
  getWorkbookStoreContract.getWorkbook(): WorkbookStoreContract.getWorkbook(): WorkbookStoreContract.getWorkbook(): Workbook(): Workbookinterface Workbookinterface Workbookinterface WorkbookLive workbook schema containing ordered sheets and the active sheet ID.API reference →;
  getCellStoreContract.getCell(addr: CellAddress): ResolvedCellStoreContract.getCell(addr: CellAddress): ResolvedCellStoreContract.getCell(addr: CellAddress): ResolvedCellSingle-cell read for interactions, API reads, and tests. NOT for the render hot path — renderers use getVisibleWindow.API reference →(addr: CellAddressinterface CellAddressinterface CellAddressinterface CellAddressZero-based address of one cell on a stable sheet ID.API reference →): ResolvedCellinterface ResolvedCellinterface ResolvedCellinterface ResolvedCellAuthoritative source value, evaluated value, style, and load state for a cell.API reference →;
  getVisibleWindowStoreContract.getVisibleWindow(sheet: SheetId, rows: {
    start: number;
    end: number;
}, cols: readonly number[]): VisibleWindowViewStoreContract.getVisibleWindow(sheet: SheetId, rows: {
    start: number;
    end: number;
}, cols: readonly number[]): VisibleWindowViewStoreContract.getVisibleWindow(sheet: SheetId, rows: {
    start: number;
    end: number;
}, cols: readonly number[]): VisibleWindowViewBulk read of a visible window; the only read a renderer should use per frame.API reference →(
    sheetsheet: stringlet sheet: stringlet sheet: stringRestrict to a sheet (defaults to the active sheet).API reference →: SheetIdtype SheetId = stringtype SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →,
    rowsrows: {
    start: number;
    end: number;
}let rows: {
  start: number;
  end: number;
}let rows: {
  start: number;
  end: number;
}end-exclusive row rangeAPI reference →: { start: number; end: number },
    cols: readonly number[],
  ): VisibleWindowViewinterface VisibleWindowViewinterface VisibleWindowViewinterface VisibleWindowViewOne rectangular window of resolved cells, returned by Store.getVisibleWindow in a single call. The renderer paints from this view and MUST NOT call Store.getCell per cell. styleIds are view-local indices into this view's compact styles dictionary; on the worker renderer path, styleIds.buffer is transferred during paint, so main-thread code must not read it after paint. Lifetime: valid until the next store mutation or window refresh.API reference →;
  applyTransactionStoreContract.applyTransaction: (tx: Transaction, options?: TransactionApplicationOptions) => ApplyTransactionResultinterface StoreContract {
  applyTransaction: (
    tx: Transaction,
    options?: TransactionApplicationOptions,
  ) => ApplyTransactionResult;
}interface StoreContract {
  applyTransaction: (
    tx: Transaction,
    options?: TransactionApplicationOptions,
  ) => ApplyTransactionResult;
}Apply arbitrary patches as one undoable Grid commit. No-op when read-only. Use Store.applyTransaction only for low-level writes that intentionally bypass Grid history and policy.API reference →: Storeinterface Storeinterface Storeinterface StoreColumnar workbook storage, query, transaction, and subscription contract.API reference →["applyTransaction"];
  onStoreContract.on: (evt: "change", fn: (event: ChangeEvent) => void) => () => voidinterface StoreContract {
  on: (
    evt: "change",
    fn: (event: ChangeEvent) => void,
  ) => () => void;
}interface StoreContract {
  on: (
    evt: "change",
    fn: (
      event: ChangeEvent,
    ) => void,
  ) => () => void;
}: Storeinterface Storeinterface Storeinterface StoreColumnar workbook storage, query, transaction, and subscription contract.API reference →["on"];
  acknowledgeOperationsStoreContract.acknowledgeOperations?(operations: readonly DocumentOp[]): voidStoreContract.acknowledgeOperations?(operations: readonly DocumentOp[]): voidStoreContract.acknowledgeOperations?(operations: readonly DocumentOp[]): voidRelease paged dirty pins after server acknowledgement.API reference →?(operations: readonly DocumentOptype DocumentOp = {
    op: "set";
    addr: CellAddress;
    value: CellValue;
    style?: CellStyle;
} | {
    op: "setRange";
    range: Range;
    cells: SnapshotCell[];
} | {
    op: "setBlock";
    range: Range;
    block: PackedCellBlock;
} | {
    op: "setRangeStyle";
    range: Range;
    style: Partial<CellStyle> | null;
} | {
    op: "clearRange";
    range: Range;
    contents?: boolean;
    style?: boolean;
} | {
    op: "addRows";
    sheet: SheetId;
    at: number;
    count: number;
} | {
    op: "removeRows";
    sheet: SheetId;
    at: number;
    count: number;
} | ... 19 more ... | {
    ...;
}type DocumentOp = {
    op: "set";
    addr: CellAddress;
    value: CellValue;
    style?: CellStyle;
} | {
    op: "setRange";
    range: Range;
    cells: SnapshotCell[];
} | {
    op: "setBlock";
    range: Range;
    block: PackedCellBlock;
} | {
    op: "setRangeStyle";
    range: Range;
    style: Partial<CellStyle> | null;
} | {
    op: "clearRange";
    range: Range;
    contents?: boolean;
    style?: boolean;
} | {
    op: "addRows";
    sheet: SheetId;
    at: number;
    count: number;
} | {
    op: "removeRows";
    sheet: SheetId;
    at: number;
    count: number;
} | ... 19 more ... | {
    ...;
}type DocumentOp = {
    op: "set";
    addr: CellAddress;
    value: CellValue;
    style?: CellStyle;
} | {
    op: "setRange";
    range: Range;
    cells: SnapshotCell[];
} | {
    op: "setBlock";
    range: Range;
    block: PackedCellBlock;
} | {
    op: "setRangeStyle";
    range: Range;
    style: Partial<CellStyle> | null;
} | {
    op: "clearRange";
    range: Range;
    contents?: boolean;
    style?: boolean;
} | {
    op: "addRows";
    sheet: SheetId;
    at: number;
    count: number;
} | {
    op: "removeRows";
    sheet: SheetId;
    at: number;
    count: number;
} | ... 19 more ... | {
    ...;
}Exhaustive serializable operation union for workbook mutations.API reference →[]): void;
}

Document protocol and storage transactions

WorkbookSnapshot is the versioned, JSON-safe authoritative document. Schema 1 contains sheet order and identity, stable column keys, literal/formula/reference cell inputs, sparse styles and row metadata, merges, frozen panes, conditional formats, validation rules, protected ranges, notes, row groups, hidden document metadata, filters, sort keys, and named ranges. Formula source is authoritative; resolved values are derived caches and are not serialized.

DocumentOp is the exhaustive plain-data mutation vocabulary for that document. Cells, ranges, rows/columns, merges, row metadata, frozen panes, conditional formats, validation, protection, notes, row groups, named ranges, and sheet lifecycle operations use the same store reducer and change-event shape. Local operations submitted through Grid enter grid undo/redo history; SyncCoordinator observes each non-empty local transaction and owns its durable mutation-ID record. Direct Store.applyTransaction calls deliberately bypass grid read-only/history policy. Remote operations remain observable with source: "remote" but enter neither local history nor outgoing synchronization.

const checkedconst checked: DocumentValidationResultconst checked: DocumentValidationResultconst checked: DocumentValidationResult = validateWorkbookSnapshotfunction validateWorkbookSnapshot(input: unknown, options?: SnapshotValidationOptions): DocumentValidationResultfunction validateWorkbookSnapshot(
  input: unknown,
  options?: SnapshotValidationOptions,
): DocumentValidationResultfunction validateWorkbookSnapshot(
  input: unknown,
  options?: SnapshotValidationOptions,
): DocumentValidationResultValidate and canonically order a schema-1 snapshot without hydrating runtime state.API reference →(JSONvar JSON: JSONvar JSON: JSONvar JSON: JSONAn intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format..parseJSON.parse(text: string, reviver?: (this: any, key: string, value: any) => any): anyJSON.parse(text: string, reviver?: (this: any, key: string, value: any) => any): anyJSON.parse(text: string, reviver?: (this: any, key: string, value: any) => any): anyConverts a JavaScript Object Notation (JSON) string into an object.@param text A valid JSON string.@param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.@throws {SyntaxError} If text is not valid JSON.(payloadconst payload: stringconst payload: stringconst payload: string));
if (!checkedconst checked: DocumentValidationResultconst checked: DocumentValidationResultconst checked: DocumentValidationResult.okok: booleanlet ok: booleanlet ok: boolean) throw new Errorvar Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+2 overloads)var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+2 overloads)var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+2 overloads)(checkedconst checked: {
    ok: false;
    errors: DocumentValidationError[];
}const checked: {
  ok: false;
  errors: DocumentValidationError[];
}const checked: {
  ok: false;
  errors: DocumentValidationError[];
}.errorserrors: DocumentValidationError[]let errors: DocumentValidationError[]let errors: DocumentValidationError[][0]?.messageDocumentValidationError.message: stringinterface DocumentValidationError {
  message: string;
}interface DocumentValidationError {
  message: string;
});

const outcomeconst outcome: ApplyTransactionResultconst outcome: ApplyTransactionResultconst outcome: ApplyTransactionResult = gridconst grid: Gridconst grid: Gridconst grid: GridThe imperative core grid this controller owns.API reference →.storeGrid.store: Storeinterface Grid {
  store: Store;
}interface Grid {
  store: Store;
}.applyTransactionStore.applyTransaction(tx: Transaction, options?: TransactionApplicationOptions): ApplyTransactionResultStore.applyTransaction(tx: Transaction, options?: TransactionApplicationOptions): ApplyTransactionResultStore.applyTransaction(tx: Transaction, options?: TransactionApplicationOptions): ApplyTransactionResultApply a low-level storage transaction. This bypasses Grid read-only checks and Grid undo/redo history. Use Grid.applyTransaction for normal host-driven edits. Queued and flushed at a barrier — never reentrant.API reference →({
  patchesTransaction.patches: DocumentOp[]interface Transaction {
  patches: DocumentOp[];
}interface Transaction {
  patches: DocumentOp[];
}Ordered document operations submitted as one store commit.API reference →: [
    {
      op: "set",
      addraddr: CellAddresslet addr: CellAddresslet addr: CellAddress,
      valuevalue: CellValuelet value: CellValuelet value: CellValue: { kind: "literal", valuevalue: CellScalarlet value: CellScalarlet value: CellScalar: "authoritative input" },
      stylestyle?: CellStyle | undefinedstyle?: CellStyle | undefinedstyle?: CellStyle | undefinedHost styles merged before adapter sizing styles.API reference →: { backgroundColorCellStyle.backgroundColor?: string | undefinedinterface CellStyle {
  backgroundColor?: string | undefined;
}interface CellStyle {
  backgroundColor?:
    string | undefined;
}hex color, e.g. "#ffffff"API reference →: "#fde68a" },
    },
  ],
});

Snapshot hydration is a separate, validated path: it creates every sheet handle, bulk-loads literal runs, installs formula/reference/style exceptions, then recomputes after the complete graph exists. It emits no user event, dirty patch, or undo entry. Export uses one bulk data-order read per sheet, ignores local sort/filter views and conditional render styles, and emits deterministic sparse blocks.

const savedconst saved: WorkbookSnapshotconst saved: WorkbookSnapshotconst saved: WorkbookSnapshot = await adapterconst adapter: PersistenceAdapterconst adapter: PersistenceAdapterconst adapter: PersistenceAdapter.loadPersistenceAdapter.load(documentId: string, signal?: AbortSignal): Promise<WorkbookSnapshot>PersistenceAdapter.load(documentId: string, signal?: AbortSignal): Promise<WorkbookSnapshot>PersistenceAdapter.load(documentId: string, signal?: AbortSignal): Promise<WorkbookSnapshot>(documentIdconst documentId: stringconst documentId: stringconst documentId: string, signalconst signal: AbortSignalconst signal: AbortSignalconst signal: AbortSignalAbort before or between bounded codec operations.API reference →);
const gridconst grid: Gridconst grid: Gridconst grid: GridThe imperative core grid this controller owns.API reference → = createGridFromSnapshotfunction createGridFromSnapshot(host: HTMLElement, snapshot: unknown, options?: SnapshotGridOptions): Gridfunction createGridFromSnapshot(
  host: HTMLElement,
  snapshot: unknown,
  options?: SnapshotGridOptions,
): Gridfunction createGridFromSnapshot(
  host: HTMLElement,
  snapshot: unknown,
  options?: SnapshotGridOptions,
): GridMount a grid over a validated, non-dirty snapshot. The grid owns and disposes the hydrated store just like one created through createGrid.API reference →(hostconst host: HTMLElementconst host: HTMLElementconst host: HTMLElement, savedconst saved: WorkbookSnapshotconst saved: WorkbookSnapshotconst saved: WorkbookSnapshot);
const syncconst sync: SyncCoordinatorconst sync: SyncCoordinatorconst sync: SyncCoordinator = new SyncCoordinatornew SyncCoordinator(grid: Grid, adapter: PersistenceAdapter, options: SyncCoordinatorOptions): SyncCoordinatornew SyncCoordinator(grid: Grid, adapter: PersistenceAdapter, options: SyncCoordinatorOptions): SyncCoordinatornew SyncCoordinator(grid: Grid, adapter: PersistenceAdapter, options: SyncCoordinatorOptions): SyncCoordinatorDeterministic, transport-neutral optimistic sync. Local rendering is never blocked: changes queue immediately, while hosts explicitly call sendNext or retry to perform network work.API reference →(gridconst grid: Gridconst grid: Gridconst grid: GridThe imperative core grid this controller owns.API reference →, adapterconst adapter: PersistenceAdapterconst adapter: PersistenceAdapterconst adapter: PersistenceAdapter, {
  documentIdSyncCoordinatorOptions.documentId: stringinterface SyncCoordinatorOptions {
  documentId: string;
}interface SyncCoordinatorOptions {
  documentId: string;
},
  serverVersionSyncCoordinatorOptions.serverVersion: numberinterface SyncCoordinatorOptions {
  serverVersion: number;
}interface SyncCoordinatorOptions {
  serverVersion: number;
}Last accepted contiguous remote server version.API reference →: savedconst saved: WorkbookSnapshotconst saved: WorkbookSnapshotconst saved: WorkbookSnapshot.versionWorkbookSnapshot.version?: number | undefinedinterface WorkbookSnapshot {
  version?: number | undefined;
}interface WorkbookSnapshot {
  version?: number | undefined;
} ?? 0,
});

await syncconst sync: SyncCoordinatorconst sync: SyncCoordinatorconst sync: SyncCoordinator.readySyncCoordinator.ready(): Promise<void>SyncCoordinator.ready(): Promise<void>SyncCoordinator.ready(): Promise<void>Resolves after durable work is restored and every startup commit is visible locally.API reference →();
const unsubscribeRemoteconst unsubscribeRemote: () => voidconst unsubscribeRemote: () => voidconst unsubscribeRemote: () => void = syncconst sync: SyncCoordinatorconst sync: SyncCoordinatorconst sync: SyncCoordinator.subscribeSyncCoordinator.subscribe(source: RemoteOperationSource | AsyncIterable<VersionedOperation>): () => voidSyncCoordinator.subscribe(source: RemoteOperationSource | AsyncIterable<VersionedOperation>): () => voidSyncCoordinator.subscribe(source: RemoteOperationSource | AsyncIterable<VersionedOperation>): () => void(remoteOperationSourceconst remoteOperationSource: AsyncIterable<DocumentOp>const remoteOperationSource: AsyncIterable<DocumentOp>const remoteOperationSource: AsyncIterable<DocumentOp>);
await syncconst sync: SyncCoordinatorconst sync: SyncCoordinatorconst sync: SyncCoordinator.sendNextSyncCoordinator.sendNext(): Promise<PersistenceCommitResponse | null>SyncCoordinator.sendNext(): Promise<PersistenceCommitResponse | null>SyncCoordinator.sendNext(): Promise<PersistenceCommitResponse | null>(); // host chooses send/retry timing

Each local grid transaction becomes one immutable PendingCommit with a stable clientMutationId and explicit baseVersion. Records move from pending to sending; an applied or duplicate response acknowledges store dirty state and removes only the matching ID. Transport failure returns that record to pending, so retry sends the same ID. A conflict remains conflicted with its local operations intact and exposes server operations or a snapshot; Sheetwrite does not silently merge ambiguous structural edits. See Offline and collaboration for durable storage, recovery, presence, comments, revisions, and the conservative rebase gate.

Remote operations must arrive at exactly serverVersion + 1. Older versions and known mutation echoes are idempotently ignored; a gap emits reload-required instead of guessing. Canonical server operations apply with source remote, so they repaint/recompute without entering the outgoing queue.

Document state does not include selection, scroll position, editor/caret state, search results, temporary highlights, renderer choice, read-only policy, or local zoom. Those are session state. Workbook.activeSheet remains document metadata in schema 1.

Validation and protection run at the shared local transaction boundary, not only inside the inline editor. Validation policies can reject atomically, apply with a warning, or allow input. Protected ranges deny local writes unless the host's ProtectionResolver allows them; the default is deny. atomic mode rejects a transaction containing any denied operation, while partial mode filters denied operations and reports them in rejections. Protection is client UX policy, not server authorization. Remote operations intentionally bypass local protection.

Applied storage transactions emit change with the filtered transaction, per-cell rollback data, accumulated dirty patches, epoch, commit reason, and an explicit source (local or remote). Remote operations still update formulas and rendering, but do not re-enter outgoing persistence. Conflicts and no-ops return explicit outcomes rather than throwing.

Sheet IDs remain stable across rename and reorder. Renaming rewrites canonical cross-sheet formula source while preserving the stable formula-engine handle. Removing a referenced sheet rewrites dependents to #REF!; undo restores the sheet snapshot, formulas, styles, metadata, and dependencies. Removing the active sheet selects the nearest surviving sheet. The final sheet cannot be removed. All public document actions, including custom calls through grid.actions, are no-ops when the grid is read-only.

Cell values

A cell value is one of three shapes:

type CellValuetype CellValue = {
    kind: "literal";
    value: string | number | boolean | null;
} | {
    kind: "ref";
    target: CellAddress;
} | {
    kind: "formula";
    src: string;
}type CellValue =
  | {
      kind: "literal";
      value: string | number | boolean | null;
    }
  | {
      kind: "ref";
      target: CellAddress;
    }
  | {
      kind: "formula";
      src: string;
    };type CellValue =
  | {
      kind: "literal";
      value:
        | string
        | number
        | boolean
        | null;
    }
  | {
      kind: "ref";
      target: CellAddress;
    }
  | {
      kind: "formula";
      src: string;
    };API reference → =
  | { kind: "literal"; value: string | number | boolean | null }
  | { kind: "ref"; target: CellAddressinterface CellAddressinterface CellAddressinterface CellAddressZero-based address of one cell on a stable sheet ID.API reference → } // a plain cross-reference
  | { kind: "formula"; src: string }; // authoritative source; "=" is optional at storage

Headers: letters vs. field names

The grid chrome is a real spreadsheet: the top band shows column letters (A, B, C, … AA) centered, and the left gutter shows row numbers (its width is theme.rowHeaderWidth; set it to 0 to hide the gutter). These letters are the column headers the renderer draws — the header you set on a Column is metadata (it is what CSV/XLSX export writes), not the on-canvas header.

Named field titles are therefore not chrome. The convention, exactly as in a real sheet, is to put them in row 0 (the first data row) and style them yourself. The live Vanilla example reserves row 0 and writes a styled header band over it once the initial page loads:

const FIELD_HEADERSconst FIELD_HEADERS: string[]const FIELD_HEADERS: string[]const FIELD_HEADERS: string[] = ["ID", "Date", "Customer", "City", "Amount"];

function applyFieldHeader(): void {
  gridconst grid: Gridconst grid: Gridconst grid: GridThe imperative core grid this controller owns.API reference →.storeGrid.store: Storeinterface Grid {
  store: Store;
}interface Grid {
  store: Store;
}.applyTransactionStore.applyTransaction(tx: Transaction, options?: TransactionApplicationOptions): ApplyTransactionResultStore.applyTransaction(tx: Transaction, options?: TransactionApplicationOptions): ApplyTransactionResultStore.applyTransaction(tx: Transaction, options?: TransactionApplicationOptions): ApplyTransactionResultApply a low-level storage transaction. This bypasses Grid read-only checks and Grid undo/redo history. Use Grid.applyTransaction for normal host-driven edits. Queued and flushed at a barrier — never reentrant.API reference →({
    patchesTransaction.patches: DocumentOp[]interface Transaction {
  patches: DocumentOp[];
}interface Transaction {
  patches: DocumentOp[];
}Ordered document operations submitted as one store commit.API reference →: FIELD_HEADERSconst FIELD_HEADERS: string[]const FIELD_HEADERS: string[]const FIELD_HEADERS: string[].mapArray<string>.map<{
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}>(callbackfn: (value: string, index: number, array: string[]) => {
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}, thisArg?: any): {
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}[]Array<string>.map<{
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}>(callbackfn: (value: string, index: number, array: string[]) => {
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}, thisArg?: any): {
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}[]Array<string>.map<{
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}>(callbackfn: (value: string, index: number, array: string[]) => {
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}, thisArg?: any): {
    op: "set";
    addr: {
        sheet: string;
        row: number;
        col: number;
    };
    value: {
        kind: "literal";
        value: string;
    };
    style: {
        bold: true;
        align: "center";
        backgroundColor: string;
    };
}[]Calls a defined callback function on each element of an array, and returns an array that contains the results.@param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.@param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.((labellabel: stringlet label: stringlet label: stringMenu row text. Defaults per action.API reference →, colcol: numberlet col: numberlet col: number) => ({
      op: "set",
      addraddr: {
    sheet: string;
    row: number;
    col: number;
}let addr: {
  sheet: string;
  row: number;
  col: number;
}let addr: {
  sheet: string;
  row: number;
  col: number;
}: { sheetsheet: stringlet sheet: stringlet sheet: stringRestrict to a sheet (defaults to the active sheet).API reference →: "sales", rowrow: numberlet row: numberlet row: number: 0, colcol: numberlet col: numberlet col: number },
      valuevalue: {
    kind: "literal";
    value: string;
}let value: {
  kind: "literal";
  value: string;
}let value: {
  kind: "literal";
  value: string;
}: { kind: "literal", valuevalue: stringlet value: stringlet value: string: labellabel: stringlet label: stringlet label: stringMenu row text. Defaults per action.API reference → },
      stylestyle: {
    bold: true;
    align: "center";
    backgroundColor: string;
}let style: {
  bold: true;
  align: "center";
  backgroundColor: string;
}let style: {
  bold: true;
  align: "center";
  backgroundColor: string;
}Host styles merged before adapter sizing styles.API reference →: { bold: true, align: "center", backgroundColorbackgroundColor: stringlet backgroundColor: stringlet backgroundColor: stringhex color, e.g. "#ffffff"API reference →: "#eef1f5" },
    })),
  });
}

Datasource pages can carry the same authoritative CellValue shapes as eager data, plus { value, style } wrappers. Formula sources, references, and styles hydrate without entering dirty history. If row 0 is styled locally while a page is outstanding, the local edit wins over that stale response; reserving an empty row 0 in the source remains useful when the source itself should never provide a title row.