End-State Topology

Genre: program record. This doc names current crates because the program is about these crates; the domain models it leans on live in the sibling wg clusters and are only referenced, never restated.

The two sources

The v2 family is the chassis. Its topology is adopted as-is:

• the pure pipeline — (document + effective values) → resolve → drawlist → paint, with an immutable frame product at the boundary, constructed through one entry no matter the host;
• time as data — a frame is requested at a value state: base, or sampled at an explicit time; nothing in the core owns a clock;
• the animation kernel — the chassis's most complete subsystem and the reference for how every time-varying input enters the engine;
• the resolver topology — measure → layout → transforms → bounds, with anchor bindings and declared size intents;
• the text-layout seam — a backend-neutral shaped-layout artifact behind a versioned oracle trait;
• the read and replay tiers — spatial query, the operation journal, the replay corpus, damage as data;
• the determinism doctrine — replayable sessions, versioned oracles, honesty rigs that fail loudly when goldens or budgets drift.

The legacy family is the know-how. Its substance is adopted through contracts, never copied wholesale:

• the per-node paint specs and the effects estate;
• the measured performance-optimization estate;
• the import stacks (HTML/CSS and SVG) and the export subsystem;
• the paragraph feature depth and the text-editing stack;
• the editor-core vocabulary and the sync model;
• and, until the bar flips, the role of executable conformance reference for every suite it still wins.

The bridge: the chassis exposes agnostic contracts — the leaf paint vocabulary, the shaped-text artifact, the layout model — and legacy capability migrates through those contracts, gated per the charter. Two things are deliberately not shared: the display list (per-engine by settled ruling — the display-list contract study) and each engine's compile policy above the leaf vocabulary.

Per-domain adoption map

The index; each row is expanded in The domains below.

The domains

Pipeline & frame

The chassis pipeline is the end-state pipeline: resolution is a pure function of the document and its effective values; the display-list build is a pure projection of resolved geometry and authored paint intent; painting executes that projection against a backend. A frame is an immutable product with timings, and every host — CLI, editor, server, test rig — reaches it through the same entry. Legacy contributes experience rather than structure here: its frame-scheduling and stability policies inform the preview mode (see Realtime performance). Status: landed with the v2 promotion.

Animation & time

Chassis-only — the legacy engine has no animation system, so nothing migrates. The kernel provides format-neutral, explicit-time sampling: exact time arithmetic, typed curves over scalars, colors, transforms, and path geometry, keyframe timing with easing, and additive/ accumulative composition — compiled from authored sources into a source-neutral animation program that maps one declared time onto plain property values without mutating the document. The first authored frontend is a strict SVG animation subset (the cumulative profiles under feat-svg); native n0 XML animation syntax is deliberately deferred until a second, materially different producer exercises the program (n0 XML animation RFD). Playback is a caller-owned clock mapping host time to sample time; frame scheduling is forever a host concern — the core never owns a wall clock.

Layout

Not a rivalry: both engines delegate flex to the same shared layout library, so the contest was never whose flexbox. The chassis's resolver topology is the end-state frame — measure, layout, transforms, bounds, with anchor-based positioning and declared size intents. The know-how to grant through it: block flow, the CSS-grid mapping proven in the HTML renderer, and the handling of virtual grouping nodes that appear in trees without owning layout. The resolver's semantics — rotation-in-flow, and size intents that are fixed or hug with deliberately no fill (growth is by grow and self-align) — are anchor-model doctrine; the anchor spec graduates from the archived paper into the wg tree in Phase 0's docs lane, with its home cluster chosen by the docs-placement doctrine at graduation.

Text

The chassis owns the seam: a backend-neutral shaped-layout artifact behind a versioned oracle trait — shape once, record glyph placements, replay them downstream, never reshape. The know-how owns the coverage: decorations, font features, letter/word spacing, RTL run handling, fallback management, ellipsis and line clamping, stroked text, and the full text-editing stack (sessions, selection, caret metrics, history). All of it migrates through the artifact, not around it. Known finding: paragraph base direction is latin-first on the legacy side today; the end state resolves base direction from content and authored intent. The text-oracle identity — stay on the lab shaper vs move to a production font stack — is decision D-H, taken only at the Phase 5 boundary, because flipping the oracle re-blesses both engines atomically.

Painting

The program's center of gravity. The shared surface is the leaf paint vocabulary (the ratified paint-model RFD): ordered paint stacks, stroke applications, and tri-state text-run paint ownership. The know-how is everything the legacy engine knows above that vocabulary: how each of its 19 node types compiles to paint — shape derivation, boolean flattening, virtual grouping, mask groups — and the effects estate: gradient semantics, render-intent-keyed image sampling, image filters, drop and inner shadows, noise, blur. The migration order: the vocabulary becomes a shared crate (Phase 1); a conformance suite runs the paint RFD against both engines' types and yields a gap report; per-node capabilities then land in the chassis gated by the scoreboard. Display lists stay per-engine; so does compile policy.

Realtime performance

The chassis brings the sockets: damage as data (frame products diff into precise change sets), stable node identity for cache keys, and a scene raster cache that re-composites whole frames under camera motion. The know-how brings a measured estate: cache promotion with heuristics tuned by benchmarks (including refusing to cache actively-edited nodes), whole-frame reuse under pan and zoom, input-cadence-aware frame stabilization (interaction-quality frames while the user moves, full-quality on settle), reduced effect quality during interaction with cache-variant hygiene, budgeted progressive re-rasterization after zoom, and camera quantization for pixel-stable blits. In the end state that estate returns as preview-mode policy layered above the pure core — never as semantics inside resolve or the display-list build. Whether camera and hot-loop edits become sampled inputs under the same time model as animation is decision D-K.

SVG — two surfaces

Two distinct product surfaces share the name:

• Import-to-document. The existing import pipeline's intermediate representation becomes a model-agnostic crate (Phase 3); the legacy engine keeps consuming it unchanged, and the chassis gains its own packer against it. Constructs the model cannot express become honest UNSUPPORTED scoreboard rows — never silent shims.
• Render-to-pixels. The SVG render CLI builds on the browser-grade-cascade lineage — SVG styled by real CSS resolution — aiming at the svg in → pixels out product (gridaco/nothing#13).

Stated program default (owner may override at Phase 3 entry, where the charter's NAME decision also confirms this reading): the two remain distinct surfaces — a document import and a rendering product. SVG animation is already chassis territory (see Animation & time).

HTML/CSS

Wholly know-how today, and mature (the owning domain doc: htmlcss): a real browser cascade implementation resolving computed styles, a layout mapping that includes CSS grid, paint with the long tail of CSS visuals, and a web-platform-tests harness grading it against the Chromium bar continuously. End state: the styled-tree front-end is extracted and shared; the chassis consumes it through an adapter that maps styled elements onto the model; text on both sides flows through the shaped-text artifact of the text-layout RFD. Gated by the font-provider decision (D-D) and the closed-set architecture test (Phase 4).

Export

The accurate-static render mode made concrete: raster formats, PDF including multi-page documents, and SVG out — always at full render intent, camera aimed at a node or scene, resolution-scaled without resampling artifacts. Wholly know-how today. Granted to the chassis before Phase 6's contraction (a charter amendment — the original contraction list omitted it). Export doubles as the conformance path: what the scoreboard grades is what export produces, so the export surface inherits every conformance result for free.

Editor core

The chassis carries the operation journal and replay — editing as time-as-data, sessions as corpora that serve repro, bench, fuzz, and conformance at once. The know-how carries the editing vocabulary: a working copy over the document, invertible serializable mutations, history with origins, a closed command registry with keybinding chains, intent interpretation (gesture → mutation), and the sync model — authority-ordered optimistic replication per feat-crdt. Whether the end-state editor core extends the chassis's ops or graduates the legacy editor core onto the chassis is decision D6, decided by a timeboxed mapping spike against the graduated anchor spec — before the two accrete independently.

Server & headless

The end state runs the engine as the document authority behind the CRDT server: fully headless, deterministic, and buildable with no graphics backend at all. The model family already meets this requirement — model, operations, resolution, picking, and animation sampling are backend-free. The engine crate does not yet: its raster backend is confined by design but unconditional in the build, so a build split must exist before a backend-free server build does (priced in the charter's amendments). Deterministic text exists via the lab oracle; production-grade server text hangs on D-H. Transport, persistence, and presence are host concerns — the engine ships document semantics, not a server.

Wasm

The published v1 wasm package is the freeze-contract surface and the product's only consumption point today; its publishing obligations continue unchanged through the program. The chassis has no wasm target yet — the port is priced work, not an assumption — and the switch (package identity, soak window, product-side unpin, freeze-contract retirement) is Phase 6's D-I, coordinated with the product side. Until then, no new capability accretes to the v1 package.

Format & storage

The canonical engine contract is the in-memory model and its operation vocabulary. .n0.xml is the authored source form (the n0 XML RFD family; root-element identity is still open in its ratification pass). The v1 binary (.grida / FlatBuffers) is legacy input through an explicit converter — converter-shaped forever, never a native dialect. What replaces it as the archive/interchange form — ratified n0 XML, a future v2 binary, or a host-owned format with engine-provided tooling — is D-G(b) widened by D-J (the host-managed posture in goal.md). The v1 schema is a frozen surface until Phase 6.

Foundations

The model-agnostic satellite crates both engines stand on: math (geometry primitives and transforms), font introspection (parsing, feature enumeration, family selection, webfont metadata — distinct from shaping, which lives behind the text oracle), and the cascade engine. The end state keeps this tier as shared foundations consumed by contracts and engines alike; vocabulary crates cut during the program (paint first, the SVG IR next, the styled-tree front-end after) join it. Each cut settles its own math vocabulary at the moment of cutting, per the method's naming step — never before; the SVG IR's cut carries the charter's NAME decision.

Verification estate

The program's instrument tier — shared, not owned by either engine: the reftest tooling and its scored suites, the web-platform-tests harness, the replay corpus (one corpus serving repro, bench, fuzz, and conformance), the honesty rigs (byte-identical goldens, double-run determinism checks, budgeted benches that fail on regression), and — the program's spine — the v1-vs-v2 scoreboard with a flip rule ratified before any score exists. Corpora live under the repo-root fixtures tree; the large suites are machine-local by convention, so CI hosts a declared subset plus the baselines, and pretends nothing.

Dev shells & observability

Each engine keeps its dev shell for the program's duration: the legacy dev CLI (benchmarks, reftests, export tooling, the render seam the scoreboard will call) and the v2 windowed shell (direct-manipulation feel spikes, the live animation player, headless screenshot and bench modes). They converge on the dev editor as capability flips. Tracing stays feature-gated and zero-cost when off. Shells are hosts: nothing in a shell may become load-bearing engine semantics, and anything a shell proves must graduate into the engine or a contract to count.

Render modes — one time model

The chassis already makes time an explicit input. All three render modes are policies over the same pure core; they may differ in when and at what quality they paint, and must never differ in what things mean. Meaning lives in the resolved document and the paint vocabulary — a mode cannot change it.

• realtime preview — the interactive canvas. Heuristics for stable frames under camera movement and hot-loop editing (frame reuse, quality reduction, budgeted re-rasterization) are welcome, and the legacy estate is the reference know-how — but they live at the host/compositor tier, never inside resolve or the display-list build. The candidate design treats camera and in-progress edits as sampled inputs under the same animation kernel; that unification is decision D-K — a design to be specified, not an existing fact.
• accurate static — the export path: full quality, no heuristics, deterministic output. The legacy export subsystem defines today's bar.
• accurate animation — offline export at exact sampled times; every frame is an accurate-static render at its declared time, so frame drops are structurally impossible. This mode already exists in the chassis for the SVG animation profiles.

End-state crate silhouette

Deliberately coarse — each concrete cut gets its own naming exercise at the moment doctrine arms it (second consumer), never before:

• the v2 engine family as landed: the backend-free model crate, the engine crate (gaining a graphics-backend-optional build to earn the server role), the dev shell;
• shared vocabulary and foundation crates, growing as cuts land — the paint vocabulary first, the SVG IR next, the styled-tree front-end after, alongside the existing math/fonts/cascade tier;
• the legacy family contracting by subtraction until only its Phase 6 residue remains — the v1 compat adapters, the legacy paint compiler, the v1 format io, and the wasm publisher — and then, at Phase 6, retiring entirely;
• archive/ holding each concluded program's frozen record — this program's eventual home too.