@beltype/cicero 0.1.8 → 0.1.10

package/dist/seam/rim.js

@@ -1,12 +1,14 @@
 /**
  * THE RIM — the system's edge, where a fact the engine measured before it was true announces that it is (*late truth is an edit*, 2026-10-13; `.claude/decisions/cicero/late-truth-is-an-edit.md`, Decisions three and four; *a box announces its own size*, 2026-10-21; `.claude/decisions/cicero/a-box-announces-its-own-size.md`).
  *
- * It listens on the top-level boxes the intake took, and on nothing else: an `<img>` inside one (`load` and `error`, caught in the capture phase because they do not bubble — a picture still pending and a picture whose `src` changes later are the same event), a custom element whose name is not yet defined (`customElements.whenDefined`, then one animation frame for its `connectedCallback` to have run), and `document.fonts` (`loadingdone`, a fact about the conditions and so about no box).
+ * It listens on the top-level boxes the intake took, and on nothing else: an `<img>` inside one (`load` and `error`, caught in the capture phase because they do not bubble: a picture still pending at intake, which the first run no longer waits for, and a picture whose `src` changes later are the same event), a custom element whose name is not yet defined (`customElements.whenDefined`, then one animation frame for its `connectedCallback` to have run), and `document.fonts` (`loadingdone`, a fact about the conditions and so about no box).
  *
  * **And the one cause that needs no name: a box's own size.** One `ResizeObserver` over the same boxes reports each one's border box; the report is read only while the box is drawn as itself on a page (the root's `isPresented`, and a reading above zero, since a parked box and a box on a page the browser skips read zero), and it is news only where it stands more than a quarter pixel from the height the last run measured for that box (the driver's table, which the client hands in as `measured`). The ear never measures: the observation is a trigger, and the resume measures. It is never paused; what it hears while a run is called or under way is judged when the runs have ended, against the table they leave, which is what keeps the engine's own presentations silent with no flag on its writes.
  *
  * **And the pieces a built page draws a block through** (*a fragment announces its own size*, 2026-10-22; `.claude/decisions/cicero/a-fragment-announces-its-own-size.md`). A divided block's original is parked, and so is a composed block's and one holding a nested fixed box, so the root names to the rim, through the client, every piece it slots into a built page's flow and every node a presentation takes out (`pieces`), and the same observer watches each from the frame it is built in. **A piece's expected height is its first reading above zero**, the presentation's own; a later reading more than the quarter pixel from it, judged under the same gate as an original's, is a `size` signal naming the piece's source box, the page the piece stands on beside it. The engine's own rebuild of a page makes new pieces with new first readings, so its writes pass with no flag. **Its limits**: a change of the original's tree after the copy was taken reaches no piece and is heard by nothing; a box on a page far from the reader is heard when the page comes near (the hearing probe, P40e), and a piece on a page never yet near has read nothing, so a change made before then, like one landing in the presentation's own frame, is its first reading and passes; and a reflow that keeps a box's height and moves its cut passes unheard, since a cut is a word address and the gate a height.
  *
+ * **A picture is news only where its arrival changed its box** (amended 2026-11-08, on Egildo's ruling of that day). A `load` or an `error` is judged when the runs have ended, as a size is: where the box is drawn as itself and the observer's last reading of it stands within the quarter pixel of the height the last run measured, the picture moved nothing and is no signal, which is what an image that declares its `width` and `height` gives; where the observer has read the box as nothing (a page the browser skips), the box's own `offsetHeight` is read instead. A box not drawn as itself while some page is not built is judged again when the observer next reports, since it may stand on that page. Where the reading differs, or the box is not drawn as itself once every page is built (parked, drawn through pieces) or was never measured whole, the rim cannot compare, and the picture is an `image` signal as before. A reading taken before the arrival was laid out passes, and the observer's own `size` hears the box a frame later.
+ *
  * **Every signal is one cancelable `beltype:change` on the document**, `detail: { kind, boxes }` with `kind` one of `image`, `element`, `font`, `size` and `boxes` the top-level boxes in document order (empty for a font); a `size` adds `pages`, beside each box the page it was heard on through a piece, or `null` where it was heard as itself. The same name is the one the live-values store dispatches for its writes (`kind: 'store'`, stage 2): the engine learns one name for every late truth and the host cancels one event to own the pace. A host that calls `preventDefault()` has taken it; otherwise `onSignal` runs with the same detail, and the client answers with the resumable run. **The default action is the engine's for an event the rim did not dispatch as well** (the amendment of 2026-10-13): the store's write (`kind: 'store'`) is dispatched by the host's module, which writes its fields synchronously when the dispatch returns un-cancelled, so the rim waits one animation frame and then, if nobody took the pace, hands `{ kind, boxes }` to the same `onSignal`.
  *
  * This module knows no run: it hears, tells, and hands the default action back. The `originals` array is the client's own and is read live — `patch` replaces an entry in it — so a box that left it is never named.
@@ -71,10 +73,11 @@ export function bringsNewFace(event) {
  * @param p.pageHolding - the page a piece is slotted into (`root.js`' `pageHolding`), asked when a piece is judged changed.
  * @param p.measured - the box's border-box height as the last run measured it, or undefined where it did not.
  * @param p.idle - resolves when no run is under way and nothing the rim told is still being answered: a size is judged then, against the table the run leaves.
+ * @param p.unbuilt - whether some page of the presentation is not built yet: a picture's box that is not drawn as itself may stand on it, and is judged again when the observer next reports. Absent, every page is built.
  * @param p.busy - whether a run is under way or a signal is being answered now: asked again just before a size is judged, since a named signal may have come while the ear waited for the frame.
  * @returns `add` subscribes to a box, releasing what the box it replaced (a patched edit) and the box itself already held, so one load is one signal; `pieces` observes the pieces a page was just built with, each beside its source box, and lets go of the ones a presentation took out; `stop` releases everything.
  */
-export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, onSignal, presented = () => false, pageHolding = () => null, measured = () => undefined, idle = async () => { }, busy = () => false }) {
+export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, onSignal, presented = () => false, pageHolding = () => null, measured = () => undefined, idle = async () => { }, busy = () => false, unbuilt = () => false }) {
     const win = doc.defaultView;
     let stopped = false;
     /** What each box's listeners hand back. */
@@ -86,6 +89,26 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
     const heard = new Map();
     /** The pieces a built page draws its blocks through (*a fragment announces its own size*, 2026-10-22): each one's source box and its expected height, which is the first reading above zero the observer reports for it — the presentation's own, since the feed has no number for a constructed first fragment or a two-cut fragment and a second arithmetic for the others is the fork the account ruling forbids. Zero until that reading; an entry leaves with its piece. */
     const pieces = new Map();
+    /** Each original's last border-box height as the observer reported it, zero included: what a picture's arrival is judged by. */
+    const latest = new WeakMap();
+    /** The boxes a picture loaded or failed in since the last judgment. */
+    const loaded = new Set();
+    /**
+     * What a picture's arrival in a box is: `same` where the box is drawn as itself at the height the last run measured for it, `later` where it is not drawn as itself while some page is not built (it may stand on that page, and is judged again when the observer next reports), and `moved` otherwise, which is also every box the rim cannot compare.
+     *
+     * @remarks The height is the observer's last reading, within {@link TOLERANCE}. Where the observer has read nothing above zero (a box on a page the browser skips reads zero, and a box parked when it was observed is never reported until it is laid out), the box is asked its `offsetHeight`, which lays out that one box and rounds to the whole pixel, so the gate there is half a pixel wider.
+     */
+    const verdict = (box) => {
+        if (!presented(box))
+            return unbuilt() ? 'later' : 'moved';
+        const was = measured(box);
+        if (was === undefined)
+            return 'moved';
+        const now = latest.get(box);
+        if (now)
+            return Math.abs(now - was) <= TOLERANCE ? 'same' : 'moved';
+        return box instanceof win.HTMLElement && Math.abs(box.offsetHeight - was) <= 0.5 + TOLERANCE ? 'same' : 'moved';
+    };
     let judging = false;
     const observer = new win.ResizeObserver((entries) => {
         const t = performance.now();
@@ -102,6 +125,7 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
                     piece.expected = size;
                 continue;
             }
+            latest.set(e.target, size);
             // Zero is what a box no page renders reads: a parked one, and one slotted into a page whose content the browser skips (`content-visibility: auto` on a page not yet near the reader — measured 2026-10-21: a page shown by a run stopped at it reads zero for one frame). It is not news; a box that comes into view reads again.
             if (size > 0 && presented(e.target))
                 heard.set(e.target, size);
@@ -110,7 +134,11 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
         }
         // The run keeps time (*the run keeps time*, 2026-09-25), and so does the ear: inert unless a host reads the measures.
         performance.measure('cicero:size-heard', { start: t, end: performance.now(), detail: { entries: entries.length, kept: heard.size } });
-        if (judging || heard.size === 0)
+        judge();
+    });
+    /** Judge what was heard, sizes and pictures, once the runs have ended. */
+    function judge() {
+        if (judging || (heard.size === 0 && loaded.size === 0))
             return;
         judging = true;
         // A frame to gather the batch; the runs' end; then the frame after it and the task after that frame, so the observer has reported what the last presentation left before anything is judged — and again while a run or an answer began in the meantime (the battery's parallel suite once heard a size beside an element and a face that the named signals were about to answer, 2026-10-22).
@@ -145,11 +173,24 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
                     moved.set(el, null);
             }
             heard.clear();
-            performance.measure('cicero:size-judged', { start: t, end: performance.now(), detail: { heard: n, moved: moved.size } });
+            const pictures = loaded.size;
+            const late = [];
+            for (const box of loaded) {
+                const v = verdict(box);
+                if (v !== 'later')
+                    loaded.delete(box);
+                if (v === 'moved')
+                    late.push(box);
+            }
+            performance.measure('cicero:size-judged', { start: t, end: performance.now(), detail: { heard: n, moved: moved.size, pictures, late: late.length, later: loaded.size } });
+            for (const box of late)
+                moved.delete(box);
+            if (late.length)
+                signal('image', late);
             if (moved.size)
                 signal('size', moved.keys(), moved);
         });
-    });
+    }
     /**
      * @param [pageOf] - a size's: the page each box was heard on through a piece, or null where it was heard as itself.
      */
@@ -176,12 +217,14 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
                 held.delete(gone);
             }
         observer.observe(box, { box: 'border-box' });
-        // `load` and `error` do not bubble, so one capturing listener per box hears every picture inside it — the ones pending now and the ones whose `src` changes later, which a listener on the pending alone would miss. The intake awaited the pictures it found, so an event here is a late one.
-        const loaded = (e) => { if (e.target.localName === 'img')
-            signal('image', [box]); };
-        box.addEventListener('load', loaded, true);
-        box.addEventListener('error', loaded, true);
-        held.set(box, () => { box.removeEventListener('load', loaded, true); box.removeEventListener('error', loaded, true); observer.unobserve(box); });
+        // `load` and `error` do not bubble, so one capturing listener per box hears every picture inside it: the ones pending now, the intake waiting for none since 2026-11-08, and the ones whose `src` changes later, which a listener on the pending alone would miss. Heard, and judged with the sizes: only an arrival that changed the box is a signal.
+        const arrived = (e) => { if (!stopped && e.target.localName === 'img') {
+            loaded.add(box);
+            judge();
+        } };
+        box.addEventListener('load', arrived, true);
+        box.addEventListener('error', arrived, true);
+        held.set(box, () => { box.removeEventListener('load', arrived, true); box.removeEventListener('error', arrived, true); observer.unobserve(box); loaded.delete(box); });
         for (const el of [box, ...box.querySelectorAll('*')]) {
             const name = el.localName;
             if (!name.includes('-') || win.customElements.get(name))

package/dist/src/capture.d.ts

@@ -108,12 +108,36 @@ export declare function sheetsUseHas(doc: Document): boolean;
 export declare function sheetsCountInPseudos(doc: Document): boolean;
 /** The arguments the host rewrote, read back from the registry rules (`:not(*) { --beltype-has-<h>: "<A>" }`, one per rewritten sheet): hash → the argument's canonical text. The capture reads the CSSOM and nothing else, so the arguments come from the rule the rewriter appended and no selector is ever parsed back. */
 export declare function hasArgumentsOf(doc: Document): Map<string, string>;
+/**
+ * The properties that paint and move no box, the one list the sheets' reach reads a rule's declarations against (ruled 2026-11-08): a style rule whose every declaration sets one of these is passed over by {@link sheetReach} and {@link topLevelReach} whatever its selector, because the reach asks whether an edit can move another box's facts, and a colour, a shadow or an opacity moves none.
+ *
+ * @remarks
+ * Closed and short on purpose. The CSSOM lists a rule's declarations as longhands, so `background` arrives as its `background-*` longhands and `border-color` as the four sides', and both families are taken by their prefix and suffix besides the names here. Anything else counts as layout, custom properties (`--x`) included, since one may feed a layout value through `var()`. Four were weighed and left out: `visibility`, whose `collapse` removes a table row or column from the layout; and `filter`, `backdrop-filter` and `will-change`, which make a containing block for a fixed or absolutely positioned descendant and so move it.
+ */
+export declare const PAINT_ONLY: ReadonlySet<string>;
+/** The rule that set a reach and the sheet it stands in, which the memo's console notice names (ruled 2026-11-08): `selector` is a style rule's `selectorText`, `null` for an `@container` or `@scope` rule or a sheet the engine cannot read; `sheet` the sheet's `href`, or `<style> n` with its place among the document's sheets, counted from 1. */
+export type ReachCulprit = {
+    selector: string | null;
+    sheet: string;
+    kind: 'style' | 'container' | 'scope' | 'unreadable';
+};
+/** A reach with the first rule that set it and how many more rules reached as far, {@link sheetReachOf}'s and {@link topLevelReachOf}'s answer. */
+export type Reach = {
+    reach: 0 | 1 | 2;
+    culprit: ReachCulprit | null;
+    count: number;
+};
 /**
  * How far a box's attributes can reach through the sheets the document wears, read off the selectors (*the forced-break index is kept across runs*, 2026-10-09) — what the forcing index's memo needs to know to say which of its answers an edit made stale, when the unit of replacement is `patchBox`'s, a box at any depth ({@link topLevelReach} reads the same sheets for a whole top-level box).
  *
  * 0: nothing but the box and what is below it; a descendant combinator or a child combinator reads a box's ancestors, which an edit does not change. 1: a sibling — `+`, `~` or `:nth-child(… of …)`, by which a box's attributes decide the style of the boxes after it (or beside it) and what they hold. 2: an ancestor or anything at all — `:has(`, an `@container` rule (a size the edit moves), or a sheet the engine cannot read. Blink's invalidation sets draw the same line and take the same fallback: where a selector defeats the reasoning, widen. The reading is textual and errs only toward more reach — a `+` in a selector's attribute value is read as a combinator — which costs speed and never a stale answer.
+ *
+ * @remarks
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, and an `@container` rule every rule under which paints answers nothing of itself; its nested rules are read as rules (ruled 2026-11-08).
  */
 export declare function sheetReach(doc: Document): 0 | 1 | 2;
+/** {@link sheetReach} with the first rule that set the reach and how many more reached as far, for the memo's console notice. */
+export declare function sheetReachOf(doc: Document): Reach;
 /**
  * How far an edit's effect can travel through the sheets when the unit of replacement is a whole top-level box (*the forced-break index is kept across runs*, amended 2026-10-25): what {@link ForcingMemo.settle}, told these boxes, needs to say which top-level boxes' kept parts an edit made stale. Named for its unit, as `sheetReach` is the reading for `patchBox`'s, a box replaced at any depth.
  *
@@ -124,12 +148,16 @@ export declare function sheetReach(doc: Document): 0 | 1 | 2;
  *
  * A nested rule is read as it matches: its `&` is its parent's selector in `:is()`, as CSS Nesting defines it. Conservative by construction, and these are the cases it does not read, each answered 2: a `:is()`, `:where()`, `:not()` or other wrapper whose argument holds a combinator and also a sibling combinator, a `:has(` or a structural pseudo-class, which takes in a nested rule whose parent's selector holds them (a wrapper with a bare `*` among its arguments constrains nothing and is passed over, which is how the engine's own `:has()` union reads); a `&` in a rule nested in no style rule; a selector whose quotes or brackets do not close; a relative selector at the top of a rule. The pseudo-classes `sheetReach` passes over (`:target`, `:checked`, `:dir()`) are passed over here too.
  *
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, so a paint-only `p + p` or `body:has(.x) p` reaches nothing, and an `@container` or `@scope` rule every rule under which paints answers nothing of itself; the walk reads its nested rules as rules (ruled 2026-11-08).
+ *
  * The unit's promise, which the host keeps: a top-level box whose name or attributes change is a new element, and the element it replaced is among `before`.
  *
  * @param boxes - the top-level boxes as they stand: the element children of their one parent, in order.
  * @param before - the top-level boxes the memo was last settled with (`ForcingMemo`'s `boxes`), empty where it keeps nothing.
  */
 export declare function topLevelReach(doc: Document, boxes: ArrayLike<Element>, before?: ArrayLike<Element>): 0 | 1 | 2;
+/** {@link topLevelReach} with the first rule that set the reach, its sheet, and how many more rules reached as far, for the memo's console notice (ruled 2026-11-08). The number alone stays `topLevelReach`'s answer, which a view adapter imports. */
+export declare function topLevelReachOf(doc: Document, boxes: ArrayLike<Element>, before?: ArrayLike<Element>): Reach;
 /** What {@link topLevelReach} asks of the document while it reads a selector. */
 export type ReachContext = {
     /** Whether the selector up to a compound can match a top-level box, or the compound alone a box an edit took out. */

package/dist/src/capture.js

@@ -80,25 +80,106 @@ function someRule(doc, test) {
     };
     return styleSheetsOf(doc).some(inSheet);
 }
+/**
+ * The properties that paint and move no box, the one list the sheets' reach reads a rule's declarations against (ruled 2026-11-08): a style rule whose every declaration sets one of these is passed over by {@link sheetReach} and {@link topLevelReach} whatever its selector, because the reach asks whether an edit can move another box's facts, and a colour, a shadow or an opacity moves none.
+ *
+ * @remarks
+ * Closed and short on purpose. The CSSOM lists a rule's declarations as longhands, so `background` arrives as its `background-*` longhands and `border-color` as the four sides', and both families are taken by their prefix and suffix besides the names here. Anything else counts as layout, custom properties (`--x`) included, since one may feed a layout value through `var()`. Four were weighed and left out: `visibility`, whose `collapse` removes a table row or column from the layout; and `filter`, `backdrop-filter` and `will-change`, which make a containing block for a fixed or absolutely positioned descendant and so move it.
+ */
+export const PAINT_ONLY = new Set(['color', 'background', 'border-color', 'outline-color', 'text-decoration-color', 'text-emphasis-color', 'caret-color', 'accent-color', 'column-rule-color', 'opacity', 'mix-blend-mode', 'box-shadow', 'text-shadow', 'cursor', 'pointer-events', 'user-select', 'forced-color-adjust', 'color-scheme', 'print-color-adjust']);
+const paints = (name) => PAINT_ONLY.has(name) || name.startsWith('background-') || (name.startsWith('border-') && name.endsWith('-color'));
+/** Whether a rule's own declarations, read through `rule.style`, all paint: a rule with none does too. A rule with no `style` is not a style rule and answers no. */
+function paintOnly(rule) {
+    const style = rule.style;
+    if (!style || typeof style.length !== 'number')
+        return false;
+    for (let i = 0; i < style.length; i++)
+        if (!paints(style.item(i)))
+            return false;
+    return true;
+}
+/** Whether every rule under a grouping rule paints, nested rules and grouping rules within it included; a rule that is neither a style rule nor a grouping rule answers no. */
+function allPaint(rules) {
+    for (const rule of Array.from((rules ?? []))) {
+        if (rule.style ? !paintOnly(rule) : !rule.cssRules)
+            return false;
+        if (rule.cssRules && !allPaint(rule.cssRules))
+            return false;
+    }
+    return true;
+}
+/** Every rule of every sheet the document wears, with its sheet's name, walked as {@link someRule} walks them but to the end; a sheet the engine cannot read is handed to `unread`. */
+function eachRule(doc, visit, unread) {
+    const inRules = (rules, sheet) => {
+        for (const rule of rules) {
+            visit(rule, sheet);
+            if (rule.cssRules)
+                inRules(rule.cssRules, sheet);
+            if (rule.styleSheet)
+                inSheet(rule.styleSheet, sheet);
+        }
+    };
+    const inSheet = (sheet, name) => {
+        const own = sheet.href ?? name;
+        let rules;
+        try {
+            rules = sheet.cssRules;
+        }
+        catch {
+            unread(own);
+            return;
+        }
+        inRules(rules, own);
+    };
+    styleSheetsOf(doc).forEach((sheet, i) => inSheet(sheet, `<style> ${i + 1}`));
+}
+/** A tally of what reached how far: the highest level, the first rule at it, and the rules after it at the same level. */
+function reachTally() {
+    const found = { reach: 0, culprit: null, count: 0 };
+    const add = (reach, culprit) => {
+        if (reach > found.reach)
+            Object.assign(found, { reach, culprit, count: 0 });
+        else if (reach > 0 && reach === found.reach)
+            found.count++;
+    };
+    return { found, add };
+}
+/** A grouping rule's kind where it is one the reach answers 2 for unless every rule under it paints, else `null`. */
+const queried = (rule) => {
+    const kind = rule.constructor?.name;
+    return kind === 'CSSContainerRule' ? 'container' : kind === 'CSSScopeRule' ? 'scope' : null;
+};
 /**
  * How far a box's attributes can reach through the sheets the document wears, read off the selectors (*the forced-break index is kept across runs*, 2026-10-09) — what the forcing index's memo needs to know to say which of its answers an edit made stale, when the unit of replacement is `patchBox`'s, a box at any depth ({@link topLevelReach} reads the same sheets for a whole top-level box).
  *
  * 0: nothing but the box and what is below it; a descendant combinator or a child combinator reads a box's ancestors, which an edit does not change. 1: a sibling — `+`, `~` or `:nth-child(… of …)`, by which a box's attributes decide the style of the boxes after it (or beside it) and what they hold. 2: an ancestor or anything at all — `:has(`, an `@container` rule (a size the edit moves), or a sheet the engine cannot read. Blink's invalidation sets draw the same line and take the same fallback: where a selector defeats the reasoning, widen. The reading is textual and errs only toward more reach — a `+` in a selector's attribute value is read as a combinator — which costs speed and never a stale answer.
+ *
+ * @remarks
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, and an `@container` rule every rule under which paints answers nothing of itself; its nested rules are read as rules (ruled 2026-11-08).
  */
 export function sheetReach(doc) {
-    if (someRule(doc, (rule) => rule.constructor?.name === 'CSSContainerRule' || !!rule.selectorText?.includes(':has(')))
-        return 2;
-    // Parenthesised arguments and attribute selectors out of the way first: `:nth-child(2n+1)` and `[lang~=en]` are not combinators, and `:nth-child(2 of .x)` is the one `nth` form that looks sideways.
-    if (someRule(doc, (rule) => {
+    return sheetReachOf(doc).reach;
+}
+/** {@link sheetReach} with the first rule that set the reach and how many more reached as far, for the memo's console notice. */
+export function sheetReachOf(doc) {
+    const { found, add } = reachTally();
+    eachRule(doc, (rule, sheet) => {
+        if (rule.constructor?.name === 'CSSContainerRule') {
+            if (!allPaint(rule.cssRules))
+                add(2, { selector: null, sheet, kind: 'container' });
+            return;
+        }
         const text = rule.selectorText;
-        if (!text)
-            return false;
-        if (/:nth-[\w-]+\([^)]*\sof\s/.test(text))
-            return true;
-        return /[+~]/.test(text.replace(/\[[^\]]*\]/g, '').replace(/:nth-[\w-]+\([^)]*\)/g, ''));
-    }))
-        return 1;
-    return 0;
+        if (!text || paintOnly(rule))
+            return;
+        const culprit = { selector: text, sheet, kind: 'style' };
+        if (text.includes(':has('))
+            return add(2, culprit);
+        // Parenthesised arguments and attribute selectors out of the way first: `:nth-child(2n+1)` and `[lang~=en]` are not combinators, and `:nth-child(2 of .x)` is the one `nth` form that looks sideways.
+        if (/:nth-[\w-]+\([^)]*\sof\s/.test(text) || /[+~]/.test(text.replace(/\[[^\]]*\]/g, '').replace(/:nth-[\w-]+\([^)]*\)/g, '')))
+            add(1, culprit);
+    }, (sheet) => add(2, { selector: null, sheet, kind: 'unreadable' }));
+    return found;
 }
 /**
  * How far an edit's effect can travel through the sheets when the unit of replacement is a whole top-level box (*the forced-break index is kept across runs*, amended 2026-10-25): what {@link ForcingMemo.settle}, told these boxes, needs to say which top-level boxes' kept parts an edit made stale. Named for its unit, as `sheetReach` is the reading for `patchBox`'s, a box replaced at any depth.
@@ -110,12 +191,18 @@ export function sheetReach(doc) {
  *
  * A nested rule is read as it matches: its `&` is its parent's selector in `:is()`, as CSS Nesting defines it. Conservative by construction, and these are the cases it does not read, each answered 2: a `:is()`, `:where()`, `:not()` or other wrapper whose argument holds a combinator and also a sibling combinator, a `:has(` or a structural pseudo-class, which takes in a nested rule whose parent's selector holds them (a wrapper with a bare `*` among its arguments constrains nothing and is passed over, which is how the engine's own `:has()` union reads); a `&` in a rule nested in no style rule; a selector whose quotes or brackets do not close; a relative selector at the top of a rule. The pseudo-classes `sheetReach` passes over (`:target`, `:checked`, `:dir()`) are passed over here too.
  *
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, so a paint-only `p + p` or `body:has(.x) p` reaches nothing, and an `@container` or `@scope` rule every rule under which paints answers nothing of itself; the walk reads its nested rules as rules (ruled 2026-11-08).
+ *
  * The unit's promise, which the host keeps: a top-level box whose name or attributes change is a new element, and the element it replaced is among `before`.
  *
  * @param boxes - the top-level boxes as they stand: the element children of their one parent, in order.
  * @param before - the top-level boxes the memo was last settled with (`ForcingMemo`'s `boxes`), empty where it keeps nothing.
  */
 export function topLevelReach(doc, boxes, before = []) {
+    return topLevelReachOf(doc, boxes, before).reach;
+}
+/** {@link topLevelReach} with the first rule that set the reach, its sheet, and how many more rules reached as far, for the memo's console notice (ruled 2026-11-08). The number alone stays `topLevelReach`'s answer, which a view adapter imports. */
+export function topLevelReachOf(doc, boxes, before = []) {
     const now = Array.from(boxes);
     const was = Array.from(before);
     const here = new Set(now);
@@ -143,22 +230,24 @@ export function topLevelReach(doc, boxes, before = []) {
         shaped,
         changed
     };
-    let reach = 0;
-    const unread = someRule(doc, (rule) => {
-        const kind = rule.constructor?.name;
-        if (kind === 'CSSContainerRule' || kind === 'CSSScopeRule')
-            return true;
-        if (!rule.selectorText || kind === 'CSSPageRule')
-            return false;
+    const { found, add } = reachTally();
+    eachRule(doc, (rule, sheet) => {
+        const kind = queried(rule);
+        if (kind) {
+            if (!allPaint(rule.cssRules))
+                add(2, { selector: null, sheet, kind });
+            return;
+        }
+        if (!rule.selectorText || rule.constructor?.name === 'CSSPageRule' || paintOnly(rule))
+            return;
         const text = resolvedSelector(rule);
         if (text != null && !CROSSING.test(text))
-            return false;
+            return;
         const r = text == null ? 2 : selectorListReach(text, ctx);
-        if (r > reach)
-            reach = r;
-        return reach === 2;
-    });
-    return unread ? 2 : reach;
+        if (r)
+            add(r, { selector: rule.selectorText, sheet, kind: 'style' });
+    }, (sheet) => add(2, { selector: null, sheet, kind: 'unreadable' }));
+    return found;
 }
 /** A style rule's selector as it matches: a rule nested in a style rule (through any grouping rules between them) has each `&` read as the parent's selector in `:is()`, and an item with no `&` the parent's as its ancestor, which is CSS Nesting's own definition, resolved up the chain; `null` for a `&` in a rule nested in no style rule, or text that does not close. */
 function resolvedSelector(rule) {

package/dist/src/chase.js

@@ -312,9 +312,11 @@ export class BeltypePage extends HTMLElement {
             const keys = names.map((n, i) => `${this.#dressText} ${n} ${generated[i]} ${(this.#reads[n] ?? []).map((r) => `${r}=${this.#published.get(r) ?? ''}`).join(',')} ${cellKey(cells[i])}`);
             let pairs = keys.map((k) => INTRINSICS.get(k));
             if (pairs.some((p) => !p)) {
+                // A rect is drawn under every transform above the page, and a host that zooms with `transform: scale(s)` would hand §5.3.2 widths in its pixels, not the page's, and the cache would keep them for every scale after (assessment 2026-11-07). The band spans exactly `#bandWidth` of the page's own pixels, so its rect says the scale.
+                const scale = el.getBoundingClientRect().width / this.#bandWidth || 1;
                 const read = (track) => {
                     el.style.gridTemplateColumns = `${track} ${track} ${track}`;
-                    return cells.map((c) => c.getBoundingClientRect().width);
+                    return cells.map((c) => c.getBoundingClientRect().width / scale);
                 };
                 const max = read('max-content');
                 const min = read('min-content');

package/dist/src/compose-dom.js

@@ -9,7 +9,7 @@
  *
  * @packageDocumentation
  */
-import { compose } from './compositor.js';
+import { compose, HYPHENATE_LIMIT_LINES } from './compositor.js';
 import { addWord, AWAY, BREAK, FILL, hasWord } from './data-beltype.js';
 import { createMeasureContext } from './measure.js';
 import { indexBlocks, pageIntervals, presentationWidths } from './positions.js';
@@ -462,7 +462,8 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
                         available: job.avail,
                         indent: r === 0 ? job.indent : 0,
                         align: job.align,
-                        breakAnywhere: job.breakAnywhere
+                        breakAnywhere: job.breakAnywhere,
+                        limitLines: HYPHENATE_LIMIT_LINES
                     });
                     record.runs.push({ start: runs[r].start, ...result });
                     record.lineCount += result.lineCount;

package/dist/src/compositor.d.ts

@@ -1,7 +1,7 @@
 /**
  * The Compositor — whole-paragraph line breaking (tablet, The Line; architecture, The Compositor; second-coding-round.md item 1). One of the system's two deciders; this module is the decision alone: DOM-free, widths through an injected provider (the whole-line Range policy lives in the provider, built browser-side by compose-dom.js), output is a Hints value the feed writer materializes.
  *
- * Knuth–Plass-shaped total-fit dynamic programming over break candidates: word boundaries plus hyphenation offsets (Liang's, or an author's soft hyphens — the caller supplies them; this module does not know where they came from). Badness is slack against the measure under the alignment's stretch model, and there are two of those (see `STRETCH` below) — aesthetic error only, never geometric: a chosen line fits because its measured width is the oracle's own. Demerits add hyphen, consecutive-hyphen, and last-line-orphan penalties. Ties break toward earlier breaks (candidates priced ascending, replaced only on strictly lower total) — a total order, no randomness, so the determinism that *cut-invariance* (C7) relies on holds by construction.
+ * Knuth–Plass-shaped total-fit dynamic programming over break candidates: word boundaries plus hyphenation offsets (Liang's, or an author's soft hyphens — the caller supplies them; this module does not know where they came from). Badness is slack against the measure under the alignment's stretch model, and there are two of those (see `STRETCH` below) — aesthetic error only, never geometric: a chosen line fits because its measured width is the oracle's own. Demerits add hyphen, consecutive-hyphen, and last-line-orphan penalties, and a run of hyphenated line ends longer than `limitLines` is no candidate at all. Ties break toward earlier breaks (candidates priced ascending, replaced only on strictly lower total) — a total order, no randomness, so the determinism that *cut-invariance* (C7) relies on holds by construction.
  *
  * Each node reads only its feasible window (*the composition lays out once*, 2026-09-27): its predecessors are scanned downward and the scan stops at the first overfull span, on the premise that for a fixed end a span starting earlier is never narrower. What was read is then priced in ascending order, so the choice and its tie-breaking are the ones pricing every predecessor would make. On BelType's own manual it took the composition's Range reads from 6.2 to 4.8 million.
  *
@@ -46,6 +46,13 @@ export type Hints = {
     /** The justify filler, serialized as a literal: the last line's slack. */
     fillerPx: number;
 };
+/**
+ * The most lines in a row the composed mode ends on a hyphen (Codeberg issue 5) — Bringhurst's rule, *avoid more than three consecutive hyphenated lines* (The Elements of Typographic Style, section 2.4), and the value css-text-4 §6.3.5's `hyphenate-limit-lines` would carry, which Chromium does not support and so never reaches computed style.
+ *
+ * @remarks
+ * A judgement with a lineage, as `RAG_TOLERANCE_EM` is. The consecutive penalty alone did not hold it: measured 2026-11-07 on the delibera specimen, its first paragraph ended seven lines in a row on a hyphen at 3000, six at 10000 (TeX's `\doublehyphendemerits`), three at 30000. Under the limit its longest run is three and its hyphens 10 for 13, the interword space averaging 1.356 of the natural space for 1.333, its spread 0.247 for 0.250, its widest unchanged.
+ */
+export declare const HYPHENATE_LIMIT_LINES = 3;
 /**
  * Compose one run: choose its line breaks by total fit.
  *
@@ -54,10 +61,11 @@ export type Hints = {
  * @param p.measure - the width provider.
  * @param p.available - the line measure in px.
  * @param p.indent - first-line text-indent in px — debits line 1's measure.
+ * @param p.limitLines - css-text-4 §6.3.5's `hyphenate-limit-lines`: the most consecutive lines that may end on a hyphen, `null` for `no-limit`. A limit extends the DP's state to (node, the run of hyphenated line ends behind it), so the limit is a constraint and not a price; with none the state is the node alone and the composition is the one it always was. A paragraph the limit leaves no way through but an overfull line is composed without it.
  * @param p.breakAnywhere - css-text-4 §6.4's `overflow-wrap: break-word | anywhere`, which lets *"an otherwise unbreakable sequence of characters be broken at an arbitrary point if there are no otherwise-acceptable break points in the line"*, and says outright that **no hyphenation character is inserted**. Such a break is a node like any other, marked `glyph: false`, so it costs no hyphen advance and carries no hyphen demerit.
  * @throws Error — bare and deliberate (`src/` may not import BelType's error types): ragged alignment with no usable `measure.emWidth`, a refusal rather than a NaN.
  */
-export declare function compose({ words, hyphenOffsets, measure, available, indent, align, breakAnywhere }: {
+export declare function compose({ words, hyphenOffsets, measure, available, indent, align, breakAnywhere, limitLines }: {
     words: string[];
     hyphenOffsets?: (wordIndex: number) => number[];
     measure: Measure;
@@ -65,4 +73,5 @@ export declare function compose({ words, hyphenOffsets, measure, available, inde
     indent?: number;
     align?: 'left' | 'right' | 'center' | 'justify';
     breakAnywhere?: boolean;
+    limitLines?: number | null;
 }): Hints;

package/dist/src/compositor.js

@@ -1,7 +1,7 @@
 /**
  * The Compositor — whole-paragraph line breaking (tablet, The Line; architecture, The Compositor; second-coding-round.md item 1). One of the system's two deciders; this module is the decision alone: DOM-free, widths through an injected provider (the whole-line Range policy lives in the provider, built browser-side by compose-dom.js), output is a Hints value the feed writer materializes.
  *
- * Knuth–Plass-shaped total-fit dynamic programming over break candidates: word boundaries plus hyphenation offsets (Liang's, or an author's soft hyphens — the caller supplies them; this module does not know where they came from). Badness is slack against the measure under the alignment's stretch model, and there are two of those (see `STRETCH` below) — aesthetic error only, never geometric: a chosen line fits because its measured width is the oracle's own. Demerits add hyphen, consecutive-hyphen, and last-line-orphan penalties. Ties break toward earlier breaks (candidates priced ascending, replaced only on strictly lower total) — a total order, no randomness, so the determinism that *cut-invariance* (C7) relies on holds by construction.
+ * Knuth–Plass-shaped total-fit dynamic programming over break candidates: word boundaries plus hyphenation offsets (Liang's, or an author's soft hyphens — the caller supplies them; this module does not know where they came from). Badness is slack against the measure under the alignment's stretch model, and there are two of those (see `STRETCH` below) — aesthetic error only, never geometric: a chosen line fits because its measured width is the oracle's own. Demerits add hyphen, consecutive-hyphen, and last-line-orphan penalties, and a run of hyphenated line ends longer than `limitLines` is no candidate at all. Ties break toward earlier breaks (candidates priced ascending, replaced only on strictly lower total) — a total order, no randomness, so the determinism that *cut-invariance* (C7) relies on holds by construction.
  *
  * Each node reads only its feasible window (*the composition lays out once*, 2026-09-27): its predecessors are scanned downward and the scan stops at the first overfull span, on the premise that for a fixed end a span starting earlier is never narrower. What was read is then priced in ascending order, so the choice and its tie-breaking are the ones pricing every predecessor would make. On BelType's own manual it took the composition's Range reads from 6.2 to 4.8 million.
  *
@@ -14,6 +14,13 @@ const LINE_PENALTY = 10;
 const HYPHEN_DEMERITS = 2500;
 const CONSECUTIVE_HYPHEN_DEMERITS = 3000;
 const LAST_LINE_ORPHAN_DEMERITS = 5000;
+/**
+ * The most lines in a row the composed mode ends on a hyphen (Codeberg issue 5) — Bringhurst's rule, *avoid more than three consecutive hyphenated lines* (The Elements of Typographic Style, section 2.4), and the value css-text-4 §6.3.5's `hyphenate-limit-lines` would carry, which Chromium does not support and so never reaches computed style.
+ *
+ * @remarks
+ * A judgement with a lineage, as `RAG_TOLERANCE_EM` is. The consecutive penalty alone did not hold it: measured 2026-11-07 on the delibera specimen, its first paragraph ended seven lines in a row on a hyphen at 3000, six at 10000 (TeX's `\doublehyphendemerits`), three at 30000. Under the limit its longest run is three and its hyphens 10 for 13, the interword space averaging 1.356 of the natural space for 1.333, its spread 0.247 for 0.250, its widest unchanged.
+ */
+export const HYPHENATE_LIMIT_LINES = 3;
 const OVERFULL_DEMERITS = 1e7;
 /** css-text-4 §6.4's emergency break: dearer than any hyphen and cheaper than an overflow, which is the whole ordering the section asks for once the candidates only exist where they are needed. */
 const EMERGENCY_DEMERITS = 1e5;
@@ -40,10 +47,11 @@ const STRETCH = { justify: 0.5 };
  * @param p.measure - the width provider.
  * @param p.available - the line measure in px.
  * @param p.indent - first-line text-indent in px — debits line 1's measure.
+ * @param p.limitLines - css-text-4 §6.3.5's `hyphenate-limit-lines`: the most consecutive lines that may end on a hyphen, `null` for `no-limit`. A limit extends the DP's state to (node, the run of hyphenated line ends behind it), so the limit is a constraint and not a price; with none the state is the node alone and the composition is the one it always was. A paragraph the limit leaves no way through but an overfull line is composed without it.
  * @param p.breakAnywhere - css-text-4 §6.4's `overflow-wrap: break-word | anywhere`, which lets *"an otherwise unbreakable sequence of characters be broken at an arbitrary point if there are no otherwise-acceptable break points in the line"*, and says outright that **no hyphenation character is inserted**. Such a break is a node like any other, marked `glyph: false`, so it costs no hyphen advance and carries no hyphen demerit.
  * @throws Error — bare and deliberate (`src/` may not import BelType's error types): ragged alignment with no usable `measure.emWidth`, a refusal rather than a NaN.
  */
-export function compose({ words, hyphenOffsets = () => [], measure, available, indent = 0, align = 'left', breakAnywhere = false }) {
+export function compose({ words, hyphenOffsets = () => [], measure, available, indent = 0, align = 'left', breakAnywhere = false, limitLines = null }) {
     const N = words.length;
     if (N === 0)
         return { breaks: [], lines: [], lineCount: 0, fillerPx: 0 };
@@ -92,14 +100,18 @@ export function compose({ words, hyphenOffsets = () => [], measure, available, i
         return Math.max(0, lastWord - firstWhole);
     };
     const lineWidth = (a, b) => measure.width(a, b) + (hyphenated(b) ? measure.hyphenWidth : 0);
+    /** The longest run of hyphenated line ends a state may carry: the limit, or 1 with none, where only whether the line before ended on a hyphen is ever read and the state is the node alone. */
+    const cap = limitLines != null && limitLines >= 1 ? Math.floor(limitLines) : 1;
+    const limited = limitLines != null && limitLines >= 1;
+    /** By node, by the run of hyphenated line ends that reaching it closes with (0 for a node that is no hyphen). */
     const best = new Array(nodes.length).fill(null);
-    best[0] = { total: 0, prev: -1, width: 0, avail: 0, overfull: false };
+    best[0] = [{ total: 0, prev: -1, prevRun: 0, width: 0, avail: 0, overfull: false }];
     /** The widths read for the current node, by predecessor: the feasible window, and `j = 0` where a negative indent makes it the one exception. */
     const feasibleW = new Array(nodes.length);
     const feasibleJ = [];
     for (let k = 1; k < nodes.length; k++) {
         const isLast = k === last;
-        let choice = null;
+        const states = [];
         /** The feasible window. The premise, stated so it can be broken: for a fixed end, a span that starts earlier is never narrower — a Range's rect over one nowrap line is the union of what it holds, and an earlier start holds everything a later one does. So once the span from `j` is overfull, every `j` below it is too against the same measure, and the scan stops there. Every `j` above 0 has the same measure; `j = 0` alone is debited the indent, which a positive indent makes narrower (overfull wherever the `j` above it is, so the stop stands) and a negative one wider — so under a negative indent a scan that stopped above it reads it on its own. */
         feasibleJ.length = 0;
         let stoppedAt = -1;
@@ -143,35 +155,55 @@ export function compose({ words, hyphenOffsets = () => [], measure, available, i
                 d += EMERGENCY_DEMERITS;
             if (isLast && k - 1 >= 0 && j !== 0 && gapsIn(nodes[j], nodes[k]) === 0)
                 d += LAST_LINE_ORPHAN_DEMERITS;
-            const total = best[j].total + d;
-            if (!choice || total < choice.total - 1e-9)
-                choice = { total, prev: j, width: W, avail, overfull: false };
+            best[j].forEach((from, run) => {
+                if (!from)
+                    return;
+                const next = hyphenated(nodes[k]) ? Math.min(run + 1, cap) : 0;
+                if (limited && hyphenated(nodes[k]) && run + 1 > cap)
+                    return;
+                const total = from.total + d;
+                const held = states[next];
+                if (!held || total < held.total - 1e-9)
+                    states[next] = { total, prev: j, prevRun: run, width: W, avail, overfull: false };
+            });
         }
-        if (!choice && !sawFeasible) {
+        if (!states.length && !sawFeasible) {
             // Nothing fits: take the shortest line from the nearest reachable node — overfull, crushing demerits, but the paragraph composes (the spirit of *the build cannot fail*, C2).
             for (let j = k - 1; j >= 0; j--) {
                 if (!best[j])
                     continue;
+                const run = best[j].findIndex(Boolean);
+                const from = best[j][run];
                 const avail = available - (j === 0 ? indent : 0);
                 const W = lineWidth(nodes[j], nodes[k]);
-                choice = { total: best[j].total + OVERFULL_DEMERITS + (W - avail) ** 2, prev: j, width: W, avail, overfull: true };
+                states[hyphenated(nodes[k]) ? Math.min(run + 1, cap) : 0] = { total: from.total + OVERFULL_DEMERITS + (W - avail) ** 2, prev: j, prevRun: run, width: W, avail, overfull: true };
                 break;
             }
         }
-        best[k] = choice;
+        best[k] = states.length ? states : null;
     }
     // Read back the chosen chain.
     const chain = [];
-    for (let k = last; k > 0; k = best[k].prev)
-        chain.push(k);
+    for (let k = last, run = 0; k > 0;) {
+        const state = best[k][run];
+        chain.push({ k, state });
+        k = state.prev;
+        run = state.prevRun;
+    }
     chain.reverse();
     const lines = [];
     let from = 0;
-    for (const k of chain) {
-        lines.push({ from: nodes[from], to: nodes[k], width: best[k].width, avail: best[k].avail, overfull: best[k].overfull });
+    for (const { k, state } of chain) {
+        lines.push({ from: nodes[from], to: nodes[k], width: state.width, avail: state.avail, overfull: state.overfull });
         from = k;
     }
-    const breaks = chain.slice(0, -1).map((k) => nodes[k]);
+    // A limit that leaves the paragraph no way through but an overfull line is not a reason to set one: the paragraph is set without the limit, where that fits.
+    if (limited && lines.some((l) => l.overfull)) {
+        const free = compose({ words, hyphenOffsets, measure, available, indent, align, breakAnywhere, limitLines: null });
+        if (!free.lines.some((l) => l.overfull))
+            return free;
+    }
+    const breaks = chain.slice(0, -1).map(({ k }) => nodes[k]);
     const lastLine = lines[lines.length - 1];
     const fillerPx = Math.max(0, lastLine.avail - lastLine.width);
     return { breaks, lines, lineCount: lines.length, fillerPx };

package/dist/src/data-beltype.d.ts

@@ -11,12 +11,14 @@
  *
  * **No key may end with another key** (`pos:` and `xpos:` cannot both exist), because "every element carrying a key" is selected by substring and a substring cannot anchor to the start of a word. {@link assertNoKeySuffix} checks it once, at load.
  *
- * **One rule, one registry.** The registry is a table of facts, each declared once — its name, its kind, what it is computed from, who writes it and, for a value, the custom property a generated sheet delivers it into — so that a later step adds entries and not a second mechanism. It holds the `has:` family, the line stamp `pos:`, `fragment`, the piece words `split`/`start`/`end`/`slice:N`, `fixed`, the engine-created elements' `shell`/`break`/`fill`, the three words the zeroing needs (`wrapped`, `adjoin`, `away`) and `artifact` (*the piece words*, 2026-10-11; see CHANGELOG 2026-10-11); `hollow` is a later step and is not written here.
+ * **One rule, one registry.** The registry is a table of facts, each declared once — its name, its kind, what it is computed from, who writes it and, for a value, the custom property a generated sheet delivers it into — so that a later step adds entries and not a second mechanism. It holds the `has:` family, the line stamp `pos:`, `fragment`, the piece words `split`/`start`/`end`/`slice:N`, `fixed`, the engine-created elements' `shell`/`break`/`fill`, the three words the zeroing needs (`wrapped`, `adjoin`, `away`), `artifact` (*the piece words*, 2026-10-11; see CHANGELOG 2026-10-11) and the one word a host writes on an element of its own, `host` (ruled 2026-11-08); `hollow` is a later step and is not written here.
  *
  * @packageDocumentation
  */
 /** The attribute's name. A single place for the literal; the grammar below is the only code that spells the value. */
 export declare const ATTRIBUTE = "data-beltype";
+/** The attribute a printer's preparation sets on every element it makes from generated content, valued by the pseudo it was made from (`before`, `after`, `marker`): its own attribute and not a word, because it is set by the host on the source, before the engine sees it. `content()` and `string-set` leave out what carries it, as css-gcpm-3's `content()` is the element's text without its pseudo-elements, and `content(before)` and `content(after)` read exactly that (ruled 2026-11-07). The name and its values are `GENERATED_ATTRIBUTE` and `GeneratedPseudo` in `@beltype/common/data-beltype`; `src/` imports nothing, so the literal is spelled here once, and is replaced by the import if the engine's layering ever admits common. */
+export declare const GENERATED_ATTRIBUTE = "data-beltype-generated";
 /** One fact the registry declares. */
 export type Entry = {
     /** The flag, or the key of a value word (`has` for `has:<hash>`). */
@@ -44,6 +46,8 @@ export declare const KEYS: ReadonlySet<string>;
 export declare const TRANSFORM = "transform";
 export declare const CICERO_PROVISION = "cicero-provision";
 export declare const CICERO_INTERFACE = "cicero-interface";
+/** The word a host puts on an element of its own machinery that stands among the document's boxes, so the intake passes over it (`topLevelBoxes`, `driver.js`). A host that holds the document in an element of its own names that element with the `root` option first. */
+export declare const HOST = "host";
 /** The words step 2 writes, named once: the engine, the editing tools, Caster and the essay spell them through these and never as a literal of their own. */
 export declare const FRAGMENT = "fragment";
 export declare const SPLIT = "split";