@hueest/xray 0.5.0 → 0.7.0

package/dist/{project-BZosujs9.js → serialize-Cj-EHvMv.js}

@@ -1,4 +1,4 @@
-import { a as ROOT_ATTR, c as SPEC_GATE, i as NODE_CLASS, l as SPEC_INLINE, n as BOUNDARY_ATTR, r as LEAF_CLASS, u as SPEC_LEAF } from "./plate-BRR6d8Se.js";
+import { a as ROOT_ATTR, c as SPEC_GATE, i as NODE_CLASS, l as SPEC_INLINE, n as BOUNDARY_ATTR, r as LEAF_CLASS, u as SPEC_LEAF } from "./plate-CXIh5_OB.js";
 //#region src/ir.ts
 /** A frozen `LiteStyleDeclaration` of empty strings, for entry-less nodes (root/stitch/synthetic). */
 const EMPTY_STYLE = Object.freeze({
@@ -45,33 +45,35 @@ const EMPTY_STYLE = Object.freeze({
 	alignItems: "",
 	verticalAlign: ""
 });
-/** The `LeafKind` values, as a runtime list (kept local so `ir.ts` has no runtime edge back to `serialize.ts`). */
+/**
+* The `LeafKind` values, as a runtime list (kept local so `ir.ts` has no runtime edge back to
+* `measure.ts`).
+*/
 const LEAF_KINDS$1 = [
-	"text",
+	"text-line",
 	"text-block",
 	"media",
-	"box"
+	"box",
+	"hidden"
 ];
 function isLeafKind(kind) {
 	return LEAF_KINDS$1.includes(kind);
 }
 /**
-* Run a per-View pass over every View of a `PlateIR` (ADR 0022 §3). The pass is
-* the annotate-in-place kind — it mutates `view.bundle.root`'s nodes (sets
-* `dropped`/`folded`/`count`/… fields) and returns nothing; `eachView` just
-* sequences it across the bundle's Views. A cross-View pass reads across
-* `plate.views` directly instead (those stay deferred; ADR 0022 §2).
+* Run a per-View pass over every View of a `PlateIR` (ADR 0022 §3). The pass is the
+* annotate-in-place kind — it mutates `view.bundle.root`'s nodes (sets `dropped`/`folded`/`count`/…
+* fields) and returns nothing; `eachView` just sequences it across the bundle's Views. A cross-View
+* pass reads across `plate.views` directly instead (those stay deferred; ADR 0022 §2).
 */
 function eachView(plate, pass) {
 	for (const view of plate.views) pass(view);
 }
 /**
-* Copy the bounded computed-style set off the live `CSSStyleDeclaration` into a
-* frozen plain object (ADR 0022 invariant 5). The live view is NEVER stored, so a
-* pass cannot re-read the DOM. Each prop coalesces to `''` so a node whose `cs`
-* carries only a partial set (a test stub, or a UA-default-only element) still
-* reads a safe `string`, never `undefined`. Called by the walk at each node's
-* build site (it already holds the live `cs`) — the snapshot folds into Measure.
+* Copy the bounded computed-style set off the live `CSSStyleDeclaration` into a frozen plain object
+* (ADR 0022 invariant 5). The live view is NEVER stored, so a pass cannot re-read the DOM. Each
+* prop coalesces to `''` so a node whose `cs` carries only a partial set (a test stub, or a
+* UA-default-only element) still reads a safe `string`, never `undefined`. Called by the walk at
+* each node's build site (it already holds the live `cs`) — the snapshot folds into Measure.
 */
 function snapshotStyle(cs) {
 	return Object.freeze({
@@ -120,18 +122,15 @@ function snapshotStyle(cs) {
 	});
 }
 /**
-* Read the (grouped) IR back into a per-View `ViewCapture`'s `{tree, rules}` — the
-* inverse of the walk's IR build. The tree comes from the node structure;
-* the flat rule list is REBUILT from the IR: each node's lifted author + inline
-* rules (`decls.author`), its carried token defs (`decls.carried`), and its
-* synthesized fallback/size rules (`decls.fallback`/`decls.size`), plus the
-* bundle's non-node-anchored rules — the text-context rule and the `@container`
-* rep bands. A rule shared across nodes (its `ids` spanning several) sits on each
-* node's `decls.author` BY REFERENCE, so it is de-duplicated by identity and
-* emitted once. Fallback/size order follows the walk's PUSH order
-* (`bundle.nodes`); author/carried/context/band rules carry their own
-* `(spec, order)`, so their array position is immaterial — classify re-sorts by
-* `(layered, spec, order)`.
+* Read the (grouped) IR back into a per-View `ViewCapture`'s `{tree, rules}` — the inverse of the
+* walk's IR build. The tree comes from the node structure; the flat rule list is REBUILT from the
+* IR: each node's lifted author + inline rules (`decls.author`), its carried token defs
+* (`decls.carried`), and its synthesized fallback/size rules (`decls.fallback`/`decls.size`), plus
+* the bundle's non-node-anchored rules — the text-context rule and the `@container` rep bands. A
+* rule shared across nodes (its `ids` spanning several) sits on each node's `decls.author` BY
+* REFERENCE, so it is de-duplicated by identity and emitted once. Fallback/size order follows the
+* walk's PUSH order (`bundle.nodes`); author/carried/context/band rules carry their own `(spec,
+* order)`, so their array position is immaterial — classify re-sorts by `(layered, spec, order)`.
 */
 function emit(bundle) {
 	const tree = irTree(bundle.root);
@@ -198,22 +197,17 @@ function irTree(node) {
 	return out;
 }
 /**
-* A node's EFFECTIVE kids — the kids `emit` actually projects, after lowering the
-* `dropped` and `flattened` annotations. Used by BOTH `irTree` (tree building) and
-* `collectNodes` (rule collection) so structure and rules stay in lockstep, and by
-* `templateIR`'s structural matching (`serialize.ts`) so a run is templated on the
-* shape `emit` will project, not the raw pre-Flatten tree (ADR 0022 §3). A FOLDED
-* node yields NO kids — it projects as one synthetic text-bar leaf, so its raw
-* subtree is suppressed (the glyph-fold survivor model, ADR 0022 §4). For
-* each kid, in order:
-*   - `dropped` → omit it AND its whole subtree (a dropped node is never recursed).
-*   - `flattened` → splice it out: contribute NEITHER a tree node NOR its rules,
-*     and in its slot hoist the kid's OWN effective kids (recurse, so a chain of
-*     flattened wrappers collapses to a fixpoint). Dropping the flattened node's
-*     rules matches the old destructive Flatten exactly — the spliced wrapper never
-*     reached emit, and `isPassthroughWrapper` guarantees it carries no tokens, zero
-*     margin, and a coincident box, so there is no layout to lose.
-*   - otherwise → keep it.
+* A node's EFFECTIVE kids — the kids `emit` actually projects, after lowering the `dropped` and
+* `flattened` annotations. Used by BOTH `irTree` (tree building) and `collectNodes` (rule
+* collection) so structure and rules stay in lockstep, and by `templateIR`'s structural matching
+* (`distil.ts`) so a run is templated on the shape `emit` will project, not the raw pre-Flatten
+* tree (ADR 0022 §3). A FOLDED node yields NO kids — it projects as one synthetic text-bar leaf, so
+* its raw subtree is suppressed (the glyph-fold survivor model, ADR 0022 §4). For each kid, in
+* order: - `dropped` → omit it AND its whole subtree (a dropped node is never recursed). -
+* `flattened` → splice it out: contribute NEITHER a tree node NOR its rules, and in its slot hoist
+* the kid's OWN effective kids (recurse, so a chain of flattened wrappers collapses to a fixpoint).
+* Dropping the flattened node's rules is safe: `isPassthroughWrapper` guarantees it carries no
+* tokens, zero margin, and a coincident box, so there is no layout to lose. - otherwise → keep it.
 */
 function effectiveKids(node) {
 	if (node.folded) return [];
@@ -226,38 +220,35 @@ function effectiveKids(node) {
 	return out;
 }
 /**
-* A node's EFFECTIVE bone box — the rect downstream geometry passes read (ADR 0022
-* invariant 3). A glyph-fold survivor reports its `folded.box` (the union of the
-* absorbed icon + the text unit, exactly what the old synthetic bar measured); every
-* other node reports its raw measured `box`. The single place "override ?? raw box"
-* lives, so Superset / Crop never branch on `folded` themselves.
+* A node's EFFECTIVE bone box — the rect downstream geometry passes read (ADR 0022 invariant 3). A
+* glyph-fold survivor reports its `folded.box` (the union of the absorbed icon + the text unit);
+* every other node reports its raw measured `box`. The single place "override ?? raw box" lives, so
+* Superset / Crop never branch on `folded` themselves.
 */
 function boneBox(node) {
 	return node.folded?.box ?? node.box;
 }
 /**
-* A node's EFFECTIVE kind — the kind downstream shape/leaf passes see. A glyph-fold
-* survivor is a `text` leaf bar regardless of its raw `kind` (it was a text unit or
-* a thin container around one; the old merge re-stamped it `kind: 'text'`); every
+* A node's EFFECTIVE kind — the kind downstream shape/leaf passes see. A glyph-fold survivor is a
+* `text` leaf bar regardless of its raw `kind` (a text unit or a thin container around one); every
 * other node reports its raw `kind`.
 */
 function effectiveKind(node) {
-	return node.folded ? "text" : node.kind;
+	return node.folded ? "text-line" : node.kind;
 }
 /**
-* A node's EFFECTIVE declarations — the decls `emit` projects (ADR 0022 §4). A
-* glyph-fold survivor emits ONLY its synthesized `folded.decls` (the inline-block +
-* width/height the old merged bar carried); its own author/carried/fallback/size are
-* SUPPRESSED, since the bar replaces the original text unit. Every other node emits
-* its raw `decls`.
+* A node's EFFECTIVE declarations — the decls `emit` projects (ADR 0022 §4). A glyph-fold survivor
+* emits ONLY its synthesized `folded.decls` (inline-block + width/height); its own
+* author/carried/fallback/size are SUPPRESSED, since the bar replaces the original text unit. Every
+* other node emits its raw `decls`.
 */
 function effectiveDecls(node) {
 	return node.folded ? node.folded.decls : node.decls;
 }
 /**
-* Map every node by its plate-local id. Used by the build phase's CSS-extract to
-* attach each lifted rule to the node(s) it targets. Ids are unique across the
-* tree (`state.nextId++`), so the map is one-to-one.
+* Map every node by its plate-local id. Used by the build phase's CSS-extract to attach each lifted
+* rule to the node(s) it targets. Ids are unique across the tree (`state.nextId++`), so the map is
+* one-to-one.
 */
 function indexById(root) {
 	const map = /* @__PURE__ */ new Map();
@@ -271,11 +262,11 @@ function indexById(root) {
 //#endregion
 //#region src/css.ts
 /**
-* Pure CSS plumbing shared by both extraction strategies: which properties are
-* layout (vs paint), approximate selector specificity for cascade-preserving
-* ordering, and rendering scoped rules back to a single plate CSS string.
+* Pure CSS plumbing shared by both extraction strategies: which properties are layout (vs paint),
+* approximate selector specificity for cascade-preserving ordering, and rendering scoped rules back
+* to a single plate CSS string.
 */
-const EXACT_PROPS = new Set([
+const EXACT_PROPS = /* @__PURE__ */ new Set([
 	"display",
 	"position",
 	"float",
@@ -352,17 +343,15 @@ function isLayoutProp(prop) {
 	return PATTERN_PROPS.some((re) => re.test(prop));
 }
 /**
-* The legacy `-webkit-box` display family is the 2009 flexbox, used almost
-* exclusively for the `-webkit-line-clamp` truncation idiom
-* (`display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: N;
-* overflow: hidden`). Its companions `-webkit-box-orient` / `-webkit-line-clamp`
-* are NOT layout props we carry, so copying `display: -webkit-box` alone yields a
-* broken box: with no `-webkit-box-orient` it defaults to a HORIZONTAL old-flexbox
-* that collapses an empty bone child to zero width (invisible), and `overflow:
-* hidden` then reads as a blank placeholder with the next sibling riding up under
-* it. The idiom's only visible effect — clamping text to N lines — is already
-* captured in the text bone's measured (clamped) height, so the container just
-* needs to be a normal block. Map the legacy values to their modern flow
+* The legacy `-webkit-box` display family is the 2009 flexbox, used almost exclusively for the
+* `-webkit-line-clamp` truncation idiom (`display: -webkit-box; -webkit-box-orient: vertical;
+* -webkit-line-clamp: N; overflow: hidden`). Its companions `-webkit-box-orient` /
+* `-webkit-line-clamp` are NOT carried layout props, so copying `display: -webkit-box` alone yields
+* a broken box: with no `-webkit-box-orient` it defaults to a HORIZONTAL old-flexbox that collapses
+* an empty bone child to zero width (invisible), and `overflow: hidden` then reads as a blank
+* placeholder with the next sibling riding up under it. The idiom's only visible effect — clamping
+* text to N lines — is already captured in the text bone's measured (clamped) height, so the
+* container just needs to be a normal block. Map the legacy values to their modern flow
 * equivalents; every other display value passes through untouched.
 */
 const LEGACY_DISPLAY = {
@@ -382,20 +371,18 @@ function resolveVars(value, computed) {
 	return out;
 }
 /**
-* A non-nesting `var(--name[, fallback])` matcher used by the FREEZE: the
-* fallback group `[^()]*` deliberately stops at a nested paren, so a
-* `var(--a, var(--b))` is rewritten head-first (replacing `--a` re-exposes the
-* inner `var(--b)` for the next iteration). The freeze loops to a fixpoint, so
-* one-level-at-a-time is correct and keeps the regex simple.
+* A non-nesting `var(--name[, fallback])` matcher used by the FREEZE: the fallback group `[^()]*`
+* deliberately stops at a nested paren, so a `var(--a, var(--b))` is rewritten head-first
+* (replacing `--a` re-exposes the inner `var(--b)` for the next iteration). The freeze loops to a
+* fixpoint, so one-level-at-a-time is correct and keeps the regex simple.
 */
 const VAR_REF = /var\(\s*(--[\w-]+)\s*(?:,([^()]*))?\)/g;
 /**
-* The HEAD token name of EVERY `var(` in a value — both the top-level heads and
-* any head nested inside a fallback (`var(--a, var(--b))` → `--a`, `--b`). A
-* fallback branch is reached by the engine only when its head is undefined, but
-* a carried chain must stay self-contained whichever branch renders, so every
-* head is a reachability seed. Matching `var(\s*(--name)` globally catches all of
-* them in one pass regardless of nesting depth — simpler and more correct than a
+* The HEAD token name of EVERY `var(` in a value — both the top-level heads and any head nested
+* inside a fallback (`var(--a, var(--b))` → `--a`, `--b`). A fallback branch is reached by the
+* engine only when its head is undefined, but a carried chain must stay self-contained whichever
+* branch renders, so every head is a reachability seed. Matching `var(\s*(--name)` globally catches
+* all of them in one pass regardless of nesting depth — simpler and more correct than a
 * fallback-recursing regex (whose `[^()]*` cannot see into a nested `var()`).
 */
 const VAR_HEAD = /var\(\s*(--[\w-]+)/g;
@@ -409,28 +396,24 @@ function referencedTokens(value) {
 	return out;
 }
 /**
-* Freeze ONLY the `var()` references whose token was NOT carried (ADR 0019 §1).
-* A decl produced in carry mode keeps its raw `var(--x, …)` text; once the caller
-* knows which tokens it actually emitted on the plate (`carried`), this resolves
-* every leftover reference to its capture-time value — the irreducible freeze for
-* a constant token, an un-anchorable wrapper token (Q5), or a genuinely
-* unreadable one. A reference to a carried token is left INTACT so the plate's own
-* definition drives it. The result is self-contained by construction: after this
-* runs, every surviving `var()` names a token the plate defines.
+* Freeze ONLY the `var()` references whose token was NOT carried (ADR 0019 §1). A decl produced in
+* carry mode keeps its raw `var(--x, …)` text; once the caller knows which tokens it actually
+* emitted on the plate (`carried`), this resolves every leftover reference to its capture-time
+* value — the irreducible freeze for a constant token, an un-anchorable wrapper token, or a
+* genuinely unreadable one. A reference to a carried token is left INTACT so the plate's own
+* definition drives it. The result is self-contained by construction: after this runs, every
+* surviving `var()` names a token the plate defines.
 *
-* A leftover token resolves in this order: the caller's `frozen` map (the token's
-* winning author value, read straight from the CSSOM) FIRST, then the matched
-* element's `computed` style, then the var()'s own fallback. The author-value
-* path is authoritative and independent of computed-style inheritance — computed
-* style cannot always resolve a deeply-inherited custom property (and happy-dom
-* never does), so without it a constant token could dangle and break
-* self-containment. The `frozen` map already carries the cascade winner, so it is
-* preferred where present.
+* A leftover token resolves in this order: the caller's `frozen` map (the token's winning author
+* value, read straight from the CSSOM) FIRST, then the matched element's `computed` style, then the
+* var()'s own fallback. The author-value path is authoritative and independent of computed-style
+* inheritance — computed style cannot always resolve a deeply-inherited custom property (and
+* happy-dom never does), so without it a constant token could dangle and break self-containment.
+* The `frozen` map already carries the cascade winner, so it is preferred where present.
 *
-* Operates on whole `prop: value` decl strings (splitting on the FIRST colon, so
-* a `calc()`/`url()` value with colons is untouched) and re-runs `fluidTracks`
-* on a frozen grid track list — a token that froze to px-only tracks falls back
-* to the heuristic, the documented last resort.
+* Operates on whole `prop: value` decl strings (splitting on the FIRST colon, so a `calc()`/`url()`
+* value with colons is untouched) and re-runs `fluidTracks` on a frozen grid track list — a token
+* that froze to px-only tracks falls back to the heuristic, the documented last resort.
 */
 function freezeUncarriedVars(decls, carried, computed, frozen) {
 	return decls.map((decl) => {
@@ -456,26 +439,24 @@ function freezeUncarriedVars(decls, carried, computed, frozen) {
 	});
 }
 /**
-* A grid track list that is only `px` lengths is a frozen computed value —
-* authors write `fr`/`%`/`minmax`/`auto`, not sub-pixel tracks, so this is
-* almost always a var()-driven `grid` shorthand the engine dropped, leaving us
-* the resolved computed track sizes. Frozen px locks the grid to the capture
-* width (off-centre at any other size); we can't recover the author value, so we
-* reconstruct a responsive one. Already-fluid lists (fr/%/minmax/repeat/auto/…)
-* pass through untouched.
+* A grid track list that is only `px` lengths is a frozen computed value — authors write
+* `fr`/`%`/`minmax`/`auto`, not sub-pixel tracks, so this is almost always a var()-driven `grid`
+* shorthand the engine dropped, leaving us the resolved computed track sizes. Frozen px locks the
+* grid to the capture width (off-centre at any other size); the author value is unrecoverable, so a
+* responsive one is reconstructed. Already-fluid lists (fr/%/minmax/repeat/auto/…) pass through
+* untouched.
 *
-*  - Rows follow their content in a skeleton (the bones set the height), so a
-*    frozen row list becomes `auto` tracks.
-*  - Columns are almost always a centred layout: a wide content track flanked by
-*    gutters. Make the gutters flexible and equal (`1fr`) so the grid recentres
-*    at any width — this also erases the scrollbar-width asymmetry the capture
-*    picked up — and cap the content track(s) at the captured size
-*    (`minmax(0, px)`) so they shrink on narrow viewports but never overgrow. A
-*    uniform list (no track ≥2× the others — e.g. an even `repeat(n, 1fr)`) has
-*    no gutters, so every track becomes `1fr`.
+* - Rows follow their content in a skeleton (the bones set the height), so a frozen row list becomes
+*   `auto` tracks.
+* - Columns are almost always a centred layout: a wide content track flanked by gutters. Make the
+*   gutters flexible and equal (`1fr`) so the grid recentres at any width — this also erases the
+*   scrollbar-width asymmetry the capture picked up — and cap the content track(s) at the captured
+*   size (`minmax(0, px)`) so they shrink on narrow viewports but never overgrow. A uniform list
+*   (no track ≥2× the others — e.g. an even `repeat(n, 1fr)`) has no gutters, so every track
+*   becomes `1fr`.
 *
-* A single capture can't tell fixed tracks from flexible ones; the precise fix is
-* to diff track sizes across the capture-all widths (a later refinement).
+* A single capture can't tell fixed tracks from flexible ones; the precise fix is to diff track
+* sizes across the capture-all widths (deferred).
 */
 const PX_ONLY_TRACKS = /^\s*(?:-?[\d.]+px\s*)+$/;
 function fluidTracks(value, axis) {
@@ -488,19 +469,16 @@ function fluidTracks(value, axis) {
 	return tracks.map((t, i) => isContent[i] ? `minmax(0, ${t}px)` : "1fr").join(" ");
 }
 /**
-* Extract the layout-relevant declarations of a style block as `prop: value`
-* strings.
+* Extract the layout-relevant declarations of a style block as `prop: value` strings.
 *
-* Without `carry`, custom-property references are resolved against `computed`
-* (the matched element's computed style) and FROZEN to their capture-time value
-* — the legacy ADR 0005 path, unchanged.
+* Without `carry`, custom-property references are resolved against `computed` (the matched
+* element's computed style) and FROZEN to their capture-time value (the ADR 0005 freeze).
 *
-* With `carry` (ADR 0019 §1), a `var()` is KEPT RAW and its referenced token
-* names are recorded into `carry.referenced`; the caller resolves the
-* carry-vs-freeze decision globally (it alone sees every cross-sheet definition)
-* and runs `freezeUncarriedVars` afterward to freeze only the leftovers. This is
-* how a responsive token survives as a live reference the plate's own emitted
-* definition drives, instead of being locked to one viewport's px.
+* With `carry` (ADR 0019 §1), a `var()` is KEPT RAW and its referenced token names are recorded
+* into `carry.referenced`; the caller resolves the carry-vs-freeze decision globally (it alone sees
+* every cross-sheet definition) and runs `freezeUncarriedVars` afterward to freeze only the
+* leftovers. A responsive token thus survives as a live reference the plate's own emitted
+* definition drives, instead of locking to one viewport's px.
 */
 function filterLayoutDecls(style, computed, carry) {
 	const out = [];
@@ -523,10 +501,9 @@ function filterLayoutDecls(style, computed, carry) {
 	return out;
 }
 /**
-* Approximate selector specificity packed as a single comparable number
-* (`a * 1e6 + b * 1e3 + c`). Good enough to order rewritten rules so the
-* original cascade winner still wins; known approximation: `:is()`/`:not()`
-* sum their arguments instead of taking the max.
+* Approximate selector specificity packed as a single comparable number (`a * 1e6 + b * 1e3 + c`).
+* Good enough to order rewritten rules so the original cascade winner still wins; known
+* approximation: `:is()`/`:not()` sum their arguments instead of taking the max.
 */
 function specificity(selector) {
 	let a = 0;
@@ -624,18 +601,17 @@ const BORDER_WIDTH_SATURATION = 4;
 const SPACING_SATURATION = 64;
 /** Type-scale (size×weight ratio over base) at which the axis saturates — ~a hero heading. */
 const TYPE_SCALE_SATURATION = 2.5;
-/** font-weight at/above which weight contributes its full bump to type-scale. */
+/** Font-weight at/above which weight contributes its full bump to type-scale. */
 const BOLD_WEIGHT = 700;
 /** The base (`normal`) font weight type-scale measures a bump against. */
 const NORMAL_WEIGHT = 400;
 /** The CSS default font-size (px) used when the context base is missing/degenerate. */
 const DEFAULT_FONT_SIZE = 16;
 /**
-* Axis weights for the convenience `score` blend. Contrast and size lead — a
-* skeleton bone exists because something PAINTS at some SIZE — with type-scale
-* and spacing as secondary modifiers. They sum to 1 so `score` stays in 0..1.
-* A per-axis consumer ignores this entirely; it exists only so a gate that wants
-* one number has a sensible default. Tunable.
+* Axis weights for the convenience `score` blend. Contrast and size lead — a skeleton bone exists
+* because something PAINTS at some SIZE — with type-scale and spacing as secondary modifiers. They
+* sum to 1 so `score` stays in 0..1. A per-axis consumer ignores this entirely; it exists only so a
+* gate that wants one number has a sensible default. Tunable.
 */
 const WEIGHTS = {
 	contrast: .35,
@@ -656,10 +632,10 @@ function pad$1(value) {
 	return Number.isFinite(n) ? n : 0;
 }
 /**
-* A ramp from `lo` to `hi`: 0 at/below `lo`, 1 at/above `hi`, linear between.
-* Every axis funnels its raw measurement through one of these so "more signal"
-* maps monotonically to a higher score and then saturates — past a point, a
-* thicker border or a bigger heading does not read as proportionally more salient.
+* A ramp from `lo` to `hi`: 0 at/below `lo`, 1 at/above `hi`, linear between. Every axis funnels
+* its raw measurement through one of these so "more signal" maps monotonically to a higher score
+* and then saturates — past a point, a thicker border or a bigger heading does not read as
+* proportionally more salient.
 */
 function ramp(value, lo, hi) {
 	if (hi <= lo) return value > lo ? 1 : 0;
@@ -730,7 +706,7 @@ function spacingAxis(cs) {
 }
 /** True when justify/align-content/items declares a non-default distribution. */
 function hasExplicitAlignment(cs) {
-	const inert = new Set([
+	const inert = /* @__PURE__ */ new Set([
 		"",
 		"normal",
 		"stretch",
@@ -761,14 +737,13 @@ function typeScaleAxis(cs, ctx) {
 	return ramp(sizeRatio * (1 + .3 * clamp01(((Number.isFinite(weightRaw) ? weightRaw : NORMAL_WEIGHT) - NORMAL_WEIGHT) / (BOLD_WEIGHT - NORMAL_WEIGHT))), 1, TYPE_SCALE_SATURATION);
 }
 /**
-* Score a node's visual relevance from the four measurable-visual signals
-* (ADR 0019 §4). Returns the per-axis vector plus a convenience blended scalar,
-* each in 0..1.
+* Score a node's visual relevance from the four measurable-visual signals (ADR 0019 §4). Returns
+* the per-axis vector plus a convenience blended scalar, each in 0..1.
 *
-* @param cs   the node's computed style (any `getPropertyValue` reader)
-* @param rect the node's rendered box (a `getBoundingClientRect`-shaped value)
-* @param ctx  the measured context: nearest painted ancestor background, base
-*             font-size, and reference (root/viewport) area
+* @param cs The node's computed style (any `getPropertyValue` reader)
+* @param rect The node's rendered box (a `getBoundingClientRect`-shaped value)
+* @param ctx The measured context: nearest painted ancestor background, base font-size, and
+*   reference (root/viewport) area
 */
 function salience(cs, rect, ctx) {
 	const contrast = contrastAxis(cs, ctx);
@@ -808,11 +783,10 @@ function createDiagnostics() {
 	};
 }
 /**
-* Build a single diagnostic record with its canonical message, for callers
-* outside the walk that surface a diagnostic directly (e.g. the client mapping
-* `CaptureTooLargeError`, or the server reporting an invalid committed plate).
-* Uses the same message table as the collector so the text is identical
-* everywhere. `detail` must never carry user CSS or captured text.
+* Build a single diagnostic record with its canonical message, for callers outside the walk that
+* surface a diagnostic directly (e.g. the client mapping `CaptureTooLargeError`, or the server
+* reporting an invalid committed plate). Uses the same message table as the collector so the text
+* is identical everywhere. `detail` must never carry user CSS or captured text.
 */
 function makeDiagnostic(code, options) {
 	return {
@@ -823,10 +797,9 @@ function makeDiagnostic(code, options) {
 	};
 }
 /**
-* The human-readable message per code, shared verbatim by browser and server so
-* their text cannot drift. Messages describe the omission and its fidelity
-* cost; none echoes user CSS or captured text. `formatDiagnostic` appends the
-* aggregate count and any short detail.
+* The human-readable message per code, shared verbatim by browser and server so their text cannot
+* drift. Messages describe the omission and its fidelity cost; none echoes user CSS or captured
+* text. `formatDiagnostic` appends the aggregate count and any short detail.
 */
 const DIAGNOSTIC_MESSAGES = {
 	"unreadable-stylesheet": "could not read a stylesheet (likely cross-origin); rules from it were not captured",
@@ -841,11 +814,10 @@ const DIAGNOSTIC_MESSAGES = {
 	"invalid-plate-file": "a committed plate file could not be read (corrupt JSON, wrong shape, or a version mismatch) and was ignored"
 };
 /**
-* The single shared formatter. Renders one diagnostic to a stable one-line
-* string used IDENTICALLY by the browser console and the Vite server output, so
-* the two can never disagree. Shape: `<message> (<count>)[: <detail>]`. Count is
-* omitted when 1 or absent; detail is appended only when present and is never
-* user content.
+* The single shared formatter. Renders one diagnostic to a stable one-line string used IDENTICALLY
+* by the browser console and the Vite server output, so the two can never disagree. Shape:
+* `<message> (<count>)[: <detail>]`. Count is omitted when 1 or absent; detail is appended only
+* when present and is never user content.
 */
 function formatDiagnostic(diagnostic) {
 	const count = diagnostic.count !== void 0 && diagnostic.count > 1 ? ` (${diagnostic.count})` : "";
@@ -859,14 +831,12 @@ function diagnosticsHeader(name) {
 //#endregion
 //#region src/style-cache.ts
 /**
-* A per-capture memo of `getComputedStyle(el)` keyed by element, scoped to ONE
-* synchronous capture (capture performance plan, piece 5). The walk reads each
-* entry node's own style through here, and the ancestor-walking helpers
-* (contrast, line-height, clipping) memoize the parents they climb. A
-* `CSSStyleDeclaration` is a live view, so this WeakMap lives only as long as
-* the single capture that built it and is then dropped — it is NEVER cached
-* across captures or time (a stored style would silently go stale; the plan
-* forbids it). `get` lazily computes and stores on first lookup.
+* A per-capture memo of `getComputedStyle(el)` keyed by element, scoped to ONE synchronous capture
+* (ADR 0025). The walk reads each entry node's own style through here, and the ancestor-walking
+* helpers (contrast, line-height, clipping) memoize the parents they climb. A `CSSStyleDeclaration`
+* is a live view, so this WeakMap lives only as long as the single capture that built it and is
+* then dropped — it is NEVER cached across captures or time (a stored style would silently go
+* stale; ADR 0025 forbids it). `get` lazily computes and stores on first lookup.
 */
 var StyleCache = class {
 	#win;
@@ -889,11 +859,10 @@ function isInlineish(display) {
 	return display === "inline" || display.startsWith("inline-");
 }
 /**
-* Does this container lay its children out in normal inline/block FLOW — so its
-* inline-level children coalesce into one run (ADR 0021 §2) — versus flex / grid
-* / table, which blockify every child into its own Bone? Keyed on the formatting
-* context, not nesting depth: this is why two flex-column labels stay two Bones
-* while inline siblings in a block become one line.
+* Does this container lay its children out in normal inline/block FLOW — so its inline-level
+* children coalesce into one run (ADR 0021 §2) — versus flex / grid / table, which blockify every
+* child into its own Bone? Keyed on the formatting context, not nesting depth: this is why two
+* flex-column labels stay two Bones while inline siblings in a block become one line.
 */
 function establishesInlineFlow(display) {
 	return !/\b(flex|grid|table|ruby)\b/.test(display);
@@ -906,28 +875,27 @@ function pxValue(value) {
 	return /(?:^|\s)-?[\d.]+px$/.test(value.trim()) ? Number.parseFloat(value) : null;
 }
 //#endregion
-//#region src/passes.ts
+//#region src/distil.ts
 /**
-* An element at or below this opacity contributes no visible ink: opacity is not
-* inherited, but it composites the element AND its subtree as one group and then
-* multiplies that group to (near) nothing, so every descendant is hidden too.
-* Dropped like `display:none`/`visibility:hidden`. The small epsilon (not a
-* strict `=== 0`) also catches the `opacity: 0.001` visually-hidden idiom while
-* sparing genuinely faint-but-readable content. A missing/invalid value parses
-* to `NaN`, which fails the `<=` and is correctly kept.
+* An element at or below this opacity contributes no visible ink: opacity is not inherited, but it
+* composites the element AND its subtree as one group and then multiplies that group to (near)
+* nothing, so every descendant is hidden too. Dropped like `display:none`/`visibility:hidden`. The
+* small epsilon (not a strict `=== 0`) also catches the `opacity: 0.001` visually-hidden idiom
+* while sparing genuinely faint-but-readable content. A missing/invalid value parses to `NaN`,
+* which fails the `<=` and is correctly kept.
 */
 const INVISIBLE_OPACITY = .01;
 /**
-* Does this IR node read as ONE single-line text bar a glyph icon can fold into?
-* A bare `text` leaf, or a thin branch whose sole child is a `text` leaf (a
-* `<span>label</span>` blockified in a flex row). A `text-block` (multi-line) or
-* any structured branch does NOT — a glyph hugs one line.
+* Does this IR node read as ONE single-line text bar a glyph icon can fold into? A bare `text`
+* leaf, or a thin branch whose sole child is a `text` leaf (a `<span>label</span>` blockified in a
+* flex row). A `text-block` (multi-line) or any structured branch does NOT — a glyph hugs one
+* line.
 */
 function textLineUnitIR(kid) {
-	if (kid.kind === "text" && kid.kids.length === 0) return true;
+	if (kid.kind === "text-line" && kid.kids.length === 0) return true;
 	if (kid.kind === "container" && kid.kids.length === 1) {
 		const only = kid.kids[0];
-		return only !== void 0 && only.kind === "text" && only.kids.length === 0;
+		return only !== void 0 && only.kind === "text-line" && only.kids.length === 0;
 	}
 	return false;
 }
@@ -939,59 +907,52 @@ function boxGlyphGeometry(icon, text, lineHeight) {
 	return (icon.x >= text.x + text.width ? icon.x - (text.x + text.width) : text.x - (icon.x + icon.width)) <= lineHeight * .6;
 }
 /**
-* Is this text bar a multi-line BLOCK rather than a single LINE? Reads the bar's
-* `ink` snapshot — the clamped run box and the parent's resolved line-height the
-* walk recorded — and applies the SAME `height >= lineHeight × 1.5` threshold the
-* old in-walk `isMultiLineRun` used (ADR 0021 §4). An unresolved line-height (0)
-* reads as a single line, exactly as before.
+* Is this text bar a multi-line BLOCK rather than a single LINE? Reads the bar's `ink` snapshot
+* (the clamped run box and the parent's resolved line-height the walk recorded) and applies the
+* `height >= lineHeight × 1.5` threshold (ADR 0021 §4). An unresolved line-height (0) reads as a
+* single line.
 */
 function inkIsMultiLine(ink) {
 	const runHeight = ink.lineRects[0]?.height ?? 0;
 	return ink.lineHeight > 0 && runHeight >= ink.lineHeight * 1.5;
 }
 /**
-* MARK-INK — the classification pass (ADR 0022 invariant 5; capture-pipeline Phase
-* 3). It takes over the BONE-KIND assignment the measuring walk used to decide
-* inline, reading ONLY the IR snapshot (never the live DOM): `isMedia`, `paint`,
-* `ink`, and `style`. The walk now builds STRUCTURE + decls + the synthetic text
-* bars and leaves a PROVISIONAL kind; `markInk` finalizes the leaf kinds and folds
-* invisibility into a `dropped: { reason: 'invisible' }` annotation. Runs BEFORE
-* `foldGlyphRowsIR` (which reads `kind: 'media'` / `'text'`).
+* MARK-INK — the classification pass (ADR 0022 invariant 5). It owns BONE-KIND assignment, reading
+* ONLY the IR snapshot (never the live DOM): `isMedia`, `paint`, `ink`, and `style`. The walk
+* builds STRUCTURE + decls + the synthetic text bars and leaves a PROVISIONAL kind; `markInk`
+* finalizes the leaf kinds and folds invisibility into a `dropped: { reason: 'invisible' }`
+* annotation. Runs BEFORE `foldGlyphRowsIR` (which reads `kind: 'media'` / `'text-line'`).
+*
+* Per-node, the rules — UPGRADE-ONLY for the inferred kinds, so an explicit kind the walk set (a
+* `ctx.bone()` bone, the `@container` text-rep's `text-block` bone) is never downgraded:
+*
+* - A DECLARED bone (`markKind`, from `data-xr-bone-kind`; ADR 0018; ADR 0022 §5) → re-stamped a
+*   CHILDLESS bone of that kind: the walk descended normally (measuring the full subtree into the
+*   IR), and here every effective kid is marked `dropped: { reason: 'collapsed' }` and the node
+*   synthesizes its own leaf display+size, so `effectiveKids`/emit lower it to one bone. This
+*   pre-empts the inferred kinds below (a declared kind is authoritative) and shares the Absorb
+*   re-stamp's display/size synthesis;
+* - A text bar (`ink` present) → `text` (one baseline) or `text-block` (≥2);
+* - An empty/childless ELEMENT (`el !== null`, no raw kids) that is `isMedia` → `media`; else a
+*   `container` seed whose `paint.surface` paints → `box` (the empty-element painted-box-vs-spacer
+*   split, off `paint` instead of a live `hasVisibleBackground`); an explicit seed (media/box/text)
+*   is never overwritten, and a non-painted spacer is left as a container.
 *
-* Per-node, the rules — UPGRADE-ONLY for the inferred kinds, so an explicit kind the
-* walk set (a `ctx.bone()` bone, the `@container` text-rep's `text-block` bone) is
-* never downgraded:
-*   - a DECLARED bone (`markKind`, from `data-xr-bone-kind`; ADR 0018; ADR 0022 §5)
-*     → re-stamped a CHILDLESS bone of that kind: the walk descended normally
-*     (measuring the full subtree into the IR), and here every effective kid is
-*     marked `dropped: { reason: 'collapsed' }` and the node synthesizes its own
-*     leaf display+size, so `effectiveKids`/emit lower it to one bone. This pre-empts
-*     the inferred kinds below (a declared kind is authoritative) and shares the
-*     Absorb re-stamp's display/size synthesis;
-*   - a text bar (`ink` present) → `text` (one baseline) or `text-block` (≥2),
-*     the line-vs-block decision MOVED out of `textBar`;
-*   - an empty/childless ELEMENT (`el !== null`, no raw kids) that is `isMedia`
-*     → `media`; else a `container` seed whose `paint.surface` paints → `box`
-*     (the empty-element painted-box-vs-spacer split, off `paint` instead of a
-*     live `hasVisibleBackground`); an explicit seed (media/box/text) is never
-*     overwritten, and a non-painted spacer is left as a container.
+* Invisibility (ADR 0022 §4) is annotated `dropped: { reason: 'invisible' }`. The two CSS
+* mechanisms reach differently, and `markInk` models both off the snapshot, threading the inherited
+* context DOWN (Measure DESCENDS both; it skips only `display: none`):
 *
-* Invisibility (ADR 0022 §4) is annotated `dropped: { reason: 'invisible' }`. The
-* two CSS mechanisms reach differently, and `markInk` models both off the snapshot,
-* threading the inherited context DOWN (Measure now DESCENDS both — it skips only
-* `display: none`):
-*   - `opacity <= INVISIBLE_OPACITY` composites the element AND its whole subtree as
-*     one group and multiplies it to nothing — every descendant is hidden too and
-*     NOTHING below can re-show. The TOPMOST group-hidden node drops; `effectiveKids`
-*     lowers the whole subtree, so the descendants need no individual drop.
-*   - `visibility: hidden|collapse` is INHERITED but an ELEMENT descendant can
-*     override it (`visibility: visible` re-shows). A node is visibility-hidden when
-*     its own value hides it OR it inherits hidden and does not re-show; such a node
-*     drops ONLY when it has no surviving effective kid — a re-shown descendant keeps
-*     the bone-free ancestors alive so it survives. This fixes the latent bug where a
-*     hidden ancestor used to vanish a re-shown subtree. A synthetic text bar carries
-*     no own visibility (empty snapshot), so it correctly INHERITS its parent's.
-* Idempotent — never overwrites a prior drop (a glyph-folded icon keeps `folded`).
+* - `opacity <= INVISIBLE_OPACITY` composites the element AND its whole subtree as one group and
+*   multiplies it to nothing — every descendant is hidden too and NOTHING below can re-show. The
+*   TOPMOST group-hidden node drops; `effectiveKids` lowers the whole subtree, so the descendants
+*   need no individual drop.
+* - `visibility: hidden|collapse` is INHERITED but an ELEMENT descendant can override it
+*   (`visibility: visible` re-shows). A node is visibility-hidden when its own value hides it OR it
+*   inherits hidden and does not re-show; such a node drops ONLY when it has no surviving effective
+*   kid — a re-shown descendant keeps the bone-free ancestors alive so it survives; a hidden
+*   ancestor can never vanish a re-shown subtree. A synthetic text bar carries no own visibility
+*   (empty snapshot), so it correctly INHERITS its parent's. Idempotent — never overwrites a prior
+*   drop (a glyph-folded icon keeps `folded`).
 *
 * Pure: reads only the IR. Tested with a hand-built IR (markInk.test.ts).
 */
@@ -1031,7 +992,7 @@ function markInk(node, inherited = NOT_HIDDEN) {
 		return;
 	}
 	if (node.ink) {
-		node.kind = inkIsMultiLine(node.ink) ? "text-block" : "text";
+		node.kind = inkIsMultiLine(node.ink) ? "text-block" : "text-line";
 		return;
 	}
 	if (node.el !== null && node.kids.length === 0) {
@@ -1061,49 +1022,46 @@ function markInk(node, inherited = NOT_HIDDEN) {
 	}
 }
 /**
-* The Salience contrast axis at/above which a NON-fill surface (a contrasting
-* border or a box-shadow) is strong enough to read as one Bone on its own —
-* Absorb's trigger for the cases the contrasting fill never covered. Set so an
-* INTENTIONAL, visible surface clears it and an incidental hairline does not: a
-* box-shadow scores 1; a contrasting border needs ~2px (the contrast axis ramps
-* border width 0→`BORDER_WIDTH_SATURATION`=4px, so 2px → 0.5) AND an opaque,
-* page-contrasting colour. Conservative by design — a 1px same-as-page divider
-* scores ~0 and is left as a container, never over-absorbed. Tunable.
+* The Salience contrast axis at/above which a NON-fill surface (a contrasting border or a
+* box-shadow) is strong enough to read as one Bone on its own — Absorb's trigger for the cases the
+* contrasting fill never covered. Set so an INTENTIONAL, visible surface clears it and an
+* incidental hairline does not: a box-shadow scores 1; a contrasting border needs ~2px (the
+* contrast axis ramps border width 0→`BORDER_WIDTH_SATURATION`=4px, so 2px → 0.5) AND an opaque,
+* page-contrasting colour. Conservative by design — a 1px same-as-page divider scores ~0 and is
+* left as a container, never over-absorbed. Tunable.
 */
 const ABSORB_CONTRAST_MIN = .5;
 /**
-* Does this node's SURFACE absorb its label content into one Bone (ADR 0021 §3)?
-* PURE — reads ONLY the snapshot Measure resolved at build time (3a), never the
-* DOM. Two additive paths, neither weakening the other:
+* Does this node's SURFACE absorb its label content into one Bone (ADR 0021 §3)? PURE — reads ONLY
+* the snapshot Measure resolved at build time, never the DOM. Two additive paths, neither weakening
+* the other:
 *
-*  - FILL — `paint.contrastingFill`, the resolved `hasContrastingFill` boolean, so
-*    every filled control that collapsed before collapses identically.
-*  - BORDER / BOX-SHADOW — the resolved Salience contrast axis (graded) at/above
-*    `ABSORB_CONTRAST_MIN`. The axis is the MAX of fill/border/shadow, so this path
-*    only ever ADDS surfaces the fill boolean missed: a card outlined or lifted off
-*    the page whose content is label-only is itself the visual.
+* - FILL — `paint.contrastingFill`, the resolved `hasContrastingFill` boolean: a filled control
+*   collapses to one Bone.
+* - BORDER / BOX-SHADOW — the resolved Salience contrast axis (graded) at/above
+*   `ABSORB_CONTRAST_MIN`. The axis is the MAX of fill/border/shadow, so this path only ever ADDS
+*   surfaces the fill boolean missed: a card outlined or lifted off the page whose content is
+*   label-only is itself the visual.
 *
-* Conservative: a node with neither a contrasting fill NOR a strong border/shadow
-* surface returns false and keeps its children. An entry-less node (root/stitch/
-* synthetic bar) has no `paint`/`salience` snapshot, so it never absorbs.
+* Conservative: a node with neither a contrasting fill NOR a strong border/shadow surface returns
+* false and keeps its children. An entry-less node (root/stitch/ synthetic bar) has no
+* `paint`/`salience` snapshot, so it never absorbs.
 */
 function surfaceAbsorbs(node) {
 	if (node.paint?.contrastingFill) return true;
 	return node.salience !== void 0 && node.salience.contrast >= ABSORB_CONTRAST_MIN;
 }
 /**
-* Does this node's EFFECTIVE content reduce to a single label/run and nothing else
-* (ADR 0021 §3)? PURE IR predicate over `effectiveKids`/`effectiveKind` — never the
-* DOM. Every effective kid must read as a text label drawing one bone with no
-* independent structure:
-*   - a bare text leaf (`text` / `text-block`), incl. a glyph-fold survivor (an
-*     effective `text` bar);
-*   - a thin wrapper whose sole effective kid is itself a single text leaf (a
-*     `<span>label</span>` blockified in a flex/grid control, or the `@container`
-*     text-rep wrapper around one `text-block` bone).
-* A SECOND distinct shape (a `box`, a non-folded sibling structure), any REPLACED
-* MEDIA (`media` is never a swallowing surface, ADR 0021 §3), or a Stitch makes the
-* node a container/frame — draw the parts, keep the surface as a frame.
+* Does this node's EFFECTIVE content reduce to a single label/run and nothing else (ADR 0021 §3)?
+* PURE IR predicate over `effectiveKids`/`effectiveKind` — never the DOM. Every effective kid must
+* read as a text label drawing one bone with no independent structure:
+*
+* - A bare text leaf (`text` / `text-block`), incl. a glyph-fold survivor (an effective `text` bar);
+* - A thin wrapper whose sole effective kid is itself a single text leaf (a `<span>label</span>`
+*   blockified in a flex/grid control, or the `@container` text-rep wrapper around one `text-block`
+*   bone). A SECOND distinct shape (a `box`, a non-folded sibling structure), any REPLACED MEDIA
+*   (`media` is never a swallowing surface, ADR 0021 §3), or a Stitch makes the node a
+*   container/frame — draw the parts, keep the surface as a frame.
 */
 function isLabelContent(node) {
 	return effectiveKids(node).every(isLabelUnit);
@@ -1111,43 +1069,37 @@ function isLabelContent(node) {
 /** A single effective kid that reads as one text label (no media, no distinct shape, no stitch). */
 function isLabelUnit(node) {
 	const kind = effectiveKind(node);
-	if (kind === "text" || kind === "text-block") return true;
+	if (kind === "text-line" || kind === "text-block") return true;
 	if (kind !== "container") return false;
 	const kids = effectiveKids(node);
 	const only = kids[0];
 	if (kids.length !== 1 || only === void 0) return false;
 	const onlyKind = effectiveKind(only);
-	return (onlyKind === "text" || onlyKind === "text-block") && effectiveKids(only).length === 0;
+	return (onlyKind === "text-line" || onlyKind === "text-block") && effectiveKids(only).length === 0;
 }
 const NOT_HIDDEN = {
 	groupHidden: false,
 	visHidden: false
 };
 /**
-* Fold a glyph-sized icon Bone into an adjacent single-line text Bone — the
-* geometry-driven group pass (ADR 0021 §2, "row anything"), now run over the built
-* IR instead of the live DOM via `kidEls`. For each NON-FLOW parent (flex / grid /
-* table / ruby — normal flow already folds its icon into the run during the walk),
-* a `media` kid that hugs a neighbouring element-backed text-line on the same row
-* (`boxGlyphGeometry` over the snapshotted boxes) folds WITH that neighbour into one
-* text-line bar sized to their union. A bigger or gutter-gapped icon fails the
-* geometry and stays its own Bone.
+* Fold a glyph-sized icon Bone into an adjacent single-line text Bone — the geometry-driven group
+* pass (ADR 0021 §2, "row anything"), run over the built IR. For each NON-FLOW parent (flex / grid
+* / table / ruby — normal flow already folds its icon into the run during the walk), a `media` kid
+* that hugs a neighbouring element-backed text-line on the same row (`boxGlyphGeometry` over the
+* snapshotted boxes) folds WITH that neighbour into one text-line bar sized to their union. A
+* bigger or gutter-gapped icon fails the geometry and stays its own Bone.
 *
-* ANNOTATE-ONLY (ADR 0022 §4): the pass NEVER restructures `kids`. For each match it
-* SETS `folded` on the SURVIVING text unit — the effective bone box (their union) and
-* the synthesized inline-block + width/height decls the old merged bar carried — and
-* marks the absorbed icon `dropped: { reason: 'folded' }`. The surviving node keeps
-* its `id` and its place in `bundle.nodes`, so `emit` projects the same single text-bar leaf (icon gone,
-* unit as a `text` leaf sized to the union) the old destructive merge produced; every
-* downstream pass reads the union via `boneBox(node)` and the leaf shape via the
-* effective-node accessors (`effectiveKind`/`effectiveKids`), so a folded node behaves
-* exactly like the old synthetic bar without the tree surgery.
+* ANNOTATE-ONLY (ADR 0022 §4): the pass NEVER restructures `kids`. For each match it SETS `folded`
+* on the SURVIVING text unit — the effective bone box (their union) and the synthesized
+* inline-block + width/height decls of the bar — and marks the absorbed icon `dropped: { reason:
+* 'folded' }`. The surviving node keeps its `id` and its place in `bundle.nodes`, so `emit`
+* projects one text-bar leaf (icon gone, unit as a `text` leaf sized to the union); every
+* downstream pass reads the union via `boneBox(node)` and the leaf shape via the effective-node
+* accessors (`effectiveKind`/`effectiveKids`).
 *
-* Scan/skip semantics mirror the old destructive pass: an icon prefers its LEFT
-* neighbour (`i - 1` before `i + 1`); a dropped (already-folded) icon never folds
-* again; and a folded unit is never re-used as another icon's neighbour (the old
-* merge replaced the unit with an `el: null` bar, which the `el !== null` guard
-* rejected — `folded` is the explicit mirror, since the node is left in place here).
+* Scan/skip semantics: an icon prefers its LEFT neighbour (`i - 1` before `i + 1`); a dropped
+* (already-folded) icon never folds again; and a folded unit is never re-used as another icon's
+* neighbour.
 */
 function foldGlyphRowsIR(node) {
 	for (const kid of node.kids) foldGlyphRowsIR(kid);
@@ -1184,29 +1136,22 @@ function foldGlyphRowsIR(node) {
 	}
 }
 /**
-* Flatten passthrough wrapper chains (capture-pipeline Phase 2, per-View). A
-* layout-only container — containers paint no Bone (only leaves carry `xr-leaf`),
-* a single child, its box coincident with that child, no margin or positional
-* offset of its own — contributes nothing the child does not already produce.
-* Promoting the child into a normal-flow grandparent drops the wrapper
-* Bone-free and position-faithful, shrinking the plate.
+* FLATTEN (ADR 0022, per-View): collapse passthrough wrapper chains. A layout-only container —
+* containers paint no Bone (only leaves carry `xr-leaf`), a single child, its box coincident with
+* that child, no margin or positional offset of its own — contributes nothing the child does not
+* already produce. Promoting the child into a normal-flow grandparent drops the wrapper Bone-free
+* and position-faithful, shrinking the plate.
 *
-* Annotate-only (ADR 0022 §4): the pass NEVER restructures the tree. It SETS
-* `flattened = true` on each passthrough wrapper that should be spliced; Serialize
-* (`emit`, ir.ts) is the sole structural mutation — it omits a `flattened` node and
-* hoists its kids into the parent's slot. The wrapper stays in the IR with its
-* geometry/decls, so later passes and diagnostics still see it.
+* Annotate-only (ADR 0022 §4): the pass NEVER restructures the tree. It SETS `flattened = true` on
+* each passthrough wrapper that should be spliced; Serialize (`emit`, ir.ts) is the sole structural
+* mutation — it omits a `flattened` node and hoists its kids into the parent's slot. The wrapper
+* stays in the IR with its geometry/decls, so later passes and diagnostics still see it.
 *
-* Bottom-up so a chain collapses to a fixpoint
-* (`<div><div><div>x</div></div></div>` → one node: every wrapper in the chain is
-* marked). Only flattens wrappers under a normal-flow parent — a flex/grid item's
-* slot needs the wrapper's flex sizing, which we do not transfer — and never
-* crosses a Stitch (opaque, ADR 0006). The conditions in `isPassthroughWrapper` are
-* what keep it position-faithful. The marked set is the wrappers the old
-* destructive Flatten removed via `collapseWrapperChain` — same predicate, gate,
-* and chain walk (modulo the per-hop 1px coincidence tolerance, evaluated against
-* the unmutated neighbor rather than the collapsed survivor; transitive within
-* tolerance, so the set agrees in every realistic chain — see `markWrapperChain`).
+* Bottom-up so a chain collapses to a fixpoint (`<div><div><div>x</div></div></div>` → one node:
+* every wrapper in the chain is marked). Only flattens wrappers under a normal-flow parent — a
+* flex/grid item's slot needs the wrapper's flex sizing, which the splice does not transfer — and
+* never crosses a Stitch (opaque, ADR 0006). The conditions in `isPassthroughWrapper` are what keep
+* it position-faithful.
 */
 function flattenIR(node) {
 	if (node.kind === "stitch") return;
@@ -1214,14 +1159,10 @@ function flattenIR(node) {
 	if (establishesInlineFlow(node.style.display)) for (const kid of node.kids) markWrapperChain(kid);
 }
 /**
-* Mark every passthrough wrapper in the chain rooted at `node` `flattened`, down to
-* the first node that survives — the set the old `collapseWrapperChain` removed (it
-* replaced the kid with that first survivor, dropping every wrapper it walked
-* past). One difference is immaterial: this walks the unmutated chain, so each
-* coincidence check is wrapper-vs-its-own-child (the old code, walking the already
-* collapsed kids, checked wrapper-vs-survivor). Coincidence is transitive within
-* the 1px tolerance, so the marked set agrees in every realistic chain. Sets fields
-* only; never touches `kids`.
+* Mark every passthrough wrapper in the chain rooted at `node` `flattened`, down to the first node
+* that survives. Walks the unmutated chain, so each coincidence check is wrapper-vs-its-own-child;
+* coincidence is transitive within the 1px tolerance, so a whole chain marks consistently. Sets
+* fields only; never touches `kids`.
 */
 function markWrapperChain(node) {
 	let cursor = node;
@@ -1233,11 +1174,10 @@ function markWrapperChain(node) {
 	}
 }
 /**
-* A container the skeleton can drop without moving anything: one child, its box
-* coincident with the child (so no padding/border insetting it and no size of its
-* own), no margin and `position: static` with no `transform` (so no offset the
-* promoted child would lose), and no carried token def anchored to it (a
-* descendant's `var()` reads it). A stitch child has no box, so it is never
+* A container the skeleton can drop without moving anything: one child, its box coincident with the
+* child (so no padding/border insetting it and no size of its own), no margin and `position:
+* static` with no `transform` (so no offset the promoted child would lose), and no carried token
+* def anchored to it (a descendant's `var()` reads it). A stitch child has no box, so it is never
 * coincident — stitch wrappers are conservatively kept.
 */
 function isPassthroughWrapper(node) {
@@ -1262,28 +1202,25 @@ function marginIsZero(margin) {
 	return margin.split(/\s+/).every((v) => v === "0px" || v === "0");
 }
 /**
-* Superset (capture-pipeline Phase 2, per-View). When a Bone's box sits wholly
-* inside a SOLID Bone's box, the enclosing Bone *supersets* it — it paints the
-* same area, so the two render as one and the layered "bone-over-bone" look the
-* inner one would add is barely perceptible. Annotate the inner Bone (the
-* `subset`) `dropped` so `emit` lowers it out, then prune any container the drop
-* leaves empty (`orphaned`).
+* SUPERSET (ADR 0022, per-View). When a Bone's box sits wholly inside a SOLID Bone's box, the
+* enclosing Bone _supersets_ it — it paints the same area, so the two render as one and the layered
+* "bone-over-bone" look the inner one would add is barely perceptible. Annotate the inner Bone (the
+* `subset`) `dropped` so `emit` lowers it out, then prune any container the drop leaves empty
+* (`orphaned`).
 *
-* Order / opacity / stacking are IRRELEVANT — it is a set union, so the superset
-* always wins regardless of which paints on top. The subset can be ANY kind (a
-* text line / block on a solid surface is the same redundant bone-over-bone, so
-* it goes too); only the SUPERSET must be SOLID — a gappy `text` Bone or a
-* paint-less branch never supersets, since the union must actually fill the area.
-* Decided by geometry, global within the plate (an overlay nested in one subtree
-* can superset media in another); a stitch has no box, so it neither supersets nor
-* is a subset. Non-destructive — the node stays in the IR (see `IRNode.dropped`).
-* Runs last of the IR passes.
+* Order / opacity / stacking are IRRELEVANT — it is a set union, so the superset always wins
+* regardless of which paints on top. The subset can be ANY kind (a text line / block on a solid
+* surface is the same redundant bone-over-bone, so it goes too); only the SUPERSET must be SOLID —
+* a gappy `text` Bone or a paint-less branch never supersets, since the union must actually fill
+* the area. Decided by geometry, global within the plate (an overlay nested in one subtree can
+* superset media in another); a stitch has no box, so it neither supersets nor is a subset.
+* Non-destructive — the node stays in the IR (see `IRNode.dropped`). Runs last of the IR passes.
 *
-* WATCH IN QA: a large solid Bone supersets ANY bone inside it — intended for a
-* filled card collapsing its on-surface lines/badges, but a full-bleed background
-* `<img>` would also swallow a button/CTA or headline laid on it. A white/outline
-* card stays a paint-less container, so its content is kept; only a CONTRASTING
-* (bone-producing) surface supersets. If meaningful content vanishes, add a guard.
+* WATCH IN QA: a large solid Bone supersets ANY bone inside it — intended for a filled card
+* collapsing its on-surface lines/badges, but a full-bleed background `<img>` would also swallow a
+* button/CTA or headline laid on it. A white/outline card stays a paint-less container, so its
+* content is kept; only a CONTRASTING (bone-producing) surface supersets. If meaningful content
+* vanishes, add a guard.
 */
 function supersetIR(root, diagnostics) {
 	const leaves = [];
@@ -1306,13 +1243,12 @@ function supersetIR(root, diagnostics) {
 	pruneEmptyBranches(root);
 }
 /**
-* Gather every leaf with its edges (any kind — all are cullable). A leaf without
-* its own box falls back to its nearest box-bearing ancestor's box: a multi-line
-* `text-block` reflow bone is created boxless (it sizes via `@container` bands,
-* not a rect), but its rendered extent IS its ancestor element's box, so without
-* this fallback an overlay caption that wrapped to a `text-block` would never be
-* recognized as contained. A SOLID (`box`/`media`) bone never falls back: it can
-* only be a container if it truly paints that rect, so a boxless solid is omitted.
+* Gather every leaf with its edges (any kind — all are droppable). A leaf without its own box falls
+* back to its nearest box-bearing ancestor's box: a multi-line `text-block` reflow bone is created
+* boxless (it sizes via `@container` bands, not a rect), but its rendered extent IS its ancestor
+* element's box, so without this fallback an overlay caption that wrapped to a `text-block` would
+* never be recognized as contained. A SOLID (`box`/`media`) bone never falls back: it can only be a
+* container if it truly paints that rect, so a boxless solid is omitted.
 */
 function collectLeaves(node, out, inherited) {
 	const own = edgesOf(node);
@@ -1328,17 +1264,16 @@ function collectLeaves(node, out, inherited) {
 }
 /** A painted leaf (carries a bone): `box`/`media`/`text`/`text-block`. */
 function isLeaf(kind) {
-	return kind === "box" || kind === "media" || kind === "text" || kind === "text-block";
+	return kind === "box" || kind === "media" || kind === "text-line" || kind === "text-block";
 }
 /** A filled bone that paints its whole rect — `box`/`media`. Only these may be the container. */
 function isSolidLeaf(kind) {
 	return kind === "box" || kind === "media";
 }
 /**
-* A node's EFFECTIVE bone box as edges, or null if missing/degenerate (0-area). Reads
-* `boneBox` (ADR 0022 invariant 3), so a glyph-fold survivor reports its `folded.box`
-* (the icon+text union) instead of its raw text box — exactly the rect the old
-* synthetic merged bar had.
+* A node's EFFECTIVE bone box as edges, or null if missing/degenerate (0-area). Reads `boneBox`
+* (ADR 0022 invariant 3), so a glyph-fold survivor reports its `folded.box` (the icon+text union)
+* instead of its raw text box.
 */
 function edgesOf(node) {
 	const b = boneBox(node);
@@ -1355,10 +1290,10 @@ function coversFully(outer, inner) {
 	return outer.left <= inner.left + 1 && outer.top <= inner.top + 1 && outer.right >= inner.right - 1 && outer.bottom >= inner.bottom - 1;
 }
 /**
-* After Superset, drop any container it emptied — a container whose every child
-* is now dropped paints nothing and adds only dead structure. Bottom-up, so an
-* emptied parent propagates up its chain. Skips originally-empty containers (no
-* kids — other passes own those) and never drops the root.
+* After Superset, drop any container it emptied — a container whose every child is now dropped
+* paints nothing and adds only dead structure. Bottom-up, so an emptied parent propagates up its
+* chain. Skips originally-empty containers (no kids — other passes own those) and never drops the
+* root.
 */
 function pruneEmptyBranches(node) {
 	for (const kid of node.kids) pruneEmptyBranches(kid);
@@ -1366,70 +1301,61 @@ function pruneEmptyBranches(node) {
 	if (node.kids.every((kid) => kid.dropped !== void 0)) node.dropped = { reason: "orphaned" };
 }
 /**
-* Crop's ONLY knob: a multiplier on a clipping context's visible bottom, so the
-* fold sits a half-context BELOW the visible edge. It covers render-time reflow to
-* a taller viewport/container (ADR 0004) — the captured fold is a width-dependent,
-* render-time line, so this buffer keeps it deliberately conservative. The buffer
-* is applied ONLY at the final per-leaf compare, never accumulated into the clip
-* bottom threaded to children, so it never compounds across nesting levels.
+* Crop's ONLY knob: a multiplier on a clipping context's visible bottom, so the fold sits a
+* half-context BELOW the visible edge. It covers render-time reflow to a taller viewport/container
+* (ADR 0004) — the captured fold is a width-dependent, render-time line, so this buffer keeps it
+* deliberately conservative. The buffer is applied ONLY at the final per-leaf compare, never
+* accumulated into the clip bottom threaded to children, so it never compounds across nesting
+* levels.
 */
 const CROP_BUFFER = 1.5;
 /**
-* CROP — Phase-2 past-the-fold drop (capture-pipeline Phase 2, per-View). 2D: drops
-* every Bone whose box sits past the FOLD on EITHER axis — its TOP below the visible
-* BOTTOM, or its LEFT past the visible RIGHT edge, of that Bone's NEAREST CLIPPING
-* CONTEXT (a vertically- OR horizontally-scrolling / overflow-clipping ancestor, or
-* the viewport as the base case) — then orphan-prunes the emptied containers. The
-* horizontal axis closes the off-screen-RIGHT carousel-card case Template cannot
+* CROP — the past-the-fold drop (ADR 0022, per-View). 2D: drops every Bone whose box sits past the
+* FOLD on EITHER axis — its TOP below the visible BOTTOM, or its LEFT past the visible RIGHT edge,
+* of that Bone's NEAREST CLIPPING CONTEXT (a vertically- OR horizontally-scrolling /
+* overflow-clipping ancestor, or the viewport as the base case) — then orphan-prunes the emptied
+* containers. The horizontal axis closes the off-screen-RIGHT carousel-card case Template cannot
 * dedup (a single long run past its scroller's clip).
 *
-* - **No spacer.** Nothing reserves the dropped extent; the skeleton simply ends
-*   at the fold.
-* - **Why no CLS.** A dropped Bone was off-screen (below the viewport fold, or right
-*   of it) or inside a scroll/overflow container past its clip — never visible at
-*   capture. When real content lands it just grows the scroll height/width (or, for
-*   `overflow:hidden`/`clip`, is never visible at all); off-screen / clipped shifts
-*   do not score CLS, so the drop is layout-shift-free.
-* - **Reflow caveat (ADR 0004).** The fold is a render-time, width-dependent line
-*   (text rewraps at the render width, not the capture width), so the capture-time
-*   fold is conservative via `CROP_BUFFER`; a viewport / container larger than the
-*   one captured briefly shows blank past the fold until content fills — transient,
-*   no shift.
-* - **LTR-first; RTL a known limit.** The horizontal fold drops content past the
-*   RIGHT edge (the off-screen direction in LTR). In an RTL carousel the off-screen
-*   cards sit to the LEFT, so the right-edge fold does not catch them — an accepted
-*   known limit (the base-case viewport fold still drops anything genuinely right of
-*   `innerWidth`).
-* - **Per-View.** Views are independent and breakpoint-gated (ADR 0004); each
-*   carries its own folds (`viewportHeight`/`viewportWidth` = that View's
-*   `window.innerHeight`/`innerWidth`).
-* - **Coordinate space.** Boxes are raw `getBoundingClientRect` (viewport-relative),
-*   so the viewport folds (`viewportHeight`/`viewportWidth`) and the clip-ancestor
-*   bottoms/rights (`box.bottom`/`box.right`) live in the SAME space — no rebasing.
-* - **Architecture (ADR 0022 invariants 3 & 5).** Measure only snapshots the raw
-*   clip inputs (`overflow-y`/`overflow-x`, `scroll*`/`client*`); THIS pass derives
-*   the clip bottom/right. The walk records numbers, the pure pass owns all
-*   derivation.
+* - **No spacer.** Nothing reserves the dropped extent; the skeleton simply ends at the fold.
+* - **Why no CLS.** A dropped Bone was off-screen (below the viewport fold, or right of it) or inside
+*   a scroll/overflow container past its clip — never visible at capture. When real content lands
+*   it just grows the scroll height/width (or, for `overflow:hidden`/`clip`, is never visible at
+*   all); off-screen / clipped shifts do not score CLS, so the drop is layout-shift-free.
+* - **Reflow caveat (ADR 0004).** The fold is a render-time, width-dependent line (text rewraps at
+*   the render width, not the capture width), so the capture-time fold is conservative via
+*   `CROP_BUFFER`; a viewport / container larger than the one captured briefly shows blank past the
+*   fold until content fills — transient, no shift.
+* - **LTR-first; RTL a known limit.** The horizontal fold drops content past the RIGHT edge (the
+*   off-screen direction in LTR). In an RTL carousel the off-screen cards sit to the LEFT, so the
+*   right-edge fold does not catch them — an accepted known limit (the base-case viewport fold
+*   still drops anything genuinely right of `innerWidth`).
+* - **Per-View.** Views are independent and breakpoint-gated (ADR 0004); each carries its own folds
+*   (`viewportHeight`/`viewportWidth` = that View's `window.innerHeight`/`innerWidth`).
+* - **Coordinate space.** Boxes are raw `getBoundingClientRect` (viewport-relative), so the viewport
+*   folds (`viewportHeight`/`viewportWidth`) and the clip-ancestor bottoms/rights
+*   (`box.bottom`/`box.right`) live in the SAME space — no rebasing.
+* - **Architecture (ADR 0022 invariants 3 & 5).** Measure only snapshots the raw clip inputs
+*   (`overflow-y`/`overflow-x`, `scroll*`/`client*`); THIS pass derives the clip bottom/right. The
+*   walk records numbers, the pure pass owns all derivation.
 *
-* A top-down traversal threading the RAW (un-buffered) clip bottom AND right: a node
-* lives inside its PARENT's clip context, so the folds that judge a node are its
-* parent's clip bottom/right; the node's own clipping constrains its CHILDREN. The
-* buffer is applied only at the leaf compare so it never compounds down nesting.
-* Reuses `isLeaf`/`isSolidLeaf`/`edgesOf` and the boxless-fallback rule from
-* `collectLeaves`, and `pruneEmptyBranches` for the orphan sweep. Non-destructive
-* (`IRNode.dropped`); `emit` lowers it. Order vs Superset is immaterial — both
-* only annotate `dropped`.
+* A top-down traversal threading the RAW (un-buffered) clip bottom AND right: a node lives inside
+* its PARENT's clip context, so the folds that judge a node are its parent's clip bottom/right; the
+* node's own clipping constrains its CHILDREN. The buffer is applied only at the leaf compare so it
+* never compounds down nesting. Reuses `isLeaf`/`isSolidLeaf`/`edgesOf` and the boxless-fallback
+* rule from `collectLeaves`, and `pruneEmptyBranches` for the orphan sweep. Non-destructive
+* (`IRNode.dropped`); `emit` lowers it. Order vs Superset is immaterial — both only annotate
+* `dropped`.
 */
 function cropIR(root, viewportHeight, viewportWidth, diagnostics) {
 	cropNode(root, viewportHeight, viewportWidth, null, diagnostics);
 	pruneEmptyBranches(root);
 }
 /**
-* Does this node clip its content vertically — a scroll/overflow context whose
-* visible bottom is a fold for its children? `overflow-y` is one of
-* auto|scroll|hidden|clip AND the content actually overflows the client box
-* (`scrollHeight > clientHeight`, +1 absorbing sub-pixel). When the metrics were
-* not snapshotted (overflow-y was not clipping at measure time), this is correctly
+* Does this node clip its content vertically — a scroll/overflow context whose visible bottom is a
+* fold for its children? `overflow-y` is one of auto|scroll|hidden|clip AND the content actually
+* overflows the client box (`scrollHeight > clientHeight`, +1 absorbing sub-pixel). When the
+* metrics were not snapshotted (overflow-y was not clipping at measure time), this is correctly
 * false.
 */
 function nodeClipsY(node) {
@@ -1437,14 +1363,13 @@ function nodeClipsY(node) {
 	return node.scrollHeight !== void 0 && node.clientHeight !== void 0 && node.scrollHeight > node.clientHeight + 1;
 }
 /**
-* Does this node clip its content HORIZONTALLY — a scroll/overflow context whose
-* visible right edge is a fold for its children (a carousel)? The horizontal mirror
-* of `nodeClipsY`: `overflow-x` is one of auto|scroll|hidden|clip AND the content
-* actually overflows the client box (`scrollWidth > clientWidth`, +1 absorbing
-* sub-pixel). When the metrics were not snapshotted (overflow-x was not clipping at
-* measure time), this is correctly false — so a `flex-wrap`/grid that merely WRAPS
-* to more rows (`overflow-x: visible`) never tightens the horizontal fold; its
-* wrapped items are judged against the wider ancestor/viewport fold and kept.
+* Does this node clip its content HORIZONTALLY — a scroll/overflow context whose visible right edge
+* is a fold for its children (a carousel)? The horizontal mirror of `nodeClipsY`: `overflow-x` is
+* one of auto|scroll|hidden|clip AND the content actually overflows the client box (`scrollWidth >
+* clientWidth`, +1 absorbing sub-pixel). When the metrics were not snapshotted (overflow-x was not
+* clipping at measure time), this is correctly false — so a `flex-wrap`/grid that merely WRAPS to
+* more rows (`overflow-x: visible`) never tightens the horizontal fold; its wrapped items are
+* judged against the wider ancestor/viewport fold and kept.
 */
 function nodeClipsX(node) {
 	if (!/^(auto|scroll|hidden|clip)$/.test(node.style.overflowX)) return false;
@@ -1452,13 +1377,12 @@ function nodeClipsX(node) {
 }
 /**
 * Recurse top-down threading `(inheritedAncestorBox, clipBottom, clipRight)`.
-* `clipBottom`/`clipRight` are the folds that apply to THIS node (its parent
-* context's visible bottom / right edge); `inheritedAncestorBox` is the nearest
-* box-bearing ancestor's edges, for the boxless-leaf fallback (identical to
-* `collectLeaves`). The clip bottom/right passed to children tightens to this node's
-* box bottom/right when the node itself clips that axis — and ONLY then: a node that
-* merely wraps (overflow:visible) never tightens, so normal in-viewport wrapped
-* content is never over-cropped.
+* `clipBottom`/`clipRight` are the folds that apply to THIS node (its parent context's visible
+* bottom / right edge); `inheritedAncestorBox` is the nearest box-bearing ancestor's edges, for the
+* boxless-leaf fallback (identical to `collectLeaves`). The clip bottom/right passed to children
+* tightens to this node's box bottom/right when the node itself clips that axis — and ONLY then: a
+* node that merely wraps (overflow:visible) never tightens, so normal in-viewport wrapped content
+* is never over-cropped.
 */
 function cropNode(node, clipBottom, clipRight, inheritedAncestorBox, diagnostics) {
 	const own = edgesOf(node);
@@ -1475,33 +1399,30 @@ function cropNode(node, clipBottom, clipRight, inheritedAncestorBox, diagnostics
 	for (const kid of effectiveKids(node)) cropNode(kid, childClipBottom, childClipRight, own ?? inheritedAncestorBox, diagnostics);
 }
 /**
-* Phase-2 Template (per-View): collapse a run of >= MIN_TEMPLATE_RUN consecutive,
-* structurally-similar sibling cells (a feed/grid) into ONE representative cell
-* carrying `count = N`. The serializer emits the cell's HTML once plus the count
-* and the renderer expands it back to N (chunk.ts / react.core.tsx), so the plate
-* ships one cell instead of N.
+* TEMPLATE (per-View, runs last): collapse a run of >= MIN_TEMPLATE_RUN consecutive,
+* structurally-similar sibling cells (a feed/grid) into ONE representative cell carrying `count =
+* N`. The serializer emits the cell's HTML once plus the count and the renderer expands it back to
+* N (chunk.ts / react.core.tsx), so the plate ships one cell instead of N.
 *
-* Template runs LAST of the IR passes (after Superset and Crop), so it compresses ONLY
-* what survives the removal passes — what a human would actually see (the owner's
-* guiding principle). Crop drops a run's off-screen tail first; Template then groups the
-* on-screen prefix and `count = run.length` renders back to exactly that surviving N.
-* This makes Template LOSSLESS compression (one cell + a faithful count), so it warns
-* about nothing — the lossy off-screen removal is Crop's job (`dropped-cropped`).
+* Template runs LAST of the IR passes (after Superset and Crop), so it compresses ONLY what
+* survives the removal passes — what a viewer would actually see. Crop drops a run's off-screen
+* tail first; Template then groups the on-screen prefix and `count = run.length` renders back to
+* exactly that surviving N. Template is therefore LOSSLESS compression (one cell + a faithful
+* count), so it warns about nothing; the lossy off-screen removal is Crop's job
+* (`dropped-cropped`).
 *
-* Cells need not be pixel-identical — text length varies cell to cell — so the
-* match is STRUCTURAL: a multiset of every descendant's `structuralHash`
-* (kind + author-decls signature, dimensions excluded), compared within a loose
-* tolerance (TEMPLATE_SHAPE_TOLERANCE differing nodes, so a minority FEATURED
-* badge still groups). The template takes the run's MODAL structure (a minority
-* badge normalizes away) and, for each fixed-size bone, the rounded median
-* width/height across the run; text-block bones reflow via `@container`, so their
-* dims are left alone. Only stitch-free, count-free, NON-dropped cells are templated
-* (the cell must flatten to one HTML string; nested templates are out of scope; a
-* dropped cell breaks the run). The dropped cells' `@container` rep bands are pruned
-* from `extraRules` so no dead CSS ships.
+* Cells need not be pixel-identical — text length varies cell to cell — so the match is STRUCTURAL:
+* a multiset of every descendant's `structuralHash` (kind + author-decls signature, dimensions
+* excluded), compared within a loose tolerance (TEMPLATE_SHAPE_TOLERANCE differing nodes, so a
+* minority FEATURED badge still groups). The template takes the run's MODAL structure (a minority
+* badge normalizes away) and, for each fixed-size bone, the rounded median width/height across the
+* run; text-block bones reflow via `@container`, so their dims are left alone. Only stitch-free,
+* count-free, NON-dropped cells are templated (the cell must flatten to one HTML string; nested
+* templates are out of scope; a dropped cell breaks the run). The dropped cells' `@container` rep
+* bands are pruned from `extraRules` so no dead CSS ships.
 *
-* Loose by design — the tolerance is a single knob; tighten it toward 0 (exact)
-* if false positives surface.
+* Loose by design — the tolerance is a single knob; tighten it toward 0 (exact) if false positives
+* surface.
 */
 const MIN_TEMPLATE_RUN = 3;
 const TEMPLATE_SHAPE_TOLERANCE = 1;
@@ -1512,7 +1433,10 @@ function templateIR(bundle) {
 	collapseTemplateRuns(bundle.root, dropped);
 	if (dropped.size > 0) bundle.extraRules = bundle.extraRules.filter((rule) => !rule.ids.every((id) => dropped.has(id)));
 }
-/** Recurse bottom-up, then replace each maximal template run among a node's kids with one cell + count. */
+/**
+* Recurse bottom-up, then replace each maximal template run among a node's kids with one cell +
+* count.
+*/
 function collapseTemplateRuns(node, dropped) {
 	if (node.folded) return;
 	for (const kid of node.kids) collapseTemplateRuns(kid, dropped);
@@ -1537,13 +1461,12 @@ function collapseTemplateRuns(node, dropped) {
 	node.kids = out;
 }
 /**
-* Maximal run of consecutive templateable kids from `start` matching a common modal
-* shape within tolerance. A `dropped` cell is non-templatable (`isStaticCell` rejects
-* it), so it breaks the run AND is rejected as a first cell — Template runs LAST, after
-* Crop, so it only ever groups NON-dropped (on-screen surviving) cells. Crop drops a
-* contiguous off-screen tail, so this yields the surviving prefix as the run; the
-* dropped tail flows through `collapseTemplateRuns`'s else-branch unchanged (still
-* `dropped`, `emit` lowers it).
+* Maximal run of consecutive templateable kids from `start` matching a common modal shape within
+* tolerance. A `dropped` cell is non-templatable (`isStaticCell` rejects it), so it breaks the run
+* AND is rejected as a first cell — Template runs LAST, after Crop, so it only ever groups
+* NON-dropped (on-screen surviving) cells. Crop drops a contiguous off-screen tail, so this yields
+* the surviving prefix as the run; the dropped tail flows through `collapseTemplateRuns`'s
+* else-branch unchanged (still `dropped`, `emit` lowers it).
 */
 function templateRun(kids, start) {
 	const first = kids[start];
@@ -1560,21 +1483,21 @@ function templateRun(kids, start) {
 	}
 	return run;
 }
-/** A clear majority of the run matches its modal shape exactly (>= MIN_TEMPLATE_MAJORITY) — else there's no single template. */
+/**
+* A clear majority of the run matches its modal shape exactly (>= MIN_TEMPLATE_MAJORITY) — else
+* there's no single template.
+*/
 function hasModalMajority(run) {
 	const shapes = run.map(cellShape);
 	const modalKey = modalShape(shapes).join(SHAPE_SEP);
 	return shapes.filter((shape) => shape.join(SHAPE_SEP) === modalKey).length >= run.length * MIN_TEMPLATE_MAJORITY;
 }
 /**
-* Replace a run with one template cell: modal structure, median fixed-bone dims, and
-* `count = run.length` — the full SURVIVING count. Template runs LAST (after Crop), so
-* the run holds only on-screen cells (Crop already dropped any off-screen tail, and a
-* dropped cell breaks the run in `templateRun`); the count therefore renders back to
-* exactly the N a human would see. Template is now LOSSLESS compression — one cell + a
-* faithful count — so there is nothing to warn about; the lossy off-screen removal is
-* Crop's job and already emits `dropped-cropped`. The median dims are taken over the
-* modal cells.
+* Replace a run with one template cell: modal structure, median fixed-bone dims, and `count =
+* run.length` — the full SURVIVING count. Template runs LAST (after Crop), so the run holds only
+* on-screen cells (Crop already dropped any off-screen tail, and a dropped cell breaks the run in
+* `templateRun`); the count renders back to exactly the N a viewer would see. The median dims are
+* taken over the modal cells.
 */
 function synthesizeTemplate(run, dropped) {
 	const modalKey = modalShape(run.map(cellShape)).join(SHAPE_SEP);
@@ -1587,23 +1510,26 @@ function synthesizeTemplate(run, dropped) {
 	return template;
 }
 /**
-* A cell that can flatten to one HTML string: no stitch and no (nested) template
-* anywhere within. Reads the EFFECTIVE structure (ADR 0022 §3): a `flattened`
-* wrapper contributes nothing of its own and is judged purely by its hoisted kids,
-* so the verdict matches what `emit` projects — mirroring `effectiveKids`.
+* A cell that can flatten to one HTML string: no stitch and no (nested) template anywhere within.
+* Reads the EFFECTIVE structure (ADR 0022 §3): a `flattened` wrapper contributes nothing of its own
+* and is judged purely by its hoisted kids, so the verdict matches what `emit` projects — mirroring
+* `effectiveKids`.
 *
-* A `dropped` cell is NON-templatable: Template runs LAST (after Crop), so a dropped
-* (off-screen / superseted / etc.) cell must never be grouped — it breaks the run in
-* `templateRun` and is rejected as a first cell, so Template only ever compresses the
-* on-screen survivors. `effectiveKids` already prunes a dropped descendant, so only the
-* cell's OWN drop needs the explicit guard here.
+* A `dropped` cell is NON-templatable: Template runs LAST (after Crop), so a dropped (off-screen /
+* superseted / etc.) cell must never be grouped — it breaks the run in `templateRun` and is
+* rejected as a first cell, so Template only ever compresses the on-screen survivors.
+* `effectiveKids` already prunes a dropped descendant, so only the cell's OWN drop needs the
+* explicit guard here.
 */
 function isStaticCell(node) {
 	if (node.dropped !== void 0) return false;
 	if (!node.flattened && (node.kind === "stitch" || node.ref !== void 0 || node.count !== void 0)) return false;
 	return effectiveKids(node).every(isStaticCell);
 }
-/** This bone's structural identity for templating: kind + a dimension-free author-decls signature. Memoized. */
+/**
+* This bone's structural identity for templating: kind + a dimension-free author-decls signature.
+* Memoized.
+*/
 function structuralHash(node) {
 	if (node.structuralHash !== void 0) return node.structuralHash;
 	const decls = effectiveDecls(node);
@@ -1614,11 +1540,10 @@ function structuralHash(node) {
 	return hash;
 }
 /**
-* A cell's shape: the sorted multiset of every EFFECTIVE descendant's
-* `structuralHash`. Reads through `flattened` (ADR 0022 §3): a flattened wrapper
-* contributes no hash of its own and its kids are hoisted, so a run of cells
-* templates on the shape `emit` projects — identical whether or not each cell wraps
-* its content in a coincident passthrough wrapper. Mirrors `effectiveKids`.
+* A cell's shape: the sorted multiset of every EFFECTIVE descendant's `structuralHash`. Reads
+* through `flattened` (ADR 0022 §3): a flattened wrapper contributes no hash of its own and its
+* kids are hoisted, so a run of cells templates on the shape `emit` projects — identical whether or
+* not each cell wraps its content in a coincident passthrough wrapper. Mirrors `effectiveKids`.
 */
 function cellShape(node) {
 	const out = [];
@@ -1671,11 +1596,10 @@ function shapeDistance(a, b) {
 	return diff + (a.length - i) + (b.length - j);
 }
 /**
-* Median (rounded) fixed-size bone dims across the modal cells, written onto the
-* template's bones. Bones are paired by pre-order INDEX across cells; a kind guard
-* skips mismatches, so a same-shape cell whose DOM order differs (flex `order`,
-* `row-reverse`) just drops out of the median rather than contaminating it —
-* uncommon and guarded, not corrected here.
+* Median (rounded) fixed-size bone dims across the modal cells, written onto the template's bones.
+* Bones are paired by pre-order INDEX across cells; a kind guard skips mismatches, so a same-shape
+* cell whose DOM order differs (flex `order`, `row-reverse`) just drops out of the median rather
+* than contaminating it — uncommon and guarded, not corrected here.
 */
 function applyMedianDims(template, cells) {
 	const lists = cells.map(fixedSizeLeaves);
@@ -1707,16 +1631,16 @@ function applyMedianDims(template, cells) {
 	}
 }
 /**
-* A cell's fixed-size bones (text-line / box / media) in EFFECTIVE pre-order;
-* text-block reflows, so it's excluded. Reads through `flattened` (a passthrough
-* wrapper is a bone-free container anyway, so this matches `cellShape`'s ordering
-* and the structure `emit` projects — ADR 0022 §3, mirroring `effectiveKids`).
+* A cell's fixed-size bones (text-line / box / media) in EFFECTIVE pre-order; text-block reflows,
+* so it's excluded. Reads through `flattened` (a passthrough wrapper is a bone-free container
+* anyway, so this matches `cellShape`'s ordering and the structure `emit` projects — ADR 0022 §3,
+* mirroring `effectiveKids`).
 */
 function fixedSizeLeaves(node) {
 	const out = [];
 	const visit = (n) => {
 		const kind = effectiveKind(n);
-		if (!n.flattened && (kind === "text" || kind === "box" || kind === "media") && effectiveDecls(n).size) out.push(n);
+		if (!n.flattened && (kind === "text-line" || kind === "box" || kind === "media") && effectiveDecls(n).size) out.push(n);
 		for (const kid of effectiveKids(n)) visit(kid);
 	};
 	visit(node);
@@ -5763,13 +5687,13 @@ function endsWithLineStartProhibitedText(text) {
 	const last = getLastCodePoint(text);
 	return last !== null && (kinsokuStart.has(last) || leftStickyPunctuation.has(last));
 }
-const keepAllGlueChars = new Set([
+const keepAllGlueChars = /* @__PURE__ */ new Set([
 	"\xA0",
 	" ",
 	"⁠",
 	""
 ]);
-const keepAllDashBreakChars = new Set([
+const keepAllDashBreakChars = /* @__PURE__ */ new Set([
 	"-",
 	"‐",
 	"–",
@@ -5790,7 +5714,7 @@ function canContinueKeepAllTextRun(previousText, breakAfterPunctuation) {
 	if (endsWithKeepAllDashBreakText(previousText)) return false;
 	return true;
 }
-const kinsokuStart = new Set([
+const kinsokuStart = /* @__PURE__ */ new Set([
 	"，",
 	"．",
 	"！",
@@ -5818,7 +5742,7 @@ const kinsokuStart = new Set([
 	"ヽ",
 	"ヾ"
 ]);
-const kinsokuEnd = new Set([
+const kinsokuEnd = /* @__PURE__ */ new Set([
 	"\"",
 	"(",
 	"[",
@@ -5843,8 +5767,8 @@ const kinsokuEnd = new Set([
 	"〘",
 	"〚"
 ]);
-const forwardStickyGlue = new Set(["'", "’"]);
-const leftStickyPunctuation = new Set([
+const forwardStickyGlue = /* @__PURE__ */ new Set(["'", "’"]);
+const leftStickyPunctuation = /* @__PURE__ */ new Set([
 	".",
 	",",
 	"!",
@@ -5872,14 +5796,14 @@ const leftStickyPunctuation = new Set([
 	"›",
 	"…"
 ]);
-const arabicNoSpaceTrailingPunctuation = new Set([
+const arabicNoSpaceTrailingPunctuation = /* @__PURE__ */ new Set([
 	":",
 	".",
 	"،",
 	"؛"
 ]);
-const myanmarMedialGlue = new Set(["၏"]);
-const closingQuoteChars = new Set([
+const myanmarMedialGlue = /* @__PURE__ */ new Set(["၏"]);
+const closingQuoteChars = /* @__PURE__ */ new Set([
 	"”",
 	"’",
 	"»",
@@ -6255,7 +6179,7 @@ function mergeUrlQueryRuns(segmentation) {
 		starts
 	};
 }
-const numericJoinerChars = new Set([
+const numericJoinerChars = /* @__PURE__ */ new Set([
 	":",
 	"-",
 	"/",
@@ -6268,7 +6192,7 @@ const numericJoinerChars = new Set([
 ]);
 const wordInternalSymbolRe = /[\p{P}\p{S}\p{Co}]/u;
 const emojiPresentationRe$1 = /\p{Emoji_Presentation}/u;
-const noSpaceWordBreakAfterChars = new Set([
+const noSpaceWordBreakAfterChars = /* @__PURE__ */ new Set([
 	"?",
 	"֊",
 	"-",
@@ -8037,7 +7961,7 @@ function textBar(run, foldedMedia, state, depth) {
 	const node = {
 		id: state.nextId++,
 		el: null,
-		kind: "text",
+		kind: "text-line",
 		kids: [],
 		depth,
 		decls: { fallback: ["display: inline-block", "vertical-align: middle"] },
@@ -8065,13 +7989,12 @@ function textBar(run, foldedMedia, state, depth) {
 	return node;
 }
 /**
-* CSS generic font-family keywords — none names a concrete face, so pretext's
-* canvas `measureText` can't agree with what the browser actually resolved
-* (pretext's own README flags `system-ui` as unsafe on macOS). A run whose first
-* family token is one of these has no capture-matched named font, so the rep
-* falls back. The list is the CSS generic set plus the `ui-*` system aliases.
+* CSS generic font-family keywords — none names a concrete face, so pretext's canvas `measureText`
+* can't agree with what the browser actually resolved (pretext's own README flags `system-ui` as
+* unsafe on macOS). A run whose first family token is one of these has no capture-matched named
+* font, so the rep falls back. The list is the CSS generic set plus the `ui-*` system aliases.
 */
-const GENERIC_FONT_FAMILIES = new Set([
+const GENERIC_FONT_FAMILIES = /* @__PURE__ */ new Set([
 	"serif",
 	"sans-serif",
 	"monospace",
@@ -8092,10 +8015,10 @@ const GENERIC_FONT_FAMILIES = new Set([
 	"revert-layer"
 ]);
 /**
-* The first font-family token, unquoted and lowercased, or null when the list is
-* empty. `getComputedStyle().fontFamily` serializes the resolved list (the
-* first entry is the face the browser used for this run), comma-separated with
-* quoted multi-word names — `"Helvetica Neue", Arial, sans-serif` → `helvetica neue`.
+* The first font-family token, unquoted and lowercased, or null when the list is empty.
+* `getComputedStyle().fontFamily` serializes the resolved list (the first entry is the face the
+* browser used for this run), comma-separated with quoted multi-word names — `"Helvetica Neue",
+* Arial, sans-serif` → `helvetica neue`.
 */
 function firstFontFamily(fontFamily) {
 	const first = splitTopLevelComma(fontFamily)[0];
@@ -8122,11 +8045,11 @@ function splitTopLevelComma(value) {
 	return out;
 }
 /**
-* Build the canvas `font` shorthand pretext wants — `<style> <weight> <size>px
-* <family-list>` — from the run's resolved computed style, mirroring CSS exactly
-* (the families pass through verbatim, quotes and all, so the canvas resolves the
-* SAME face). Returns null when the size is not a usable px length. Order follows
-* the canvas/CSS `font` shorthand: style, then weight, then size, then family.
+* Build the canvas `font` shorthand pretext wants — `<style> <weight> <size>px <family-list>` —
+* from the run's resolved computed style, mirroring CSS exactly (the families pass through
+* verbatim, quotes and all, so the canvas resolves the SAME face). Returns null when the size is
+* not a usable px length. Order follows the canvas/CSS `font` shorthand: style, then weight, then
+* size, then family.
 */
 function canvasFontShorthand(cs) {
 	const sizePx = pxValue(cs.fontSize);
@@ -8139,14 +8062,12 @@ function canvasFontShorthand(cs) {
 	return parts.join(" ");
 }
 /**
-* Does this environment have real canvas text metrics (the feature gate for the
-* whole rep)? pretext relies on Canvas 2D `measureText` AND `Intl.Segmenter`
-* (its documented runtime requirement); a layout-less env (happy-dom in tests,
-* older runtimes) has neither, so `prepare()`/`layout()` cannot compute there.
-* We probe once per capture: a 2d context whose `measureText` returns a positive
-* width for a known glyph, plus a present `Intl.Segmenter`. When this is false
-* the rep is skipped entirely and the run takes the existing pill-bar fallback,
-* keeping the no-canvas path byte-identical to before this change.
+* Does this environment have real canvas text metrics (the feature gate for the whole rep)? pretext
+* relies on Canvas 2D `measureText` AND `Intl.Segmenter` (its documented runtime requirement); a
+* layout-less env (happy-dom in tests, older runtimes) has neither, so `prepare()`/`layout()`
+* cannot compute there. Probe once per capture: a 2d context whose `measureText` returns a positive
+* width for a known glyph, plus a present `Intl.Segmenter`. When this is false the rep is skipped
+* entirely and the run takes the pill-bar fallback.
 */
 function hasUsableTextMetrics(win) {
 	if (!("Intl" in win) || !("Segmenter" in Intl)) return false;
@@ -8160,11 +8081,10 @@ function hasUsableTextMetrics(win) {
 	}
 }
 /**
-* The nearest block-level ancestor that establishes the run's wrapping width,
-* starting from the text's parent. Inline wrappers (`<b>`, `<span>`) don't bound
-* wrapping; the first non-inline ancestor's content box is the available width
-* the injected `container-type: inline-size` wrapper will assume (it fills its
-* slot). Returns the parent itself when it is already block-level.
+* The nearest block-level ancestor that establishes the run's wrapping width, starting from the
+* text's parent. Inline wrappers (`<b>`, `<span>`) don't bound wrapping; the first non-inline
+* ancestor's content box is the available width the injected `container-type: inline-size` wrapper
+* will assume (it fills its slot). Returns the parent itself when it is already block-level.
 */
 function wrappingBlock(parent, styles) {
 	for (let host = parent; host; host = host.parentElement) if (!isInlineish(styles.get(host).display)) return host;
@@ -8176,12 +8096,10 @@ function innerContentWidth(el, styles) {
 	return el.getBoundingClientRect().width - pad(cs.paddingLeft) - pad(cs.paddingRight) - pad(cs.borderLeftWidth) - pad(cs.borderRightWidth);
 }
 /**
-* Count the run's rendered lines from its `Range` rects: `getClientRects()`
-* yields one rect per line fragment, so distinct `top` values (collapsed within
-* 1px) are the line count. This is the same ground truth the spike validated
-* pretext against; here it is the capture-time AGREEMENT check — if pretext's
-* predicted line count at the capture width disagrees with what the browser
-* actually rendered, the rep would be wrong for this run and we fall back.
+* Count the run's rendered lines from its `Range` rects: `getClientRects()` yields one rect per
+* line fragment, so distinct `top` values (collapsed within 1px) are the line count. The
+* capture-time AGREEMENT check: if pretext's predicted line count at the capture width disagrees
+* with what the browser actually rendered, the rep would be wrong for this run, so it falls back.
 */
 function renderedLineCount(range) {
 	const rects = Array.from(range.getClientRects());
@@ -8193,25 +8111,22 @@ function renderedLineCount(range) {
 	return Math.max(1, tops.length);
 }
 /**
-* The active `-webkit-line-clamp` line cap governing the run, or null. The clamp
-* idiom (`display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp:
-* N; overflow: hidden`) clips text to N lines, so a clamped run NEVER shows more
-* than N no matter how narrow the container gets. pretext measures the UNCLAMPED
-* wrap, and a `Range`'s rects ignore the clip too (`renderedLineCount`), so the
-* agreement check passes on the full count while the run actually renders at most
-* N — without this the rep would emit bands TALLER than the clamp ever shows.
-* Capping the band sweep at N makes a clamped block exact and bounds its stack to
-* ≤N. Walks ancestors (the clamp may sit a few wrappers above the text node) and
-* returns the nearest ACTIVE clamp — a positive integer `-webkit-line-clamp` on a
-* vertical `-webkit-box-orient` (the idiom). A clamp value without the vertical
-* orientation has no effect and is ignored, matching the browser.
+* The active `-webkit-line-clamp` line cap governing the run, or null. The clamp idiom (`display:
+* -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: N; overflow: hidden`) clips text
+* to N lines, so a clamped run NEVER shows more than N no matter how narrow the container gets.
+* pretext measures the UNCLAMPED wrap, and a `Range`'s rects ignore the clip too
+* (`renderedLineCount`), so the agreement check passes on the full count while the run actually
+* renders at most N — without this the rep would emit bands TALLER than the clamp ever shows.
+* Capping the band sweep at N makes a clamped block exact and bounds its stack to ≤N. Walks
+* ancestors (the clamp may sit a few wrappers above the text node) and returns the nearest ACTIVE
+* clamp — a positive integer `-webkit-line-clamp` on a vertical `-webkit-box-orient` (the idiom). A
+* clamp value without the vertical orientation has no effect and is ignored, matching the browser.
 *
-* Detection keys on the line-clamp + box-orient PAIR, deliberately NOT on
-* computed `display`: Chrome normalizes an active `display: -webkit-box` clamp to
-* `display: flow-root` in computed style (verified), so a `display === -webkit-box`
-* guard silently never matched in Chrome — the bug this comment guards against.
-* `-webkit-box-orient` and `-webkit-line-clamp` ARE exposed in computed style, so
-* the pair is the reliable cross-engine signal.
+* Detection keys on the line-clamp + box-orient PAIR, deliberately NOT on computed `display`:
+* Chrome normalizes an active `display: -webkit-box` clamp to `display: flow-root` in computed
+* style (verified), so a `display === -webkit-box` guard silently never matched in Chrome — the bug
+* this comment guards against. `-webkit-box-orient` and `-webkit-line-clamp` ARE exposed in
+* computed style, so the pair is the reliable cross-engine signal.
 */
 function activeLineClamp(parent, styles) {
 	for (let el = parent; el; el = el.parentElement) {
@@ -8224,24 +8139,21 @@ function activeLineClamp(parent, styles) {
 	return null;
 }
 /**
-* The line-count step function across the width range, swept at 1px so each
-* band threshold lands on the exact width the run changes line count (the spike
-* confirmed these coincide with the browser's real wrap points to the pixel).
-* Walks widths ascending and records every transition; the first entry is the
-* baseline (most lines, narrowest), each later entry a `min-width` step.
-* `maxWidth` caps the sweep at the largest realistic container width (the run may
-* fit on one line before reaching it). `lines` is clamped to `maxLines` (the
-* caller passes `MAX_REP_LINES`, or a smaller `-webkit-line-clamp` cap), so the
-* band stack is bounded no matter how many lines the run wraps to at the narrow
-* end.
+* The line-count step function across the width range, swept at 1px so each band threshold lands on
+* the exact width the run changes line count (measured to coincide with the browser's real wrap
+* points to the pixel). Walks widths ascending and records every transition; the first entry is the
+* baseline (most lines, narrowest), each later entry a `min-width` step. `maxWidth` caps the sweep
+* at the largest realistic container width (the run may fit on one line before reaching it).
+* `lines` is clamped to `maxLines` (the caller passes `MAX_REP_LINES`, or a smaller
+* `-webkit-line-clamp` cap), so the band stack is bounded no matter how many lines the run wraps to
+* at the narrow end.
 */
 /**
-* Cap on the line-count bands per run. A run that wraps to more lines than this at
-* the narrow end clamps here (a tall block reads as "tall" — a line or two off at
-* an extreme-narrow width is imperceptible on swap), so the band stack can never
-* explode — an unbounded sweep produced 40–70 bands per run on real content. Kept
-* above realistic mobile paragraph line counts so it does not clip genuine content.
-* Tunable.
+* Cap on the line-count bands per run. A run that wraps to more lines than this at the narrow end
+* clamps here (a tall block reads as "tall" — a line or two off at an extreme-narrow width is
+* imperceptible on swap), so the band stack can never explode — an unbounded sweep produced 40–70
+* bands per run on real content. Kept above realistic mobile paragraph line counts so it does not
+* clip genuine content. Tunable.
 */
 const MAX_REP_LINES = 16;
 function lineCountStepFunction(prepared, lh, minWidth, maxWidth, maxLines) {
@@ -8261,45 +8173,41 @@ function lineCountStepFunction(prepared, lh, minWidth, maxWidth, maxLines) {
 	return bands;
 }
 /**
-* The minimum container width to sweep from. The bone never renders narrower
-* than one line-height tall, and sweeping below a few px is wasted work; a small
-* floor keeps the sweep bounded for a pathologically long run. Real containers
-* are far wider, so this only caps the bottom of the band stack.
+* The minimum container width to sweep from. The bone never renders narrower than one line-height
+* tall, and sweeping below a few px is wasted work; a small floor keeps the sweep bounded for a
+* pathologically long run. Real containers are far wider, so this only caps the bottom of the band
+* stack.
 */
 const REP_MIN_WIDTH = 16;
 /**
-* Cap on the sweep's upper width: the largest realistic container width. The rep
-* runs during the walk, before per-plate breakpoints are derived, so it cannot
-* read the actual biggest breakpoint — this fixed bound stands in for it. Beyond
-* it (a text run spanning a full ultra-wide viewport), a height mismatch on swap
-* is imperceptible against that much space, so sweeping out to the run's
-* single-line width would only emit wasted bands. Tunable; ≈ the largest common
-* breakpoint.
+* Cap on the sweep's upper width: the largest realistic container width. The rep runs during the
+* walk, before per-plate breakpoints are derived, so it cannot read the actual biggest breakpoint —
+* this fixed bound stands in for it. Beyond it (a text run spanning a full ultra-wide viewport), a
+* height mismatch on swap is imperceptible against that much space, so sweeping out to the run's
+* single-line width would only emit wasted bands. Tunable; ≈ the largest common breakpoint.
 */
 const REP_MAX_WIDTH = 1920;
 /**
-* Attempt the `@container` line-count rep for a wrapping text run (ADR 0019 §2).
-* Returns the leaf-scoped wrapper `IRNode` (a branch with one full-width text
-* bone child, both pushed to `state.nodes`) and emits its reflow band rules onto
-* `state`, OR returns null to signal the caller to keep the existing measured
-* pill bar. Null is returned for everything the rep can't safely cover, so a
-* fallback is always graceful and never a regression:
+* Attempt the `@container` line-count rep for a wrapping text run (ADR 0019 §2). Returns the
+* leaf-scoped wrapper `IRNode` (a branch with one full-width text bone child, both pushed to
+* `state.nodes`) and emits its reflow band rules onto `state`, OR returns null to signal the caller
+* to keep the existing measured pill bar. Null is returned for everything the rep can't safely
+* cover, so a fallback is always graceful and never a regression:
 *
-*  - no usable canvas text metrics (every test env; older runtimes) — feature gate;
-*  - no resolved parent / no named capture-matched font / no px line-height;
-*  - a single-line or short run (stays the thin pill bar — a fat block misreads);
-*  - an out-of-model wrap mode pretext doesn't model: `text-align: justify`,
-*    `hyphens: auto`, `word-break: break-all`, `white-space` ≠ normal/pre-wrap;
-*  - an unbreakable token wider than the container (the spike's failure: the
-*    browser overflows it on one line, pretext wraps it — they diverge);
-*  - pretext's predicted line count disagreeing with the browser's actual wrap
-*    at the capture width (a self-check that also catches font substitution).
+* - No usable canvas text metrics (every test env; older runtimes) — feature gate;
+* - No resolved parent / no named capture-matched font / no px line-height;
+* - A single-line or short run (stays the thin pill bar — a fat block misreads);
+* - An out-of-model wrap mode pretext doesn't model: `text-align: justify`, `hyphens: auto`,
+*   `word-break: break-all`, `white-space` ≠ normal/pre-wrap;
+* - An unbreakable token wider than the container (the browser overflows it on one line, pretext
+*   wraps it — they diverge);
+* - Pretext's predicted line count disagreeing with the browser's actual wrap at the capture width (a
+*   self-check that also catches font substitution).
 *
-* On success the wrapper carries `container-type: inline-size` + a plate-local
-* unique `container-name`, and the bone gets `@container <name> (min-width: …)
-* { height: calc(N × lh) }` bands — reflowing by CSS alone, no frozen height,
-* no render JS. v1 ALWAYS injects a fresh named container; reusing an immediate
-* author container (ADR 0019 §2) is a deferred optimization.
+* On success the wrapper carries `container-type: inline-size` + a plate-local unique
+* `container-name`, and the bone gets `@container <name> (min-width: …) { height: calc(N × lh) }`
+* bands — reflowing by CSS alone, no frozen height, no render JS. v1 ALWAYS injects a fresh named
+* container; reusing an immediate author container (ADR 0019 §2) is a deferred optimization.
 */
 function textLineCountRep(run, range, height, parent, state, depth) {
 	if (!parent) return null;
@@ -8395,12 +8303,11 @@ function textLineCountRep(run, range, height, parent, state, depth) {
 	return wrapperNode;
 }
 /**
-* A `Range` rect is the tight union of the glyph line boxes, so a wrapped run
-* measures lines × glyph-height — short of the lines × line-height the source
-* actually occupied (a 2-line paragraph rendered ~3px short per line). When the
-* parent's line-height resolves to px and the run is clearly multi-line, round
-* to a whole number of line boxes so the bone reserves the real block height.
-* A single line is left untouched — its line box comes from the parent's pinned
+* A `Range` rect is the tight union of the glyph line boxes, so a wrapped run measures lines ×
+* glyph-height — short of the lines × line-height the source actually occupied (a 2-line paragraph
+* rendered ~3px short per line). When the parent's line-height resolves to px and the run is
+* clearly multi-line, round to a whole number of line boxes so the bone reserves the real block
+* height. A single line is left untouched — its line box comes from the parent's pinned
 * line-height, and the thin glyph bar reads as text rather than a fat block.
 */
 function snapToLines(height, parent, styles) {
@@ -8603,12 +8510,11 @@ function rightmostCompound(selector) {
 	return selector;
 }
 /**
-* Index author rules the way a browser's rule hash does: bucket each selector
-* by a token its matching element must carry (id, a class, or tag), so an
-* element only tests the rules that could possibly apply to it. CSS-module
-* class names are unique, so this turns an O(rules × nodes) sweep into a
-* near-linear one. Selectors keyed on nothing concrete (`*`, attribute-only)
-* fall back to a universal bucket tested against every element.
+* Index author rules the way a browser's rule hash does: bucket each selector by a token its
+* matching element must carry (id, a class, or tag), so an element only tests the rules that could
+* possibly apply to it. CSS-module class names are unique, so this turns an O(rules × nodes) sweep
+* into a near-linear one. Selectors keyed on nothing concrete (`*`, attribute-only) fall back to a
+* universal bucket tested against every element.
 */
 function indexRules(found, diagnostics) {
 	const index = {
@@ -8654,15 +8560,14 @@ function indexRules(found, diagnostics) {
 	return index;
 }
 /**
-* Scan every flattened author rule for custom-property declarations and group
-* them by token name. A token may be defined many times (a `:root` base plus an
-* `@media` override, or per-theme blocks); each definition keeps its conditions
-* and selector so the carry decision can see whether ANY of them is conditional
-* and where each anchors. Reuses the SAME flatten `copyRules` already paid for
-* (`collectStyleRules`), so this adds one extra pass over the rules, no new CSSOM
-* traversal. Dynamic-pseudo / pseudo-element rules never define layout tokens we
-* carry, but they are cheap to include and harmless (their selectors won't anchor
-* to a captured node or to :root), so the scan stays simple and skips nothing.
+* Scan every flattened author rule for custom-property declarations and group them by token name. A
+* token may be defined many times (a `:root` base plus an `@media` override, or per-theme blocks);
+* each definition keeps its conditions and selector so the carry decision can see whether ANY of
+* them is conditional and where each anchors. Reuses the SAME flatten `copyRules` already paid for
+* (`collectStyleRules`), so this adds one extra pass over the rules, no new CSSOM traversal.
+* Dynamic-pseudo / pseudo-element rules never define carried layout tokens, but they are cheap to
+* include and harmless (their selectors won't anchor to a captured node or to :root), so the scan
+* stays simple and skips nothing.
 */
 function collectTokenDefs(found) {
 	const defs = /* @__PURE__ */ new Map();
@@ -8695,12 +8600,11 @@ function collectTokenDefs(found) {
 	return defs;
 }
 /**
-* A selector that puts a custom property in scope for the WHOLE captured subtree
-* — `:root`, `html`, or the universal `*` (optionally wrapped in zero-specificity
-* `:where()`/`:is()`, and ignoring a trailing dynamic state). Such a definition
-* inherits down into every node, so it anchors on the plate's scoped root (node
-* id 0). Anything more specific is an element-level (re)definition handled by
-* matching it against the captured elements instead.
+* A selector that puts a custom property in scope for the WHOLE captured subtree — `:root`, `html`,
+* or the universal `*` (optionally wrapped in zero-specificity `:where()`/`:is()`, and ignoring a
+* trailing dynamic state). Such a definition inherits down into every node, so it anchors on the
+* plate's scoped root (node id 0). Anything more specific is an element-level (re)definition
+* handled by matching it against the captured elements instead.
 */
 const ROOT_SCOPE_SELECTOR = /^(?::root|html|\*)$/;
 function isRootScopeSelector(selector) {
@@ -8712,12 +8616,11 @@ function hasConditionalDef(defs) {
 	return defs.some((def) => def.media.length > 0 || def.container.length > 0);
 }
 /**
-* The plate-id a token definition anchors to, or null when it cannot be anchored
-* on the captured tree (an un-captured wrapper — Q5). Root-scope selectors
-* (`:root`/`html`/`*`) anchor on the scoped root (id 0, emitted as `ids: []`);
-* an element-level definition anchors on every captured element it matches (a
-* token redefined on a card anchors on that card's node). A definition that
-* matches NO captured element and is not root-scope is un-anchorable.
+* The plate-id a token definition anchors to, or null when it cannot be anchored on the captured
+* tree (an un-captured wrapper). Root-scope selectors (`:root`/`html`/`*`) anchor on the scoped
+* root (id 0, emitted as `ids: []`); an element-level definition anchors on every captured element
+* it matches (a token redefined on a card anchors on that card's node). A definition that matches
+* NO captured element and is not root-scope is un-anchorable.
 */
 function anchorIdsFor(def, elNodes) {
 	if (isRootScopeSelector(def.selector)) return [0];
@@ -8726,13 +8629,12 @@ function anchorIdsFor(def, elNodes) {
 	return ids.length > 0 ? ids : null;
 }
 /**
-* The winning UNCONDITIONAL definition value of a token — its constant value,
-* picked by the cascade among definitions that carry no `@media`/`@container`
-* condition: highest specificity, then latest source order. Null when the token
-* has no unconditional definition (it only exists inside a query — purely
-* conditional). This is what a constant token freezes to, sourced from the author
-* CSSOM rather than computed style, so the freeze is correct even where computed
-* style cannot resolve an inherited custom property.
+* The winning UNCONDITIONAL definition value of a token — its constant value, picked by the cascade
+* among definitions that carry no `@media`/`@container` condition: highest specificity, then latest
+* source order. Null when the token has no unconditional definition (it only exists inside a query
+* — purely conditional). This is what a constant token freezes to, sourced from the author CSSOM
+* rather than computed style, so the freeze is correct even where computed style cannot resolve an
+* inherited custom property.
 */
 function constantValueOf(defs) {
 	let best = null;
@@ -8927,39 +8829,39 @@ function attachCarried(nodeById, id, rule) {
 	(node.decls.carried ??= []).push(rule);
 }
 //#endregion
-//#region src/serialize.ts
+//#region src/measure.ts
 /**
-* Capture-only DOM annotations (ADR 0018), read DURING the walk to shape the
-* `PlateNode` tree and NEVER written into the tree, the Plate, or the persisted
-* JSON. They are the declarative 90% of capture customization; the programmable
-* `captureWalker` is the 10% escape hatch.
+* Capture-only DOM Hints (ADR 0018), read DURING the walk to shape the `PlateNode` tree and NEVER
+* written into the tree, the Plate, or the persisted JSON. They are the declarative 90% of capture
+* customization; the programmable `captureWalker` is the 10% escape hatch.
 *
 * - `data-xr-ignore` drops the element AND its subtree (it contributes no bone).
-* - `data-xr-bone-kind="text|media|box"` collapses the element's whole subtree
+* - `data-xr-bone-kind="text-line|text-block|media|box|hidden"` collapses the element's whole subtree
 *   into ONE Bone leaf of the given kind, sized from the element's own box.
 *
-* Both are subordinate to the stitch guard (ADR 0006): a nested `<Skeleton>`
-* boundary always becomes a stitch first, so neither annotation can make a
-* boundary leak into the parent plate. See `walk`.
+* Both are subordinate to the stitch guard (ADR 0006): a nested `<Skeleton>` boundary always
+* becomes a stitch first, so neither hint can make a boundary leak into the parent plate. See
+* `walk`.
 */
 const XR_IGNORE_ATTR = "data-xr-ignore";
 const XR_BONE_KIND_ATTR = "data-xr-bone-kind";
 /** The `LeafKind` values an author may legally name in `data-xr-bone-kind`. */
 const LEAF_KINDS = [
-	"text",
+	"text-line",
 	"text-block",
 	"media",
-	"box"
+	"box",
+	"hidden"
 ];
 /** Narrow an arbitrary `data-xr-bone-kind` string to a `LeafKind`, or null if unknown. */
 function asLeafKind(value) {
 	return LEAF_KINDS.find((kind) => kind === value) ?? null;
 }
 /**
-* Typed identity wrapper for authoring a capture walker (ADR 0018) — the
-* `defineConfig` pattern. It returns its argument unchanged at runtime; its only
-* job is to infer and check the `XrayCaptureWalker` shape at the call site so an
-* author gets completion and a typo in a hook name is caught.
+* Typed identity wrapper for authoring a capture walker (ADR 0018) — the `defineConfig` pattern. It
+* returns its argument unchanged at runtime; its only job is to infer and check the
+* `XrayCaptureWalker` shape at the call site so an author gets completion and a typo in a hook name
+* is caught.
 */
 function defineXrayCaptureWalker(walker) {
 	return walker;
@@ -8970,7 +8872,7 @@ function isElementNode(node) {
 function isTextNode(node) {
 	return node.nodeType === 3;
 }
-const SKIP_TAGS = new Set([
+const SKIP_TAGS = /* @__PURE__ */ new Set([
 	"SCRIPT",
 	"STYLE",
 	"LINK",
@@ -8979,7 +8881,7 @@ const SKIP_TAGS = new Set([
 	"NOSCRIPT",
 	"TITLE"
 ]);
-const MEDIA_TAGS = new Set([
+const MEDIA_TAGS = /* @__PURE__ */ new Set([
 	"IMG",
 	"SVG",
 	"VIDEO",
@@ -9002,10 +8904,10 @@ const RUN_BREAKERS = [
 	`[${ROOT_ATTR}]`
 ].join(",");
 /**
-* A child element whose glyph ink belongs to its parent block's run rather than
-* to a Bone of its own: a pure `display: inline` text wrapper (`<span>`, `<a>`,
-* `<em>`) with no replaced-media or nested-Skeleton descendant. Inline-block and
-* friends are atomic boxes, not text flow, so they are NOT folded.
+* A child element whose glyph ink belongs to its parent block's run rather than to a Bone of its
+* own: a pure `display: inline` text wrapper (`<span>`, `<a>`, `<em>`) with no replaced-media or
+* nested-Skeleton descendant. Inline-block and friends are atomic boxes, not text flow, so they are
+* NOT folded.
 */
 function isInlineTextElement(el, cs, styles) {
 	if (cs.display !== "inline") return false;
@@ -9018,7 +8920,10 @@ function isInlineTextElement(el, cs, styles) {
 	}
 	return true;
 }
-/** Collect the rendered text nodes under an inline text element into a run, skipping non-rendered tags. */
+/**
+* Collect the rendered text nodes under an inline text element into a run, skipping non-rendered
+* tags.
+*/
 function collectInlineText(el, into) {
 	for (const child of Array.from(el.childNodes)) if (isTextNode(child)) into.push(child);
 	else if (isElementNode(child) && !SKIP_TAGS.has(child.tagName.toUpperCase())) collectInlineText(child, into);
@@ -9035,9 +8940,9 @@ function runTextRect(run) {
 	return r.getBoundingClientRect();
 }
 /**
-* The rect of the text a leading glyph-media would abut: the immediately
-* following text node or inline text element (e.g. the "4.9" after a "★" icon).
-* Replaced media and absent/blank text yield null — a glyph needs text to hug.
+* The rect of the text a leading glyph-media would abut: the immediately following text node or
+* inline text element (e.g. the "4.9" after a "★" icon). Replaced media and absent/blank text yield
+* null — a glyph needs text to hug.
 */
 function nextTextRect(nodes, i, styles) {
 	const next = nodes[i + 1];
@@ -9054,15 +8959,13 @@ function nextTextRect(nodes, i, styles) {
 	return null;
 }
 /**
-* The pure GEOMETRY of the glyph-fold (ADR 0021 §2): does a media rect read as a
-* GLYPH hugging the text `adj` on the same ROW — emoji-sized (≤ 1.5× line-height),
-* sharing the line (≥ 50% vertical overlap), and abutting within ~a space (gap ≤
-* 0.6× line-height)? A bigger icon, or one set off by a gutter (a section-heading
-* icon), fails and stays its own Bone. DISPLAY-AGNOSTIC on purpose: the caller
-* decides whether to also require inline-level (`foldsAsGlyph`, the in-flow path)
-* or rely on geometry alone (the flex/grid "row anything" post-pass,
-* `foldGlyphRows`). `adj` is the text it abuts. This size + spacing test is
-* Salience's surviving role.
+* The pure GEOMETRY of the glyph-fold (ADR 0021 §2): does a media rect read as a GLYPH hugging the
+* text `adj` on the same ROW — emoji-sized (≤ 1.5× line-height), sharing the line (≥ 50% vertical
+* overlap), and abutting within ~a space (gap ≤ 0.6× line-height)? A bigger icon, or one set off by
+* a gutter (a section-heading icon), fails and stays its own Bone. DISPLAY-AGNOSTIC on purpose: the
+* caller decides whether to also require inline-level (`foldsAsGlyph`, the in-flow path) or rely on
+* geometry alone (the flex/grid "row anything" post-pass, `foldGlyphRows`). `adj` is the text it
+* abuts. This size + spacing test is Salience's surviving role.
 */
 function glyphGeometry(mediaRect, adj, lineHeight) {
 	if (lineHeight <= 0 || !adj) return false;
@@ -9074,27 +8977,23 @@ function foldsAsGlyph(mediaCs, mediaRect, adj, lineHeight) {
 	return isInlineish(mediaCs.display) && glyphGeometry(mediaRect, adj, lineHeight);
 }
 /**
-* APPLY-WALKER — the programmable capture walker as a PASS over the measured IR
-* (ADR 0018; ADR 0022 §5). Replaces the old mid-walk ladder: the walker no longer
-* runs DURING the DOM walk (so the full subtree is always measured), it is offered
-* each element TOP-DOWN over the built IR and its decision is LOWERED here by
-* setting the same `markKind`/`dropped` fields the `data-xr-*` attribute path sets
-* (Loop 6.1), so `markInk` (which runs next, in `build`) realizes them uniformly:
-*   - `ignore` → `dropped: { reason: 'ignored' }`; the node + subtree lower (NOT
-*     recursed — the descent stops, mirroring the old walk-time `ctx.ignore()`).
-*   - `bone`   → `markKind = kind ?? inferLeafKind(el)`; `markInk`'s re-stamp lowers
-*     it to ONE childless bone of that kind (NOT recursed — the old `ctx.bone()`
-*     never descended either).
-*   - `keep` (or no `element` hook) → recurse into the kid's kids (defer to the
-*     default classifier).
+* APPLY-WALKER — the programmable capture walker as a PASS over the measured IR (ADR 0018; ADR 0022
+* §5). The walker does not run during the DOM walk (the full subtree is always measured); each
+* element is offered TOP-DOWN over the built IR and the decision is LOWERED here by setting the
+* same `markKind`/`dropped` fields the `data-xr-*` hint path sets, so `markInk` (which runs next,
+* in `build`) realizes them uniformly:
+*
+* - `ignore` → `dropped: { reason: 'ignored' }`; the node + subtree lower (NOT recursed — the descent
+*   stops).
+* - `bone` → `markKind = kind ?? inferLeafKind(el)`; `markInk`'s re-stamp lowers it to ONE childless
+*   bone of that kind (NOT recursed).
+* - `keep` (or no `element` hook) → recurse into the kid's kids (defer to the default classifier).
 *
-* Iterates a node's KIDS rather than visiting the node itself, so the synthetic
-* root / synthetic text bars (`el === null`) are never offered — but their kids
-* are still visited. A stitch (`kind: 'stitch'`, no `el`) is skipped (opaque —
-* ADR 0006: a walker can never reach a nested `<Skeleton>`), and a kid the walker
-* ignores/bones is not recursed (the pruning the old walk got for free by
-* returning before descending). Pure on `el` — the `ctx` helpers return a
-* decision; this pass is the only mutator.
+* Iterates a node's KIDS rather than visiting the node itself, so the synthetic root / synthetic
+* text bars (`el === null`) are never offered — but their kids are still visited. A stitch (`kind:
+* 'stitch'`, no `el`) is skipped (opaque — ADR 0006: a walker can never reach a nested
+* `<Skeleton>`), and a kid the walker ignores/bones is not recursed. Pure on `el` — the `ctx`
+* helpers return a decision; this pass is the only mutator.
 */
 function applyWalker(node, walker) {
 	if (!walker.element) return;
@@ -9132,13 +9031,12 @@ function parseRgb(value) {
 }
 const rgbCache = /* @__PURE__ */ new Map();
 /**
-* Resolve any computed CSS colour to sRGB bytes. `rgb()/rgba()` parse directly
-* (the cheap path, and the only one a layout-less test env needs); everything
-* else — `oklch()`, `color()`, `hsl()`, named — is painted onto a 1×1 canvas
-* and read back, since browsers serialise a computed colour in the space it was
-* authored in (Chrome returns `oklch(...)` verbatim), which a regex can't read.
-* Without this an oklch-filled control reads as no fill and never becomes a box.
-* Cached by string: the same token recurs across every node of a themed card.
+* Resolve any computed CSS colour to sRGB bytes. `rgb()/rgba()` parse directly (the cheap path, and
+* the only one a layout-less test env needs); everything else — `oklch()`, `color()`, `hsl()`,
+* named — is painted onto a 1×1 canvas and read back, since browsers serialise a computed colour in
+* the space it was authored in (Chrome returns `oklch(...)` verbatim), which a regex can't read.
+* Without this an oklch-filled control reads as no fill and never becomes a box. Cached by string:
+* the same token recurs across every node of a themed card.
 */
 function toRgb(value, win) {
 	const direct = parseRgb(value);
@@ -9177,13 +9075,12 @@ function hasVisibleBackground(cs, win) {
 /** Fill that visibly contrasts with the nearest painted ancestor — meaning ~24 per channel. */
 const FILL_CONTRAST = 72;
 /**
-* The nearest ancestor that actually paints a background, resolved to sRGB, or
-* null when nothing up the chain paints. Ancestor styles come from the
-* per-capture memo (piece 5): a deep card's parents are climbed once per check
-* but resolved once per capture. This is the `behind` colour both the
-* `hasContrastingFill` boolean and the Salience contrast axis score a node's own
-* fill/border against — extracted so the two read the SAME measured ground (the
-* salience.ts scorer takes `behind` as an input rather than climbing itself).
+* The nearest ancestor that actually paints a background, resolved to sRGB, or null when nothing up
+* the chain paints. Ancestor styles come from the per-capture memo (`StyleCache`): a deep card's
+* parents are climbed once per check but resolved once per capture. This is the `behind` colour
+* both the `hasContrastingFill` boolean and the Salience contrast axis score a node's own
+* fill/border against — extracted so the two read the SAME measured ground (the salience.ts scorer
+* takes `behind` as an input rather than climbing itself).
 */
 function nearestPaintedBackground(el, win, styles) {
 	for (let ancestor = el.parentElement; ancestor; ancestor = ancestor.parentElement) {
@@ -9193,17 +9090,14 @@ function nearestPaintedBackground(el, win, styles) {
 	return null;
 }
 /**
-* Does this element paint a fill that stands out from what's behind it? A
-* background image always counts; a background color counts only when it's
-* mostly opaque and clearly differs from the nearest ancestor's background
-* (so a white button on a white card doesn't, but a blue one does).
+* Does this element paint a fill that stands out from what's behind it? A background image always
+* counts; a background color counts only when it's mostly opaque and clearly differs from the
+* nearest ancestor's background (so a white button on a white card doesn't, but a blue one does).
 *
-* This is the fill-ONLY signal Absorb has always used. Measure runs it once and
-* snapshots the result onto `IRNode.paint.contrastingFill` (3a); the pure
-* `markInk`-side `surfaceAbsorbs` reads that snapshot for the fill case (so every
-* fill that collapsed before still collapses) and ADDS the Salience contrast axis on
-* top to catch a contrasting BORDER or BOX-SHADOW surface (ADR 0021 §3 — "the
-* existing `hasContrastingFill` branch, generalized").
+* This is the fill-ONLY signal Absorb keys on. Measure runs it once and snapshots the result onto
+* `IRNode.paint.contrastingFill`; the pure `markInk`-side `surfaceAbsorbs` reads that snapshot for
+* the fill case and ADDS the Salience contrast axis on top to catch a contrasting BORDER or
+* BOX-SHADOW surface (ADR 0021 §3 — the `hasContrastingFill` branch, generalized).
 */
 function hasContrastingFill(el, cs, win, styles) {
 	if (hasPaintedImage(cs)) return true;
@@ -9218,12 +9112,11 @@ function hasContrastingFill(el, cs, win, styles) {
 	return Math.abs(bg.r - base.r) + Math.abs(bg.g - base.g) + Math.abs(bg.b - base.b) > FILL_CONTRAST;
 }
 /**
-* The base/context font-size in px the Salience type-scale axis is measured
-* relative to: the inherited font-size of the capture subtree's context (the
-* parent of the first real element), defaulting to the CSS 16px when there is no
-* context or it does not resolve to px. Computed once per capture would be ideal,
-* but the contexts the walk touches are few and the StyleCache makes the parent
-* lookup free, so it is read on demand at each score site.
+* The base/context font-size in px the Salience type-scale axis is measured relative to: the
+* inherited font-size of the capture subtree's context (the parent of the first real element),
+* defaulting to the CSS 16px when there is no context or it does not resolve to px. Computed once
+* per capture would be ideal, but the contexts the walk touches are few and the StyleCache makes
+* the parent lookup free, so it is read on demand at each score site.
 */
 function contextBaseFontSizePx(el, styles) {
 	const parent = el.parentElement;
@@ -9232,13 +9125,12 @@ function contextBaseFontSizePx(el, styles) {
 	return sizePx !== null && sizePx > 0 ? sizePx : 16;
 }
 /**
-* Score one element's visual relevance by handing salience.ts the three inputs
-* the walk already has: the element's computed style, its rendered box, and the
-* measured context (nearest painted ancestor `behind`, base font-size, the
-* capture root's area for the size axis). `rootArea` is threaded from `walkAll`
-* so every node is normalized against the SAME reference; a non-positive value
-* (a layout-less env, or an unmeasured root) disables the size axis in the scorer
-* rather than dividing by zero. Pure pass-through — the scorer owns the math.
+* Score one element's visual relevance by handing salience.ts the three inputs the walk already
+* has: the element's computed style, its rendered box, and the measured context (nearest painted
+* ancestor `behind`, base font-size, the capture root's area for the size axis). `rootArea` is
+* threaded from `walkAll` so every node is normalized against the SAME reference; a non-positive
+* value (a layout-less env, or an unmeasured root) disables the size axis in the scorer rather than
+* dividing by zero. Pure pass-through — the scorer owns the math.
 */
 function nodeSalience(el, cs, rect, rootArea, win, styles) {
 	return salience(cs, rect, {
@@ -9252,21 +9144,17 @@ function rgbaString(c) {
 	return c.a < 1 ? `rgba(${c.r}, ${c.g}, ${c.b}, ${c.a})` : `rgb(${c.r}, ${c.g}, ${c.b})`;
 }
 /**
-* Measure-time paint + salience resolution (ADR 0022 invariants 3 & 5; capture
-* pipeline Phase 3a). Runs the SAME canvas-resolving helpers the classification
-* uses lazily today, but eagerly — once, per element entry, while layout is warm —
-* and snapshots the result onto the node so a future markInk pass reads it off the
-* IR rather than re-touching the DOM. This is ADDITIVE: classification still reads
-* its own live values, so the emitted plate is byte-identical; these fields are
-* populated-but-not-yet-read.
+* Measure-time paint + salience resolution (ADR 0022 invariants 3 & 5). Runs the canvas-resolving
+* helpers eagerly — once, per element entry, while layout is warm — and snapshots the result onto
+* the node, so `markInk`/Absorb read it off the IR rather than re-touching the DOM.
 *
-* - `paint.surface`/`bg`/`contrastingFill`/`radius` come from the existing
-*   `hasVisibleBackground` / `toRgb` / `hasContrastingFill` helpers and the
-*   computed `border-radius`. The `bg` is the canvas-resolved colour, so a later
-*   pass single-sources the colour through `toRgb` (no second parse path).
-* - `salience` is `nodeSalience`, which resolves the ancestor-climbed `behind`
-*   (via `toRgb`) and base font-size — both legal at measure time — so salience's
-*   own colour mirror never has to fall back on the capture path.
+* - `paint.surface`/`bg`/`contrastingFill`/`radius` come from the existing `hasVisibleBackground` /
+*   `toRgb` / `hasContrastingFill` helpers and the computed `border-radius`. The `bg` is the
+*   canvas-resolved colour, so a later pass single-sources the colour through `toRgb` (no second
+*   parse path).
+* - `salience` is `nodeSalience`, which resolves the ancestor-climbed `behind` (via `toRgb`) and base
+*   font-size — both legal at measure time — so salience's own colour mirror never has to fall back
+*   on the capture path.
 */
 function resolvePaintAndSalience(el, cs, rect, state) {
 	const bg = toRgb(cs.backgroundColor, state.win);
@@ -9281,6 +9169,11 @@ function resolvePaintAndSalience(el, cs, rect, state) {
 		salience: nodeSalience(el, cs, rect, state.rootArea, state.win, state.styles)
 	};
 }
+/**
+* Thrown when a capture's measured tree exceeds a Collect limit — almost always a `<Skeleton>`
+* sitting too high in the tree. Raised after the cheap walk and before the O(rules × nodes) CSS
+* extraction, so an oversized capture is refused without freezing the main thread on it.
+*/
 var CaptureTooLargeError = class extends Error {
 	/** The full measured size of the surviving tree that tripped the gate. */
 	size;
@@ -9301,20 +9194,17 @@ var CaptureTooLargeError = class extends Error {
 	}
 };
 /**
-* The build phase (capture-pipeline Phase 1.5): the walk already built the
-* light-DOM IR directly (`walkAll` returns `{ root, nodes, extraRules }`), so this
-* just lifts the author CSS onto it. The CSS-extract (`copyRules`) fills each
-* node's `decls.author` (the lifted CSSOM + inline rules targeting it) and
-* `decls.carried` (the carried token-definition rules anchored to it, ADR 0019 §1),
-* so the IR holds every node's authored CSS — the substrate `emit` reads back out.
-* Gates on node count BEFORE the O(author rules × nodes) extract, as the legacy
-* path did.
+* The build phase: the walk builds the light-DOM IR directly (`walkAll` returns `{ root, nodes,
+* extraRules }`); this lifts the author CSS onto it. The CSS-extract (`copyRules`) fills each
+* node's `decls.author` (the lifted CSSOM + inline rules targeting it) and `decls.carried` (the
+* carried token-definition rules anchored to it, ADR 0019 §1), so the IR holds every node's
+* authored CSS — the substrate `emit` reads back out. Gates on the Collect limits BEFORE the
+* O(author rules × nodes) extract.
 *
-* `copyRules` still returns the full flat rule list (its primary job here is the
-* `decls` population); `emit` rebuilds that list from the IR, so the return is
-* dropped — EXCEPT the one rule not anchored to any node: the text-context rule
-* (`ids: []`, the inherited parent font `baseRules` derives), lifted onto the
-* bundle for `emit` to fold back in.
+* `copyRules` still returns the full flat rule list (its primary job here is the `decls`
+* population); `emit` rebuilds that list from the IR, so the return is dropped — EXCEPT the one
+* rule not anchored to any node: the text-context rule (`ids: []`, the inherited parent font
+* `baseRules` derives), lifted onto the bundle for `emit` to fold back in.
 */
 function build(walked, doc, win, styles, diagnostics, collect, walker) {
 	const bundle = {
@@ -9335,28 +9225,27 @@ function build(walked, doc, win, styles, diagnostics, collect, walker) {
 	return bundle;
 }
 /**
-* Run the per-View reduction passes over one measured `IRBundle`, in their fixed,
-* load-bearing order (ADR 0022 §3). Annotate-only — each pass sets fields (`folded`/
-* `flattened`/`count`/`dropped`); `emit`/Serialize lower them. Lifted out of `build`
-* (the Measure core — `markInk` + the node-count gate + the CSS-extract — stays
-* there, since `markInk` must run before the gate) so the reductions are a pure
-* `bundle → bundle` step `runPlatePasses` runs once per View over a whole `PlateIR`
-* after the sweep (reading the snapshotted `ViewIR.viewportHeight`, since `window`
-* has moved on). `diagnostics` collects the Superset/Crop notes.
+* Run the per-View Distil passes over one measured `IRBundle`, in their fixed, load-bearing order
+* (ADR 0022 §3). Annotate-only — each pass sets fields (`folded`/ `flattened`/`count`/`dropped`);
+* `emit`/Serialize lower them. Kept apart from `build` (the Measure core — `markInk` + the Collect
+* gate + the CSS-extract — where `markInk` must run before the gate) so Distil is a pure `bundle →
+* bundle` step `distilPlate` runs once per View over a whole `PlateIR` after the sweep (reading the
+* snapshotted `ViewIR.viewportHeight`, since `window` has moved on). `diagnostics` collects the
+* Superset/Crop notes.
 *
 * Order: glyph-fold → Flatten → Superset → Crop → Template.
-* - glyph-fold first: folds glyph-sized icons into adjacent text lines (ADR 0021 §2).
-* - Flatten next: collapses passthrough wrapper chains over the folded tree (ADR 0021 §1).
-*   These two are lossless normalization the removal passes read.
-* - Superset / Crop: the "drop the imperceptible" pair — bone-on-bone (Superset) and
-*   off-screen (Crop) — both only annotate `dropped`, so their relative order is
-*   immaterial; Superset stays before Crop. Crop's base-case folds are `viewportHeight`
-*   (vertical) and `viewportWidth` (horizontal); CROP_BUFFER stays internal to the pass.
-* - Template LAST: compression operates only on what SURVIVES the removal passes, so it
-*   only ever compresses what a human would actually see (the owner's guiding principle).
-*   Crop drops a run's off-screen tail first; Template then groups the on-screen prefix
-*   and the faithful surviving `count` falls out of the fold (a dropped cell breaks a
-*   template run).
+*
+* - Glyph-fold first: folds glyph-sized icons into adjacent text lines (ADR 0021 §2).
+* - Flatten next: collapses passthrough wrapper chains over the folded tree (ADR 0021 §1). These two
+*   are lossless normalization the removal passes read.
+* - Superset / Crop: the "drop the imperceptible" pair — bone-on-bone (Superset) and off-screen
+*   (Crop) — both only annotate `dropped`, so their relative order is immaterial; Superset stays
+*   before Crop. Crop's base-case folds are `viewportHeight` (vertical) and `viewportWidth`
+*   (horizontal); CROP_BUFFER stays internal to the pass.
+* - Template LAST: compression operates only on what SURVIVES the removal passes — what a viewer
+*   would actually see. Crop drops a run's off-screen tail first; Template then groups the
+*   on-screen prefix and the faithful surviving `count` falls out of the fold (a dropped cell
+*   breaks a template run).
 */
 function runPasses(bundle, viewportHeight, viewportWidth, diagnostics) {
 	foldGlyphRowsIR(bundle.root);
@@ -9366,19 +9255,17 @@ function runPasses(bundle, viewportHeight, viewportWidth, diagnostics) {
 	templateIR(bundle);
 }
 /**
-* Run the reduction passes over every View of a `PlateIR` (ADR 0022 §3) — the
-* `PlateIR → PlateIR` pass model, via `eachView`. Each View gets its own
-* diagnostics collector (the passes' Superset/Crop notes), merged onto the View's
-* existing (Measure-time) diagnostics — a dev-only transient (stripped before disk),
-* so the merge order is immaterial. Crop reads the View's snapshotted folds: the
-* vertical base case is `viewportHeight` (an unset one passes `Infinity`, disabling
-* the base-case viewport fold — a fold of 0 would crop EVERYTHING, `top >= 1.5 * 0`,
-* so a manually-built bundle still folds only at a per-node clipping ancestor); the
-* horizontal base case is the View's `width` (its captured `innerWidth`, always set).
-* The orchestration (step 4.4) calls this once after building the bundle in one
-* session.
+* Run the Distil passes over every View of a `PlateIR` (ADR 0022 §3) — the `PlateIR → PlateIR` pass
+* model, via `eachView`. Each View gets its own diagnostics collector (the passes' Superset/Crop
+* notes), merged onto the View's existing (Measure-time) diagnostics — a dev-only transient
+* (stripped before disk), so the merge order is immaterial. Crop reads the View's snapshotted
+* folds: the vertical base case is `viewportHeight` (an unset one passes `Infinity`, disabling the
+* base-case viewport fold — a fold of 0 would crop EVERYTHING, `top >= 1.5 * 0`, so a
+* manually-built bundle still folds only at a per-node clipping ancestor); the horizontal base case
+* is the View's `width` (its captured `innerWidth`, always set). The orchestration calls this once
+* after building the bundle in one session.
 */
-function runPlatePasses(plate) {
+function distilPlate(plate) {
 	eachView(plate, (view) => {
 		const diagnostics = createDiagnostics();
 		runPasses(view.bundle, view.viewportHeight ?? Number.POSITIVE_INFINITY, view.width, diagnostics);
@@ -9387,19 +9274,17 @@ function runPlatePasses(plate) {
 	});
 }
 /**
-* Measure the SURVIVING (non-dropped) tree in one DFS pass: total `nodes`, max
-* nesting `depth`, and `breadth` — the widest level (most nodes at any one depth).
+* Measure the SURVIVING (non-dropped) tree in one DFS pass: total `nodes`, max nesting `depth`, and
+* `breadth` — the widest level (most nodes at any one depth).
 *
-* Walks via `effectiveKids`, so a `dropped` node (and its non-re-shown subtree) and
-* a `flattened` wrapper are handled exactly as `emit` will lower them — the gate
-* measures the real post-mark output, not every element Measure descended. The
-* synthetic root (id 0, el null) is NOT a measured entry, so it is excluded,
-* keeping `nodes` in the same units as the legacy `entries.length` gate.
+* Walks via `effectiveKids`, so a `dropped` node (and its non-re-shown subtree) and a `flattened`
+* wrapper are handled exactly as `emit` will lower them — the gate measures the real post-mark
+* output, not every element Measure descended. The synthetic root (id 0, el null) is NOT a measured
+* entry, so it is excluded and `nodes` counts only measured entries.
 *
-* Widest-level `breadth` is the realistic "how wide does this tree get" signal: a
-* DOM tree's total tracks its widest level (~5×), not `breadth × depth` (which
-* assumes every level is maximally wide — a fractal that never occurs). Feeds the
-* Collect gate.
+* Widest-level `breadth` is the realistic "how wide does this tree get" signal: a DOM tree's total
+* tracks its widest level (~5×), not `breadth × depth` (which assumes every level is maximally wide
+* — a fractal that never occurs). Feeds the Collect gate.
 */
 function measureTree(root) {
 	let nodes = 0;
@@ -9424,17 +9309,15 @@ function measureTree(root) {
 	};
 }
 /**
-* Measure one View's subtree into an `IRBundle` — the Measure stage (ADR 0022
-* invariant 5): the sole DOM-touching code on the capture path. Sets up the
-* per-capture computed-style memo (built here, discarded when this synchronous
-* capture returns — never outlives the call, so no cross-capture caching of live
-* styles), runs the walk (which builds the light-DOM IR directly), and runs the
-* build phase (capture-pipeline Phase 1.5): lift the author CSS onto each node's
-* `decls`, then run the annotate passes. Returns the bundle alongside the
-* `win` (for the viewport width) and the `diagnostics` collector, so the two
-* callers — `captureBundle` (the raw bundle, for tests) and `captureView` (→ a
-* `PlateIR` View) — each shape the result without re-walking. `emit`/Serialize
-* read the IR back out.
+* Measure one View's subtree into an `IRBundle` — the Measure stage (ADR 0022 invariant 5): the
+* sole DOM-touching code on the capture path. Sets up the per-capture computed-style memo (built
+* here, discarded when this synchronous capture returns — never outlives the call, so no
+* cross-capture caching of live styles), runs the walk (which builds the light-DOM IR directly),
+* and runs the build phase: lift the author CSS onto each node's `decls`, then run the annotate
+* passes. Returns the bundle alongside the `win` (for the viewport width) and the `diagnostics`
+* collector, so the two callers — `captureBundle` (the raw bundle, for tests) and `captureView` (→
+* a `PlateIR` View) — each shape the result without re-walking. `emit`/Serialize read the IR back
+* out.
 */
 function measureBundle(roots, options = {}) {
 	const doc = roots[0]?.ownerDocument;
@@ -9449,17 +9332,15 @@ function measureBundle(roots, options = {}) {
 	};
 }
 /**
-* The framework-agnostic capture core (ADR 0022 §1,§2): measure one View's subtree
-* and APPEND it to a per-Plate `PlateIR` bundle — `capture(el, ir?) → ir` in the
-* end-state vocabulary. The single entry point for capture: the dev client sweeps
-* every View through it, and the framework-neutral `captureElement` (core.ts) runs
-* it once for the single-View case, both then reducing via `runPlatePasses` and
-* projecting via `serializePlateIR`. Walks the View's `roots` into an `IRBundle`
-* (Measure + build), wraps it as a `ViewIR` at the current viewport width with the
-* capture's transient diagnostics, and appends it to the passed-in `plate` (the
-* orchestration threads ONE bundle through a Plate's per-View calls in one session,
-* ADR 0022 §2). With no `plate` it starts a fresh, as-yet-UNNAMED bundle — naming
-* and the breakpoint union are the orchestration's job (Views are orchestration,
+* The framework-agnostic capture core (ADR 0022 §1,§2): measure one View's subtree and APPEND it to
+* a per-Plate `PlateIR` bundle — ADR 0022 §1's `capture(el, ir?) → ir`. The single entry point for
+* capture: the dev client sweeps every View through it, and the framework-neutral `captureElement`
+* (core.ts) runs it once for the single-View case, both then distilling via `distilPlate` and
+* projecting via `serializePlateIR`. Walks the View's `roots` into an `IRBundle` (Measure + build),
+* wraps it as a `ViewIR` at the current viewport width with the capture's transient diagnostics,
+* and appends it to the passed-in `plate` (the orchestration threads ONE bundle through a Plate's
+* per-View calls in one session, ADR 0022 §2). With no `plate` it starts a fresh, as-yet-UNNAMED
+* bundle — naming and the breakpoint union are the orchestration's job (Views are orchestration,
 * not core, §1), so the caller sets `name`/`breakpoints` on the returned `PlateIR`.
 */
 function captureView(roots, options = {}, plate) {
@@ -9537,16 +9418,15 @@ function walk(el, state, depth, isCaptureRoot = false) {
 			ref: refName
 		};
 	}
-	return annotationWalk(el, cs, state, depth);
+	return hintWalk(el, cs, state, depth);
 }
 /**
-* The built-in annotation walker (ADR 0018), the rung between the stitch guard
-* and the default classifier. It honors the capture-only `data-xr-*`
-* annotations and otherwise falls through to the default classifier. The stitch
-* guard already ran in `walk`, so a boundary element never reaches here — an
-* annotation can never override a nested `<Skeleton>` (ADR 0006).
+* The built-in Hint rung (ADR 0018), between the stitch guard and the default classifier. It honors
+* the capture-only `data-xr-*` hints and otherwise falls through to the default classifier. The
+* stitch guard already ran in `walk`, so a boundary element never reaches here — a hint can never
+* override a nested `<Skeleton>` (ADR 0006).
 */
-function annotationWalk(el, cs, state, depth) {
+function hintWalk(el, cs, state, depth) {
 	if (el.hasAttribute(XR_IGNORE_ATTR)) return ignoreElement(state);
 	const kindAttr = el.getAttribute(XR_BONE_KIND_ATTR);
 	if (kindAttr !== null) {
@@ -9557,27 +9437,24 @@ function annotationWalk(el, cs, state, depth) {
 	return defaultClassify(el, cs, state, depth);
 }
 /**
-* `data-xr-ignore`: drop the element and its subtree at WALK TIME. No Entry, no
-* node, no descent — it contributes nothing to the Plate, and never reaches the
-* IR (so it never produces a `dropped: 'ignored'`, which is the walker-only
-* post-measure path; ADR 0022 §5). Aggregated under the existing `dropped-tag`
-* diagnostic (a hidden/non-visual drop is the same fidelity story; do not spam a
-* new code per ignored element).
+* `data-xr-ignore`: drop the element and its subtree at WALK TIME. No Entry, no node, no descent —
+* it contributes nothing to the Plate, and never reaches the IR (so it never produces a `dropped:
+* 'ignored'`, which is the walker-only post-measure path; ADR 0022 §5). Aggregated under the
+* existing `dropped-tag` diagnostic (a hidden/non-visual drop is the same fidelity story; do not
+* spam a new code per ignored element).
 */
 function ignoreElement(state) {
 	state.diagnostics.add("dropped-tag");
 	return null;
 }
 /**
-* Snapshot the raw clip inputs onto an IR node for the 2D Crop pass — one pair per
-* axis, each gated on its OWN overflow not being `visible`. The vertical pair
-* (`scrollHeight`/`clientHeight`, gated on `overflow-y`) and the horizontal pair
-* (`scrollWidth`/`clientWidth`, gated on `overflow-x`) are element PROPS, not on the
-* computed-style object and not derivable later, so they must be read at measure
-* time while layout is valid; reading them CAN force a layout, so each gate keeps it
-* off the `overflow: visible` majority for that axis. Layout is already warm here
-* (the caller just read `getBoundingClientRect`). The walk only records; `cropIR`
-* derives the fold.
+* Snapshot the raw clip inputs onto an IR node for the 2D Crop pass — one pair per axis, each gated
+* on its OWN overflow not being `visible`. The vertical pair (`scrollHeight`/`clientHeight`, gated
+* on `overflow-y`) and the horizontal pair (`scrollWidth`/`clientWidth`, gated on `overflow-x`) are
+* element PROPS, not on the computed-style object and not derivable later, so they must be read at
+* measure time while layout is valid; reading them CAN force a layout, so each gate keeps it off
+* the `overflow: visible` majority for that axis. Layout is already warm here (the caller just read
+* `getBoundingClientRect`). The walk only records; `cropIR` derives the fold.
 */
 function snapshotClipInputs(el, cs, node) {
 	if (cs.overflowY !== "visible") {
@@ -9590,23 +9467,19 @@ function snapshotClipInputs(el, cs, node) {
 	}
 }
 /**
-* The kind-inference heuristic shared by the walker's `ctx.bone()` without an
-* explicit kind (via the `applyWalker` pass) and the default classifier (ADR
-* 0018, Q4 — ONE code path). A media tag is
-* `media`; anything else collapsed to a single bone reads as a `box`. The
-* default classifier reaches the same outcomes through its own structural
-* branches (MEDIA_TAGS -> media, contrasting fill / painted empty -> box), so
-* keeping this one function is the single source of truth for "what kind is an
-* element that has no children to descend into".
+* The kind-inference heuristic shared by the walker's `ctx.bone()` without an explicit kind (via
+* the `applyWalker` pass) and the default classifier (ADR 0018, Q4 — ONE code path). A media tag is
+* `media`; anything else collapsed to a single bone reads as a `box`. The default classifier
+* reaches the same outcomes through its own structural branches (MEDIA_TAGS -> media, contrasting
+* fill / painted empty -> box), so keeping this one function is the single source of truth for
+* "what kind is an element that has no children to descend into".
 */
 function inferLeafKind(el) {
 	return MEDIA_TAGS.has(el.tagName.toUpperCase()) ? "media" : "box";
 }
 /**
-* The DEFAULT classifier — the unchanged step-4 body, extracted so the
-* precedence ladder's `next()` can call it (ADR 0018). With no walker and no
-* annotations this is the only path taken, and its output is byte-identical to
-* before the ladder was introduced.
+* The DEFAULT classifier — the precedence ladder's last rung (ADR 0018). With no walker and no
+* hints this is the only path taken.
 */
 function defaultClassify(el, cs, state, depth, markKind) {
 	const tag = el.tagName.toUpperCase();
@@ -9726,22 +9599,21 @@ function defaultClassify(el, cs, state, depth, markKind) {
 //#endregion
 //#region src/chunk.ts
 /**
-* Serialize a merged plate's RenderNode tree into the shipped `Plate` (ADR
-* 0008). This is the framework-neutral half of rendering: a skeleton is static,
-* text-free DOM, so the structure is flattened to HTML strings here, at build,
-* once — instead of every adapter walking a tree on the latency-critical first
-* paint. The adapter only injects the strings and mounts a child plate at each
-* stitch (see the React adapters). No escaping risk: bones carry only the
-* content-addressed class tokens (ADR 0007), never user content.
+* Serialize a merged plate's RenderNode tree into the shipped `Plate` (ADR 0008). This is the
+* framework-neutral half of rendering: a skeleton is static, text-free DOM, so the structure is
+* flattened to HTML strings here, at build, once — instead of every adapter walking a tree on the
+* latency-critical first paint. The adapter only injects the strings and mounts a child plate at
+* each stitch (see the React adapters). No escaping risk: bones carry only the content-addressed
+* class tokens (ADR 0007), never user content.
 */
 function nodeClass(node) {
 	return NODE_CLASS + (node.leaf ? ` ${LEAF_CLASS} ${LEAF_CLASS}-${node.leaf}` : "") + (node.cls ? ` ${node.cls}` : "");
 }
 /**
-* Whether this subtree holds a render-time DYNAMIC node anywhere — a stitch
-* (`ref`, a mount point resolved to a child plate) or a template (`count`, a cell
-* the adapter repeats). Either keeps the subtree from collapsing to one flat
-* string, since both are expanded at render rather than baked into the markup.
+* Whether this subtree holds a render-time DYNAMIC node anywhere — a stitch (`ref`, a mount point
+* resolved to a child plate) or a template (`count`, a cell the adapter repeats). Either keeps the
+* subtree from collapsing to one flat string, since both are expanded at render rather than baked
+* into the markup.
 */
 function hasDynamic(node) {
 	return node.ref !== void 0 || node.count !== void 0 || (node.kids?.some(hasDynamic) ?? false);
@@ -9752,13 +9624,12 @@ function toHtml(node) {
 	return `<div class="${nodeClass(node)}">${kids}</div>`;
 }
 /**
-* Serialize a node list into chunks: each maximal run with no render-time dynamic
-* node becomes one HTML `string`; a `ref` node becomes `{ r }`; a `count` node
-* becomes `{ t: html, n }` (its cell's HTML once + the repeat count); a node that
-* isn't itself dynamic but holds one deeper stays a real element (`{ c, k }`) and
-* recurses. Mirrors the element shape the runtime renderer would otherwise build
-* per node. A `count` cell is guaranteed stitch-free by the capture pass, so its
-* `toHtml` is a plain string the adapter repeats.
+* Serialize a node list into chunks: each maximal run with no render-time dynamic node becomes one
+* HTML `string`; a `ref` node becomes `{ r }`; a `count` node becomes `{ t: html, n }` (its cell's
+* HTML once + the repeat count); a node that isn't itself dynamic but holds one deeper stays a real
+* element (`{ c, k }`) and recurses. Mirrors the element shape the runtime renderer would otherwise
+* build per node. A `count` cell is guaranteed stitch-free by the capture pass, so its `toHtml` is
+* a plain string the adapter repeats.
 */
 function toChunks(nodes) {
 	const out = [];
@@ -9789,41 +9660,41 @@ function toChunks(nodes) {
 	return out;
 }
 /**
-* Turn a merged plate (RenderNode tree) into the shipped plate (chunks). The
-* root's own content classes travel as `rootCls` (the adapter puts them on the
-* root element); its children become `chunks`. A capture-less plate has null
-* chunks and renders the fallback.
+* Turn a merged plate (RenderNode tree) into the shipped plate (chunks). The root's own content
+* classes travel as `rootCls` (the adapter puts them on the root element); its children become
+* `chunks`. A capture-less plate has null chunks and renders the fallback.
+*
+* Two-artifact contract (ADR 0026): the returned `Plate` is the TREE artifact only; the input's
+* `css` is deliberately NOT copied onto it. The css string stays the producer's
+* (`GatedPlate`/`StoredPlate`) field, and each lowering site decides independently how its css
+* travels: the plugin's virtual `.css` modules + `export const css`, `captureElement`'s `{ plate,
+* css }` pair, or the `xray:plate` dev event, which ships no css.
 */
 function serializePlate(merged) {
-	const { v, name, tree, css } = merged;
+	const { v, name, tree } = merged;
 	if (!tree) return {
 		v,
 		name,
-		chunks: null,
-		css
+		chunks: null
 	};
 	const chunks = toChunks(tree.kids ?? []);
 	return tree.cls ? {
 		v,
 		name,
 		chunks,
-		rootCls: tree.cls,
-		css
+		rootCls: tree.cls
 	} : {
 		v,
 		name,
-		chunks,
-		css
+		chunks
 	};
 }
 /**
-* Distinct plate names referenced by the tree's stitches, in first-seen order.
-* Walks a `RenderNode` tree (the stored, post-classify shape), so it drives the
-* gen-side stitch import graph straight off a `StoredPlate.tree`
-* (`renderPlateModule`, index.ts). Relocated here from the now-deleted `merge.ts`
-* in the ADR 0022 cutover — it is the one node-side primitive that survived the
-* `mergeViews`/`addCapture` removal (the multi-View merge/gate now lives in the
-* in-browser `serializePlateIR`, project.ts).
+* Distinct plate names referenced by the tree's stitches, in first-seen order. Walks a `RenderNode`
+* tree (the stored, post-classify shape), so it drives the gen-side stitch import graph straight
+* off a `StoredPlate.tree` (`renderPlateModule`, index.ts). The one node-side primitive needed at
+* build time; multi-View gating happens in the in-browser `serializePlateIR` (serialize.ts, ADR
+* 0022).
 */
 function collectRefs(tree) {
 	const names = [];
@@ -9841,14 +9712,13 @@ function collectRefs(tree) {
 //#endregion
 //#region src/breakpoints.ts
 /**
-* Per-plate breakpoint derivation (ADR 0004): the width thresholds that could
-* change this plate come from the `@media` conditions on its own copied rules
-* plus the queries the app evaluated through `matchMedia` during capture.
-* Thresholds partition the width axis into views; identical captures in
-* adjacent views collapse at merge time.
+* Per-plate breakpoint derivation (ADR 0004): the width thresholds that could change this plate
+* come from the `@media` conditions on its own copied rules plus the queries the app evaluated
+* through `matchMedia` during capture. Thresholds partition the width axis into Views; identical
+* captures in adjacent Views collapse at Serialize.
 */
 const FONT_SIZE_PX = 16;
-/** A breakpoint is the first integer px width of the view ABOVE the boundary. */
+/** A breakpoint is the first integer px width of the View ABOVE the boundary. */
 function thresholdsOf(condition) {
 	const out = [];
 	const toPx = (value, unit) => Number.parseFloat(value) * (unit === "px" ? 1 : FONT_SIZE_PX);
@@ -9870,8 +9740,8 @@ function deriveBreakpoints(rules, matchMediaQueries = []) {
 	for (const query of matchMediaQueries) for (const bp of thresholdsOf(query)) set.add(bp);
 	return [...set].toSorted((a, b) => a - b);
 }
-/** The view interval `[min, max)` a given viewport width falls into. */
-function regimeFor(width, breakpoints) {
+/** The View interval `[min, max)` a given viewport width falls into. */
+function viewSpanFor(width, breakpoints) {
 	let min;
 	let max;
 	for (const bp of breakpoints) if (bp <= width) min = bp;
@@ -9887,17 +9757,14 @@ function regimeFor(width, breakpoints) {
 //#endregion
 //#region src/classify.ts
 /**
-* Turn id-form rules + an id-tree into the shipped plate: each distinct
-* `(tier, media, declarations)` becomes one class, named by a per-plate
-* sequential id (`[data-xr-root] .xr-<plate>-<n>`), and every node carries the
-* class tokens it needs instead of an id (ADR 0007). The id is a plain counter,
-* not a content hash: the plate prefix already keeps tokens disjoint across plates
-* (the stitch-isolation guarantee), so a per-plate counter is collision-free by
-* construction — and low-entropy ids compress far better than random hashes
-* (~31% smaller brotli on a real plate; see the ADR 0007 amendment). Rules stay
-* unlayered; the existing cascade is reproduced by emission order (losers
-* first), so the classes are emitted in `(layered, spec, order)` order exactly
-* as `renderRules` did.
+* Turn id-form rules + an id-tree into the shipped plate: each distinct `(tier, media,
+* declarations)` becomes one class, named by a per-plate sequential id (`[data-xr-root]
+* .xr-<plate>-<n>`), and every node carries the class tokens it needs instead of an id (ADR 0007).
+* The id is a plain counter, not a content hash: the plate prefix already keeps tokens disjoint
+* across plates (the stitch-isolation guarantee), so a per-plate counter is collision-free by
+* construction — and low-entropy ids compress far better than random hashes (~31% smaller brotli on
+* a real plate; see the ADR 0007 amendment). Rules stay unlayered; the cascade is reproduced by
+* emission order (losers first), so the classes are emitted in `(layered, spec, order)` order.
 *
 * Pure data-in/data-out — runs at plugin load (node) and in tests.
 */
@@ -9978,15 +9845,14 @@ function render(node, classes) {
 /** Content-class prefix; distinct from the fixed `xr-root/node/leaf` base words. */
 const CLASS_PREFIX = "xr-";
 /**
-* Font/text-rendering properties that are ALWAYS dead at generation. A bone paints
-* no glyphs, so these never reach its box — yet capture still emits them (the
-* inherited context rule, node fallbacks, lifted author rules), and
-* `filterLayoutDecls`/the validator legitimately accept them. `line-height` and
-* `font-size` are NOT here: each can be load-bearing, so `dropDeadDecls` keeps
-* them conditionally. KEEP `vertical-align`/`text-align`: they position
-* inline-block bones, not text.
+* Font/text-rendering properties that are ALWAYS dead at generation. A bone paints no glyphs, so
+* these never reach its box — yet capture still emits them (the inherited context rule, node
+* fallbacks, lifted author rules), and `filterLayoutDecls`/the validator legitimately accept them.
+* `line-height` and `font-size` are NOT here: each can be load-bearing, so `dropDeadDecls` keeps
+* them conditionally. KEEP `vertical-align`/`text-align`: they position inline-block bones, not
+* text.
 */
-const DROP_AT_GEN_ALWAYS = new Set([
+const DROP_AT_GEN_ALWAYS = /* @__PURE__ */ new Set([
 	"font",
 	"font-family",
 	"font-weight",
@@ -10000,11 +9866,11 @@ const DROP_AT_GEN_ALWAYS = new Set([
 	"text-wrap"
 ]);
 /**
-* An element-font-relative length (`em`/`ex`/`ch`) — resolves against the
-* element's own `font-size`, so dropping a per-node `font-size` would shift it.
-* EXCLUDES `rem` (root-relative, unaffected): its `em` is preceded by `r`, never
-* by a digit. Case-insensitive (author CSS may write `1EM`); the trailing `\b`
-* stops `2em` matching inside a longer identifier (`flex`, `text`).
+* An element-font-relative length (`em`/`ex`/`ch`) — resolves against the element's own
+* `font-size`, so dropping a per-node `font-size` would shift it. EXCLUDES `rem` (root-relative,
+* unaffected): its `em` is preceded by `r`, never by a digit. Case-insensitive (author CSS may
+* write `1EM`); the trailing `\b` stops `2em` matching inside a longer identifier (`flex`,
+* `text`).
 */
 const FONT_RELATIVE_LENGTH = /\d(?:em|ex|ch)\b/iu;
 /** A flex/grid/table/ruby display — its child boxes get no inline line box. */
@@ -10015,21 +9881,20 @@ function declProp(decl) {
 	return colon < 0 ? "" : decl.slice(0, colon).trim().toLowerCase();
 }
 /**
-* Drop dead font/text decls before content-addressing. The always-dead props go
-* unconditionally; the two that CAN matter are kept narrowly:
+* Drop dead font/text decls before content-addressing. The always-dead props go unconditionally;
+* the two that CAN matter are kept narrowly:
 *
-*  - `line-height` survives only as the walk's per-row pin: a `SPEC_FALLBACK` rule
-*    on an inline-flow node (no flex/grid/table/ruby display). That pin
-*    (serialize.ts, `hasTextBar`) sizes the inline-block text bone's line box, so
-*    dropping it drifts the row. The shared context `line-height`, author copies,
-*    and flex/grid rows (text is a flex *item* there — no line box) are all dead.
-*  - `font-size` survives only if some kept decl uses an element-font-relative
-*    unit (`em`/`ex`/`ch`) that resolves against it. A plate on `px`/`rem` only
-*    (e.g. MW) drops it everywhere. The scan is plate-wide: one such unit anywhere
-*    means a dropped per-node `font-size` could shift a size.
+* - `line-height` survives only as the walk's per-row pin: a `SPEC_FALLBACK` rule on an inline-flow
+*   node (no flex/grid/table/ruby display). That pin (measure.ts, `hasTextBar`) sizes the
+*   inline-block text bone's line box, so dropping it drifts the row. The shared context
+*   `line-height`, author copies, and flex/grid rows (text is a flex _item_ there — no line box)
+*   are all dead.
+* - `font-size` survives only if some kept decl uses an element-font-relative unit (`em`/`ex`/`ch`)
+*   that resolves against it. A plate on `px`/`rem` only (e.g. MW) drops it everywhere. The scan is
+*   plate-wide: one such unit anywhere means a dropped per-node `font-size` could shift a size.
 *
-* A rule emptied by the filter (the all-font context rule) is dropped downstream
-* by the existing `decls.length === 0` guard.
+* A rule emptied by the filter (the all-font context rule) is dropped downstream by the existing
+* `decls.length === 0` guard.
 */
 function dropDeadDecls(rules) {
 	const keepFontSize = rules.some((rule) => rule.decls.some((decl) => !DROP_AT_GEN_ALWAYS.has(declProp(decl)) && FONT_RELATIVE_LENGTH.test(decl)));
@@ -10049,30 +9914,26 @@ function dropDeadDecls(rules) {
 	});
 }
 /**
-* Encode a plate name into a class-token prefix, injectively. This prefix *is*
-* the isolation boundary across stitched plates (ADR 0007), so distinct plate
-* names must never produce the same prefix — a collision would let one plate's
-* `<style>` block reorder another's classes.
+* Encode a plate name into a class-token prefix, injectively. This prefix _is_ the isolation
+* boundary across stitched plates (ADR 0007), so distinct plate names must never produce the same
+* prefix — a collision would let one plate's `<style>` block reorder another's classes.
 *
-* Plate names are constrained by `isValidPlateName`: each path segment is
-* `\w+(-\w+)*` (word chars with single interior hyphens, no doubled or edge
-* hyphen) and segments are joined by `/`. The slash is the only char that is
-* not class-safe, so rendering it as `--` is enough — and because no segment
-* holds a literal `--` or an edge hyphen, no `-` ever abuts a `/`, so every
-* `--` in the prefix unambiguously came from a `/`, making the map injective.
-* Keeping `/` visually as `--` also leaves nested names readable in the
-* generated CSS (`product--card`).
+* Plate names are constrained by `isValidPlateName`: each path segment is `\w+(-\w+)*` (word chars
+* with single interior hyphens, no doubled or edge hyphen) and segments are joined by `/`. The
+* slash is the only char that is not class-safe, so rendering it as `--` is enough — and because no
+* segment holds a literal `--` or an edge hyphen, no `-` ever abuts a `/`, so every `--` in the
+* prefix unambiguously came from a `/`, making the map injective. Keeping `/` visually as `--` also
+* leaves nested names readable in the generated CSS (`product--card`).
 */
 function encodePlateName(name) {
 	return name.replace(/\//g, "--");
 }
 /**
-* What the class identity keys on, alongside media + declarations:
-*  - `'tier'`: the discrete cascade tier — smaller (more bodies dedupe), but a
-*    rare same-tier inversion within the continuous `author` band can mis-order
-*    one property on one node (ADR 0007). The default.
-*  - `'full'`: the exact `spec` — provably no inversion, marginally larger.
-* One-line flip if QA ever surfaces a mis-order.
+* What the class identity keys on, alongside media + declarations: - `'full'` (the shipped
+* setting): the exact `spec` — provably no inversion. - `'tier'`: the discrete cascade tier —
+* marginally smaller (more bodies dedupe), but a rare same-tier inversion within the continuous
+* `author` band can mis-order one property on one node (ADR 0007). One-line flip if size ever
+* matters more than the inversion risk.
 */
 const SPEC_FOLD = "full";
 function tierLabel(spec) {
@@ -10084,44 +9945,39 @@ function tierLabel(spec) {
 	return "au";
 }
 //#endregion
-//#region src/project.ts
+//#region src/serialize.ts
 /**
-* SERIALIZE — the single in-browser projection of a per-Plate IR into the shipped
-* `Plate` (ADR 0022 §5). The capture session measures every View into one
-* `PlateIR` (`captureView`, serialize.ts) and runs the reduction passes over it
-* ONCE (`runPlatePasses`, serialize.ts); Serialize is the step AFTER — it only
-* PROJECTS, it runs no passes. It assumes each `view.bundle` is already measured
-* AND reduced (the annotate-only passes have set their `dropped`/`folded`/
-* `flattened`/`count` fields), and lowers those annotations into the shipped shape.
+* SERIALIZE — the single in-browser projection of a per-Plate IR into the shipped `Plate` (ADR 0022
+* §5). The capture session measures every View into one `PlateIR` (`captureView`, measure.ts) and
+* runs the Distil passes over it ONCE (`distilPlate`, measure.ts); Serialize is the step AFTER — it
+* only PROJECTS, it runs no passes. It assumes each `view.bundle` is already measured AND distilled
+* (the annotate-only passes have set their `dropped`/`folded`/ `flattened`/`count` fields), and
+* lowers those annotations into the shipped shape.
 *
-* It FOLDS `emit` (ir.ts) — emit is the per-View projection that reads the IR back
-* out into id-form `{ tree, rules }`, lowering the annotations via `effectiveKids`/
-* `boneBox`/`effectiveKind`/`effectiveDecls`. Serialize calls it once per View, then
-* builds ONE merged id-tree and gates each View by breakpoint, in-line (the
-* multi-View merge/gate lives HERE now — the gen-side `mergeViews` it replaced is
-* gone, ADR 0022 cutover), and runs
-* `classify` to content-address the rules. It returns a `StoredPlate` — the gated,
-* content-addressed `{ tree, css }` PLUS `breakpoints` — NOT finished chunks: the
-* `serializePlate` (chunk.ts) lowering to `Plate` chunks stays GEN-SIDE at module-load
-* (ADR 0022 §5), keeping the Tailwind/Bundle passthrough a clean gen-side seam and the
-* analysis-only geometry off the wire (only this structured projection is posted).
+* It FOLDS `emit` (ir.ts) — emit is the per-View projection that reads the IR back out into id-form
+* `{ tree, rules }`, lowering the annotations via `effectiveKids`/
+* `boneBox`/`effectiveKind`/`effectiveDecls`. Serialize calls it once per View, then carries every
+* View whole under ONE id-tree and gates each View by breakpoint in-line (the multi-View gate lives
+* HERE — ADR 0022), and runs `classify` to content-address the rules. It returns a `StoredPlate` —
+* the gated, content-addressed `{ tree, css }` PLUS `breakpoints` — NOT finished chunks: the
+* `serializePlate` (chunk.ts) lowering to `Plate` chunks stays GEN-SIDE at module-load (ADR 0022
+* §5), keeping the Tailwind/Bundle passthrough a clean gen-side seam and the analysis-only geometry
+* off the wire (only this structured projection is posted).
 *
-* The wrapper-island gate (ADR 0022 §2 invariant). A View's breakpoint gate must
-* hide the View's ENTIRE subtree off-range — INCLUDING any stitch — regardless of
-* whether a node has a serializable class slot. The old gen-side `mergeViews` gated
-* each top kid individually; that silently DROPPED a gate landing on a stitch, because
-* `toChunks` serializes a stitch as a bare `{ r }` with no class slot (issue #28: a
-* parent skeleton stitching nested children collapsed off-range). Here each View's
-* top kids are wrapped in ONE synthetic CONTAINER "island" that ALWAYS carries a
-* class; the island is gated ONCE and its `display: none !important` inherits to any
-* stitch inside. Active, the island is `display: contents` so it generates no box —
-* layout-neutral (`.xr-node` sets no display, `.xr-root` is itself `display:
-* contents`, so nothing overrides it). This also reduces the gate rules from
-* N-per-View to 1-per-View and is uniform across stitch top-kids, flattened-to-top
+* The wrapper-island gate (ADR 0022 §2 invariant). A View's breakpoint gate must hide the View's
+* ENTIRE subtree off-range — INCLUDING any stitch — regardless of whether a node has a serializable
+* class slot. Gating each top kid individually silently drops a gate that lands on a stitch,
+* because `toChunks` serializes a stitch as a bare `{ r }` with no class slot (the off-range View
+* collapse: a parent skeleton stitching nested children collapsed off-range). So each View's top
+* kids are wrapped in ONE synthetic CONTAINER "island" that ALWAYS carries a class; the island is
+* gated ONCE and its `display: none !important` inherits to any stitch inside. Active, the island
+* is `display: contents` so it generates no box — layout-neutral (`.xr-node` sets no display,
+* `.xr-root` is itself `display: contents`, so nothing overrides it). This also reduces the gate
+* rules from N-per-View to 1-per-View and is uniform across stitch top-kids, flattened-to-top
 * stitches, and nested stitches alike.
 *
-* Pure data-in/data-out over the (already-reduced) IR — `emit` and everything below
-* read only the passed structures, re-measure nothing.
+* Pure data-in/data-out over the (already-distilled) IR — `emit` and everything below read only the
+* passed structures, re-measure nothing.
 */
 function serializePlateIR(plate) {
 	const views = plate.views.map((view) => emit(view.bundle)).map((projected, i) => ({
@@ -10131,7 +9987,7 @@ function serializePlateIR(plate) {
 	if (views.length <= 1) {
 		const only = views[0];
 		if (!only) return {
-			v: 2,
+			v: 1,
 			name: plate.name,
 			breakpoints: plate.breakpoints,
 			tree: null,
@@ -10139,14 +9995,14 @@ function serializePlateIR(plate) {
 		};
 		const { tree, css } = classify(only.rules, only.tree, plate.name);
 		return {
-			v: 2,
+			v: 1,
 			name: plate.name,
 			breakpoints: plate.breakpoints,
 			tree,
 			css
 		};
 	}
-	const starts = views.map((view) => regimeFor(view.width, plate.breakpoints).min ?? 0);
+	const starts = views.map((view) => viewSpanFor(view.width, plate.breakpoints).min ?? 0);
 	let nextId = 1;
 	const islands = [];
 	const rules = [];
@@ -10175,7 +10031,7 @@ function serializePlateIR(plate) {
 		kids: islands
 	}, plate.name);
 	return {
-		v: 2,
+		v: 1,
 		name: plate.name,
 		breakpoints: plate.breakpoints,
 		tree,
@@ -10192,11 +10048,7 @@ function gate(id, condition) {
 		order: id
 	};
 }
-/**
-* Deep-clone a captured subtree into fresh ids, recording the mapping. The
-* in-browser home of the old gen-side merge's id remap (`mergeViews`, removed in
-* the ADR 0022 cutover).
-*/
+/** Deep-clone a captured subtree into fresh ids, recording the mapping. */
 function cloneWithIds(node, idMap, allocate) {
 	const id = allocate();
 	idMap.set(node.id, id);
@@ -10210,21 +10062,19 @@ function cloneWithIds(node, idMap, allocate) {
 	};
 }
 /**
-* Remap a View's rule ids onto its fresh-id-remapped nodes (the old gen-side merge's
-* remap). Every View's nodes are re-id'd into one shared global id space here, so a
-* rule id that is NOT in this View's `idMap` must NOT keep its old per-View number:
-* that number is some OTHER View's global id, and aliasing onto it cross-contaminates
-* Views (a box-sizing/flex rule from View B landing on View A's island/container —
-* #28 redux, the crooked multi-view layout). An unmapped id is one of two things:
+* Remap a View's rule ids onto its fresh-id-remapped nodes. Every View's nodes are re-id'd into one
+* shared global id space here, so a rule id that is NOT in this View's `idMap` must NOT keep its
+* per-View number: that number is some OTHER View's global id, and aliasing onto it
+* cross-contaminates Views (a box-sizing/flex rule from View B landing on View A's island/container
+* — the crooked multi-view layout). An unmapped id is one of two things:
 *
-*  - `0` — the per-View synthetic root. Its rules (carried tokens, the context rule)
-*    belong on the ONE shared merged root, also id 0, so map `0 → 0`.
-*  - any other unmapped id — a node a reduction pass DROPPED (Superset/Crop/glyph-fold)
-*    that a shared author rule still lists by id. It has no node in this View's
-*    projected tree, so drop the id (emit already prunes `extraRules` this way; author
-*    rules were the gap). A rule left with no ids is itself dropped — note an
-*    originally-rootward rule (`ids: []`) is preserved as-is, since `classify` resolves
-*    an empty `ids` to the root.
+* - `0` — the per-View synthetic root. Its rules (carried tokens, the context rule) belong on the ONE
+*   shared plate root, also id 0, so map `0 → 0`.
+* - Any other unmapped id — a node a Distil pass DROPPED (Superset/Crop/glyph-fold) that a shared
+*   author rule still lists by id. It has no node in this View's projected tree, so drop the id
+*   (emit already prunes `extraRules` this way; author rules were the gap). A rule left with no ids
+*   is itself dropped — note an originally-rootward rule (`ids: []`) is preserved as-is, since
+*   `classify` resolves an empty `ids` to the root.
 */
 function remapRules(rules, idMap) {
 	const out = [];
@@ -10247,4 +10097,4 @@ function remapRules(rules, idMap) {
 	return out;
 }
 //#endregion
-export { serializePlate as a, defineXrayCaptureWalker as c, formatDiagnostic as d, makeDiagnostic as f, collectRefs as i, runPlatePasses as l, deriveBreakpoints as n, CaptureTooLargeError as o, emit as p, regimeFor as r, captureView as s, serializePlateIR as t, diagnosticsHeader as u };
+export { serializePlate as a, defineXrayCaptureWalker as c, formatDiagnostic as d, makeDiagnostic as f, collectRefs as i, distilPlate as l, deriveBreakpoints as n, CaptureTooLargeError as o, emit as p, viewSpanFor as r, captureView as s, serializePlateIR as t, diagnosticsHeader as u };