Sheet — Desktop Spreadsheet Parity Plan 🟡 PREVIEW

What is missing, why it matters, and the order in which it is being fixed.

Not a launcher app. build plan for the Sheet app, tracked in the issue tracker. This page is kept here because it documents part of the suite, but it does not appear in the app menu and has no stability classification.

This page is the reference for anyone deciding whether to trust Sheet with a real workbook, and for anyone implementing the work. It is deliberately blunt: a spreadsheet that is almost right is worse than one that is obviously incomplete, because a wrong number looks exactly like a right one.

Tracking issue: generalbots/generalbots#780.

Progress (2026-08-10): the frontend now ships a real SheetAdvanced module set — range selection, clipboard, undo/redo, fill handle, worksheet tab bar, live status bar, column-header sort, CSV/XLSX/Markdown export, conditional-format rendering, validation dots + list dropdown editor, and locale loading. Backend-heavy gaps (typed cells, parser, calc engine, number formats, xlsx round-trip, sessions, collab protocol) are unchanged.

Progress (2026-08-10, second pass): the frontend now speaks A1 row/col addressing to the collab socket instead of the legacy row*26+col position encoding (gap 25), columns and rows resize interactively by dragging header edges with persistence through /api/sheet/resize (gap 11), and Ctrl+click / Ctrl+drag accumulate multi-ranges whose overlays render simultaneously (gap 12). The JS module test suite moved out of the served static tree (issue #809), then grew to 70 assertions covering core, clipboard, validation, widths, freeze, filters, formula fill, paste/i18n, undo, notes, charts, multi-range and drag-resize. The plan phases below mark what is genuinely shipped; gaps still open are labelled honestly.

Progress (2026-08-10, third pass): the column count reached the desktop standard — 16,384 columns (DEFAULT_TOTAL_COLS) with full header/scroll virtualization, so only the visible column window is laid out and fetched (gap 10; canvas rendering remains the only unfinished part of issue 6). The collab protocol is now server-authoritative: edit and cell_update messages are applied to the session under one write guard, record an oplog entry via the session, and are stamped with a monotonically increasing seq; reconnecting clients replay the GET /api/sheet/:id/ops?since=N log through onEdit before trusting the live feed (gap 25 fully closed). Document listing is metadata-only: every save writes a .meta.json sidecar with ACLs, and the list endpoint reads sidecars instead of deserialising whole workbooks (gap 24). .xlsx import now maps workbook defined names and per-sheet protection into the model. The JS suite is at 76 assertions and the botsheet-core engine tests at 85, all green.

Progress (2026-08-15, large-sheet + fidelity pass): the save-back path is zip-level preserve-and-passthrough (only <c> cells and the workbook sheet list are rewritten; charts/pivots/validation/images/macros are copied byte-for-byte), so the original .xlsx is never overwritten (E1–E5, E7 landed). Cell hyperlinks now import into the model. Two large-sheet fixes landed: (1) the import loop now iterates umya’s actual-cell map instead of the 1..=max_row × 1..=max_col bounding box — a sheet with a cell at row 1,000,000 no longer scans a million empty rows — and (2) source_bytes serializes as base64 rather than a JSON number array. Calculation fidelity: format_number no longer saturates on as i64 for magnitudes beyond i64, and typed operators now propagate the original error (=1/0+5 → #DIV/0!, not #VALUE!); non-finite ^ results yield #NUM!. All file-size debt in botsheet + botsheet-core is cleared — chart_read.rs 701 → 431/161/134, cell_ops.rs 600 → 292/320, crud.rs 593 → 450/149, requests.rs 548 → 406/148, websocket.rs 457 → 391/72, arrays.rs 473 → 412/61. Every .rs is now ≤ 450 lines.

Progress (2026-08-15, rich text + dxf pass): rich-text runs now import into the model by recovering per-run bold/italic/underline/colour/font/size from the raw xl/sharedStrings.xml (umya flattens them), keyed by "row,col" and attached as Worksheet.rich_text; conditional-format dxf styles now carry full font fidelity (family, size, weight, style, decoration) in addition to fill + colour.

What already works well

• Around 170 worksheet functions, across arithmetic, statistics, text, dates, lookups, criteria aggregation, and the Microsoft 365 dynamic-array and lambda families (FILTER, SORT, UNIQUE, SEQUENCE, LET, LAMBDA, MAP, REDUCE, BYROW, HSTACK, TEXTSPLIT, GROUPBY, PIVOTBY), plus BOT_AI_PROMPT for AI-evaluated cells.
• Over 70 HTTP endpoints covering cells, ranges, formatting, worksheets, charts, validation, comments, protection, named ranges, external links and collaboration.
• Per-cell OOXML number-format extraction straight from the .xlsx XML, with the full ECMA-376 built-in format table.
• Virtualised scrolling, so a very large row count does not build a very large DOM.
• Storage in Drive, consistent with the rest of the platform.

The function library in particular is a genuine asset and is not being rewritten — it is being re-hosted on a real evaluator.

The thirty gaps

Each row links to the issue that closes it.

Data model

Formula engine

Rendering

Interaction

File fidelity

Infrastructure

Code health

The plan

Twelve issues in four phases. The ordering is a dependency order, not a priority order — each phase leaves the app strictly better, and nothing is built on a foundation that has to be torn out later.

Phase 1 — Foundation

Phase 1 is unglamorous and unavoidable. While a cell is a String and a formula is a string match, everything above it is built on sand.

Phase 2 — Presentation

The grid moves from one absolutely positioned <div> per cell to canvas rendering with a DOM overlay for interactive chrome — the approach every serious web grid uses, because per-cell borders, fills, clipping and overflow cannot be composited at 60 fps in the DOM.

Phase 3 — Interaction

The clipboard writes three flavours — TSV, styled HTML, and an internal JSON payload — so that a copy survives into other spreadsheet apps, and back again losslessly. Parsing competitor spreadsheets’ text/html flavour is what makes “paste keeps my formatting” true.

Phase 4 — Fidelity and infrastructure

Issue 788 starts out of order. Its first commit makes the .xlsx save-back non-destructive, because gap 20 is data loss reachable today and should not wait for its phase.

Round-trip fidelity is achieved by preserve-and-passthrough: retain the original .xlsx package, rewrite only the parts Sheet owns, and copy everything else verbatim. That is how a pivot table Sheet cannot render survives being edited around.

Enterprise fidelity — open issues (2026-08-15)

The table below is the remaining distance between the current BETA and “replace Excel / Google Sheets”. It is ordered by user-facing risk: data safety first, then visual fidelity, then scale. Each row is a ready-to-file issue with a concrete acceptance bar. (The save-back path is now zip-level preserve-and- passthrough — only xl/worksheets/sheetN.xml cell data is rewritten and every other part is copied verbatim — and edited text cells reuse the shared-string table when the value already exists, falling back to valid inline strings.)

Each lands the same way the shipped phases did: preserve-and-passthrough for anything the model cannot represent, model expansion for the parts Sheet renders, and canvas/CRDT only where the DOM and last-write-wins are provably insufficient.

Definition of done

• A real workbook — 40 sheets, pivot tables, nested INDEX/MATCH, conditional formatting, a chart — opens, renders, edits and saves without losing anything Sheet does not itself understand.
• Paste from another spreadsheet app keeps values, formulas, formats, fills and merges.
• Formulas are spreadsheet-correct: precedence, 2^3^2 = 64, -2^2 = 4, error propagation, cross-sheet references, $ anchors that survive a fill.
• 16,384 columns and 1,048,576 rows, scrolling above 55 fps.
• Undo works, 100 levels deep, one step per user action.
• Two people edit at once without either losing work.
• A viewer cannot write; a tenant cannot read another tenant’s document.
• Every toolbar control does something. Every string is translatable.
• cargo check and cargo clippy clean. No unwrap/expect/panic! outside tests. No file over 450 lines. No #[allow].
• Twenty browser scenarios pass through Chrome CDP, with screenshots.
• Performance budgets asserted, not merely observed:

See Also

• Sheet — Spreadsheets — user-facing feature reference with current status
• Sheets API — endpoint reference
• AI Sheet Cache — BOT_AI_PROMPT caching