RiXCel implementation checklist

This checklist is ordered so every milestone leaves a usable, testable layer. Checked items are implemented in the current RiX repository.

0. Portable sheet output

• Add .Sheet(data, options?) to the Output capability group.
• Adapt RiX tensors, matrices, rank-1 sequences, and rectangular nested sequences.
• Preserve exact RiX values in the output object.
• Support rank-N plane selection with viewAxes and slice.
• Attach full 1-based indices and canonical grid[...] addresses.
• Provide dual spreadsheet/RiX column labels.
• Add deterministic text rendering.
• Add host-neutral HTML rendering with data-rix-address.
• Add evaluator tests and runnable examples.
• Document the snapshot/live boundary.

1. Renderer and notebook integration

• Add dedicated Sheet styling to RiX Web.
• Render a selected-address indicator such as C2 · grid[2,3].
• Add pointer and keyboard selection without enabling value edits.
• Let formula/source editors insert canonical addresses by activation.
• Add axis selectors for rank greater than two.
• Add static Sheet rendering to the RiX notebook.
• Add accessibility tests for row/column headers and keyboard navigation.

2. Binding and widget protocol

• Specify a first-class Binding/lens value.
• Capture lvalue identity without exposing renderer-specific references.
• Define Get, Set, At, Slice, and subscription behavior.
• Define portable semantic widget events.
• Add a host-owned Widget session protocol.
• Make .Sheet(.Bind(tensor)) an editable tensor view.
• Apply the same interaction protocol to at least one Graphic example.
• Define snapshot and serialization behavior for live widgets.

3. RiXCel document runtime

• Specify the versioned .rixcel JSON format.
• Define a formula-slot entity separate from immediate Binding lenses.
• Store authoritative formula source and rebuild deferred IR from it.
• Give each formula sheet a document-owned isolated execution context.
• Define sheet:formula separately from immediate sheet:set events.
• Add atomic evaluation epochs with explicit dirty/evaluating/error states.
• Add sparse version-2 persistence with stable sheet, slot, and event IDs.
• Keep imported FormulaSheet graphs sparse with lazy implicit-slot materialization.
• Store source separately from assignment mode.
• Implement implied := and explicit RiX assignment modes.
• Add grid, row, col, and index evaluation bindings.
• Add the near evaluation binding.
• Add public FormulaSheet.Near(origin, offsets) for explicit relative reads.
• Add book, names, and imports namespaces.
• Record runtime slot-read dependencies.
• Incrementally recompute dirty dependents.
• Detect cycles and report complete address paths.
• Reserve explicit prior-epoch access instead of falling back to stale values during cycles.
• Forbid formula writes to other slots.
• Publish FormulaSheet commits through the shared reactive subscription protocol.
• Retain .LiveView(source, deferred) as a deprecated compatibility wrapper.
• Add a general .ReactiveGraph with named source and computed nodes.
• Make FormulaSheet a coordinate adapter over the general graph.
• Track computed dependencies dynamically from runtime reads.
• Incrementally propagate changes through transitive dependents.
• Batch graph propagation into atomic evaluation epochs.
• Add $name tracked reads/updates and $$name reactive-cell declarations/identity reads.
• Add same-cell aliases through $$alias := $$name.
• Add atomic ${ ... } reactive transactions with forward references and rollback.
• Warn when a reactive definition uses a plain untracked read of a reactive name.
• Support uppercase reactive callable bindings such as $$Scale.
• Add $sheet[index] tracked reads and deferred formula updates.
• Add $sheet whole-sheet tracked reads and $$sheet identity reads.
• Accept dense tensor-shaped FormulaSheet definitions at rank N.
• Add cosmetic rank-N axis names, coordinate headers, and named slice choices.
• Edit FormulaSheet row/column coordinate labels while retaining numeric headers.
• Render imported blank fields as blank without hiding intentional _ results.
• Let interactive hosts observe and dispose a direct final reactive output such as $frag.
• Coordinate tracked dependencies that span multiple independent ReactiveGraphs.
• Define volatile/external-source recomputation policy.
• Add round-trip and migration tests for .rixcel documents.

4. Standalone RiXCel editor

• Replace the placeholder apps/cel package with a RiXCel web app.
• Implement bounded 2D grid-window rendering with row/column navigation.
• Edit formula bodies from FormulaSheet grid cells.
• Add a dedicated formula bar, assignment-mode control, and exact-value display.
• Add document-level undo and redo as event-log cursor movement.
• Add single-cell formula copy/paste with explicit absolute grid and relative near semantics.
• Add multi-cell copy/paste and fill with atomic batch history events.
• Add row/column insertion with parsed reference updates.
  • Add tokenizer-aware grid/near reference rewriting and dynamic-reference detection.
  • Add shape-changing structural history events with cursor-safe undo/redo.
• Add local persistence and .rixcel open/save.
• Preflight imports and edits in a restartable, timed worker with restricted capabilities.
• Move persistent FormulaSheet ownership and visible-plane projection fully into the worker.
• Show dependency, cycle, parse, and runtime diagnostics in the grid.
• Add browser-level tests for editing and persistence.

5. Interchange and embedding

• Import CSV/TSV values.
• Import .xlsx values and sheet structure.
• Preserve unsupported delimited foreign formulas as non-executable metadata.
• Define and test a limited Excel-formula-to-RiX translator.
• Export computed values to CSV/TSV.
• Export computed values to .xlsx.
• Embed a RiXCel document as a notebook widget.
• Publish explicit named sheet exports to notebook RiX code.
• Detect import cycles across RiX scripts and RiXCel documents.

6. Higher-dimensional and advanced behavior

• Provide selectors for hidden axes.
• Add labeled-index lookup while retaining canonical numeric identity.
• Define materialization from tensor values into formula slots.
• Define linked tensor-to-sheet views.
• Design tensor spill ownership and collision rules.
• Add block formatting and named rank-N regions.
• Test sparse sheets at large logical shapes.