Performance and delivery evidence

Every number on this page comes from a validated local protocol artifact captured on a clean tree; nothing is published from an unvalidated or protocol-mismatched artifact. Every expected cell carries either a validated timing or its recorded failure - a run that did not complete is shown as a failure, never converted into a timing.

Release retained engine memory

WebAssembly linear memory grows but does not shrink after cells or stores are cleared. When your application is idle after a large import, clear, or workbook disposal, call releaseEngineMemory explicitly. Sheetwrite never schedules a release automatically.

import { releaseEngineMemory } from "@sheetwrite/core";

const report = await releaseEngineMemory();

The call waits for synchronous transactions and active datasource page loads, then moves all live stores together into a fresh instance of the selected engine. Cell sources, styles, cached formula results (including volatile results), resident datasource pages, unsaved dirty edits, and compact undo/redo history survive. Unloaded clean pages remain unloaded and can be fetched again from the datasource. Worker renderers rebuild their frames without document-change events.

The main-thread pause scales with resident cells and compact history, so do not invoke it on an interaction-critical path. Migration temporarily needs both instances and packed transfer buffers; it can increase peak memory before garbage collection reclaims the retired instance. If preparation fails, every live store stays on the original instance. Concurrent calls share the same release.

report.wasmBytesBefore and report.wasmBytesAfter are committed linear-memory bytes, not live-cell bytes or process memory. report.pauseMs measures migration, excluding the idle wait. A release is not guaranteed to reduce committed bytes: surviving data, compact history, and migration scratch can still require substantial memory. Actual process-memory reclamation depends on garbage collection.

Capture

Captured

2026-10-17 05:18 → 2026-10-17 08:11 UTC

Commit

49e05e298c3f clean worktree

Artifacts

7 validated captures from that one commit; each section states its own environment (browser or runtime) and protocol

bench:release captures render-scale, the performance showcase's paged storage at bench/results/paged-results.json, the interaction evidence at bench/results/interaction-results.json, data, core paths, formula, formula engines, matched engines, and XLSX, then re-records the render regression baseline last. Its smoke rehearsal writes only to bench/results/smoke/.

The interaction capture (bench:interaction, schema interaction-current-v2) measures the current build, not a comparison: packed inverse-index lookup latency in nanoseconds, inverse-index backing bytes, retained bytes after 100 distant edits, and the cold-route long task owned by Sheetwrite. It records the raw samples, the summary derived from them, the runner, and the method, and it holds those four metrics to absolute release ceilings. Version 1 recorded a one-off before/after pair whose baseline build cannot be re-measured at a later release, so no old sample is carried forward into the current capture.

Matched local regression check

Timing comparisons run deliberately on a controlled local machine, not as a required CI job. Capture ten fresh matched rounds, retain every raw sample, and compare the fresh artifact with the committed baseline. Any unapproved slowdown fails the local command.

bun run --filter @sheetwrite/bench bench:render:prepare
cd bench
bun run src/render-driver.ts --rounds 10 --output results/render-fresh.json --markdown-output results/render-fresh.md
bun run src/check.ts --baseline results/render-baseline.json --fresh results/render-fresh.json --power-mode balanced --concurrency 1

A result is a regression decision only when that final baseline check passes on the declared power mode and concurrency. bench:verify remains a smoke and safety-ceiling check.

The committed baseline at bench/results/render-baseline.json pins the harness source hashes, the declared sampling, and the runner (OS, CPU, Bun, Node, Chromium, power mode, concurrency). It is therefore machine- and harness-pinned: it must be re-recorded whenever a harness file, the sampling flags, the protocol version, or the runner changes, and the release capture does that as its last step by re-recording ten controlled rounds into bench/results/render-baseline-raw.json and promoting that artifact over the committed baseline. Until the re-recorded baseline is committed, bench:check fails closed on the fingerprint mismatch instead of comparing unrelated measurements.

Render benchmark

Both engines drive identical scripted interactions in a controlled browser. Pick a workbook size and a metric:

Captured

2026-10-17 05:18 UTC

Commit

49e05e298c3f clean worktree

Engines

Sheetwrite 0.5.0 release candidate · Handsontable 18.1.2

Environment

Bun 1.4.3 · Node compatibility 26.3.0 · Chromium 153.0.8010.12 · 12th Gen Intel(R) Core(TM) i9-12900H

Protocol

10 rounds · raw artifact bench/results/render-scale.json

Reproduce and validate with:

bun run --filter @sheetwrite/bench bench:render:prepare
bun run --filter @sheetwrite/bench bench:render:scale

Runtime resource ownership

The performance showcase at /showcases/performance#resource-ownership renders the public RuntimeResourceSnapshot protocol directly. It keeps exclusive-owner logical bytes, allocated capacity, WASM committed pages, and independent browser runtime observations in separate buckets; committed pages are never summed into live payload. Bulk-edit before/settled deltas use diffRuntimeResourcePhases and omit unchanged owners.

The UI and this reference share RUNTIME_RESOURCE_SCHEMA_VERSION. Detailed peak phases remain in the validated benchmark artifact rather than being presented as measurements from the visitor's browser.

String collection reclaims obsolete pool text and densely remaps surviving IDs. Automatic collection runs only at committed edit transaction barriers, never during painting or page loading, when dead arena/span storage exceeds 256 KiB and the surviving arena/span storage. Growth-based backoff avoids repeatedly scanning unchanged live data. Bulk clears and sheet removal request a new threshold check at the next commit.

compactStringStorage() explicitly collects unreachable text and trims growth slack outside an active mutation/page load. Raw IDs are valid only within stringPoolEpoch(); retain the epoch with projections and invalidate caches on a change, as described in the worker rendering guide. History snapshots own captured text. Persist resolved values, not pool IDs. Reclaimed Rust ownership does not imply that WebAssembly committed linear memory shrinks.

Reproduce and validate the full owner/operation matrix with:

bun run --filter @sheetwrite/bench bench:resource

Data engine benchmark

Captured

2026-10-17 05:24 UTC

Commit

49e05e298c3f clean worktree

Engines

Sheetwrite 0.5.0 release candidate · Handsontable 18.1.2

Environment

Bun 1.4.3

Raw artifact

bench/results/data-results.json

Sheetwrite alone at scale — Handsontable cannot complete these sizes headlessly:

Reproduce with:

bun run --filter @sheetwrite/bench bench:data

Core write path

Grid.applyTransaction of a 1,000,000-cell setBlock

488.7 ms

fromCsv import of 200,000 rows by 10 columns

234.6 ms

undo of a 1,000,000-cell clearRange

1,609.1 ms

cold initSheetwrite() through first store in a fresh Node process (7 processes)

4.24 ms

Reproduce with:

bun run --filter @sheetwrite/bench bench:core-paths

Formula engine benchmark

Captured

2026-10-17 06:43 UTC

Commit

49e05e298c3f clean worktree

Raw artifact

bench/results/formula-results.json

Reproduce with:

bun run --filter @sheetwrite/bench bench:formula

Default and full formula engines

Shared workloads more than 5% slower on the full engine

0 of 8

Widest paired-ratio spread

1.32× (limit 1.50×)

Default engine WASM, Brotli

256,150 B

Full engine WASM, Brotli

344,260 B

The default engine is @sheetwrite/wasm. The full engine is @sheetwrite/formulas. Select it with initSheetwrite(undefined, formulas). Each app uses one engine.

No shared workload tested in the matched rounds had a median paired ratio more than 5% slower with the full engine. This check covers the eight flagged rows, not a new matched run of all 53 rows.

Reproduce after bun run build:packages:

cd bench
bun run bench:formula:engines
bun run bench:formula:matched

XLSX codec benchmark

Import: time

5.5× faster

Import: peak memory

91% less

Export, 4 scenarios: time

1.3–3.7× faster

Export, 4 scenarios: peak memory

19–47% less

The baseline is the same codec at commit 87fadb723979, built from that commit and measured in the same session. Ratio = current ÷ baseline; below 1 is faster or smaller.

Reproduce with a checkout of the baseline commit, built and passed as the comparison root:

git worktree add ../sheetwrite-xlsx-baseline 87fadb72397947ea8c6ba576682925c7879579b8
cd ../sheetwrite-xlsx-baseline && bun install --frozen-lockfile && bun run build:packages
cd - && bun run --filter @sheetwrite/bench bench:xlsx -- --baseline-root ../sheetwrite-xlsx-baseline

Delivery size