No merge dialog.
Ever.

Concurrent edits from several people converge on one document with nothing to resolve. Written from scratch — importing it would leave a notebook app with nothing learned in it.

A balanced tree over text, so splicing into the middle of a long document is O(log n) rather than a full copy. Compiled to wasm and shared with the browser.

Ops are batched lock-free off the socket thread and appended to a WAL before broadcast, so a crash loses nothing that was already acknowledged to a client.

A symbol table plus an engine that re-analyses only what changed. The block tree is the analyser's cheapest advantage — an edit's blast radius is a subtree, not the whole file.

A build system for prose: each diagnostic is a derived fact with declared inputs, so invalidation propagates exactly as far as it must and no further.

Undo that touches only your own edits across a log interleaved with everyone else's — tractable only because undo is a new op computed against the log, never a rollback of shared state.

Structural diff over the block tree, so a moved section reads as a move rather than a delete plus an insert — the version-history algorithm a line-based Myers diff cannot do.

Tantivy in-process plus the backlink graph, and two deliberately different fuzzy searches — one for a page you half-remember, one for autocompleting a link mid-keystroke.

Session routing on a virtual-node ring with a failure detector and rehash, so every client on a page reaches the same stateful instance even as the fleet changes under them.

Written from scratch rather than pulled in as a crate. The whole objective is Rust depth — importing the interesting part would leave a notebook app with nothing learned in it. The tradeoff is real: a mature CRDT library is better tested than mine will be for a long time.

The op log is the source of truth and block rows are a projection — not an audit table bolted beside a mutable one. This is what makes per-actor undo tractable: undo is a new op computed against the log, never a rollback of shared state.

ADR-001 draws the boundary hard: no databases, no formulas, no workspaces, no permissions matrix. Three things done unusually well, chosen so the interesting engineering cannot be dodged by adding features instead of depth.

Foundation work is pulled by the first service that needs it, never pushed ahead of one. Building shared crates before a consumer exists is the speculative abstraction the project structure explicitly forbids — extract on the third use.

Cloud is not a track at the end. A phase is not done until its increment is deployed — Phase 1 already carries Terraform, Cloud SQL, Secret Manager and a first deploy. Cloud Run first, GKE arriving at Phase 3 when a stateful service finally needs it.

There is no red anywhere in the interface. A notebook has no compile step, so nothing in it is broken — the most severe state available is amber, and it reads as advisory rather than as an error.