@beltype/cicero 0.1.8 → 0.1.10

package/dist/src/data-beltype.js

@@ -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 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 const GENERATED_ATTRIBUTE = 'data-beltype-generated';
 /** Every word and key, once. The table `docs/reference.md` documents, in the same order. */
 export const REGISTRY = Object.freeze([
     { name: 'transform', kind: 'flag', status: 'in use', writer: 'belt', from: 'source', facing: 'host', meaning: 'the site engine\'s JSON binding block (`<script type="application/json">`)' },
@@ -36,6 +38,7 @@ export const REGISTRY = Object.freeze([
     { name: 'wrapped', kind: 'flag', status: 'in use', writer: 'engine', from: 'original', facing: 'engine', meaning: 'the box wraps each fragment whole (`box-decoration-break: clone`), so border and padding stay at a cut; decided by the engine because a selector cannot test the property' },
     { name: 'adjoin', kind: 'flag', status: 'in use', writer: 'engine', from: 'cut', facing: 'engine', meaning: 'the first-child chain after a cut BETWEEN boxes: its block-start margin adjoins the cut and is truncated, and the box is not divided' },
     { name: 'away', kind: 'flag', status: 'in use', writer: 'engine', from: 'cut', facing: 'engine', meaning: 'a box put away on this page (`display: none`): kept as an element so structural selectors read as in the source' },
+    { name: 'host', kind: 'flag', status: 'in use', writer: 'host', from: 'host', facing: 'engine', meaning: 'the host\'s word on an element of its own machinery that stands among the document\'s boxes (a hidden `<iframe>`, a probe); the intake passes over it, so it gets no address and moves none (ruled 2026-11-08)' },
     { name: 'artifact', kind: 'flag', status: 'in use', writer: 'engine', from: 'cut', facing: 'host', meaning: 'a copy the engine repeats that is not the one a reader reads: a running element\'s copy in a margin box, a fixed box\'s copy on every page after the first, and a table\'s repeated header or footer group; PDF\'s own word for pagination furniture, and nothing else. Every artifact is also aria-hidden' }
 ].map((e) => Object.freeze(e)));
 /** The flags in use. */
@@ -46,6 +49,8 @@ export const KEYS = new Set(REGISTRY.filter((e) => e.kind === 'value').map((e) =
 export const TRANSFORM = 'transform';
 export const CICERO_PROVISION = 'cicero-provision';
 export 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 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 const FRAGMENT = 'fragment';
 export const SPLIT = 'split';

package/dist/src/document-state.d.ts

@@ -13,7 +13,7 @@
  *
  * **A position is the flat word index** (`positions.js`), and an operation applies when its position is strictly before the one asked about — and not inside a remainder a carried flow has still to show, which stands before the page's first word in document order and is on that page or after it (beltype#43; `positions.js`' `remaindersOf`). That is §6.1's *"the deepest element in the normal flow that spans the page break"* said in this engine's own space: an element whose first word is the page's first word begins on the new page and does not span the break, so its own operation is not yet in force, while an element that spans the break started before that word and is included. The ancestors above the top-level blocks sit at position **−1** — they open before the document's first word and span every break there is — which is what makes the first page's answer fall out of the same comparison rather than needing a case of its own.
  *
- * **What is not read, each a real gap and each showing as a counter reading low.** A list item's implicit increment, so an `<ol>` that runs onto a second page numbers its items from 1 there (measured 2026-11-07, `<ol reversed>` and a `counter-set` of `list-item` likewise); css-lists-3's `reversed()` counters; and a top-level `position: fixed` box, which is not among the flow blocks the position index is built over. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
+ * **What is not read, each a real gap and each showing as a counter reading low.** css-lists-3's `reversed()` counters (an author's `counter-reset: reversed(name)`), a top-level `position: fixed` box, which is not among the flow blocks the position index is built over; and a scope that ended before the position asked about with no operation logged between its end and the position, since the replay closes a scope only when an operation at or above its depth arrives: a `counter(list-item)` read on a page past a list whose last item holds a list reads the inner list's count (3 where Chromium prints 2, measured 2026-11-07), and an author's nested reset is read the same way. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A list's and a list item's implicit `list-item` operations are read since 2026-11-07 (`implicitListOps`), so a `counter(list-item)` read on a page a list continued onto or past it counts the items before it. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
  *
  * @packageDocumentation
  */
@@ -48,6 +48,8 @@ export type Op = {
         name: string;
         terms: Term[];
         text: string;
+        before?: string;
+        after?: string;
         attrs: Record<string, string>;
     }[] | null;
     /** The flat word position the operation sits at. */
@@ -77,6 +79,8 @@ export declare function parseStringSet(value: unknown): {
 }[];
 /** The whitespace collapsing GCPM asks for: `content()` is *"the string value of the element, determined as if `white-space: normal` had been set"*. */
 export declare const collapse: (text: unknown) => string;
+/** An element's text without the elements a printer made from its generated content ({@link GENERATED_ATTRIBUTE}): css-gcpm-3's `content()`, the element's text and not its pseudo-elements'. An element holding none answers its `textContent`, as before. */
+export declare function contentTextOf(el: any): string;
 /** One top-level block's part of the log: its operations in document order, each with its position and depth relative to the block — the words of the block before the element, and its depth below the block (*a resumed run keeps its reads*, 2026-10-22). {@link documentOpsOf} lays the parts end to end, a part's positions offset by its block's base and its depths by the ancestors above the blocks. */
 export declare function blockOpsOf(block: any, index: {
     wordsBefore: (el: any) => number;
@@ -95,7 +99,7 @@ export declare function blockOpsOf(block: any, index: {
  * @param index - the position index (`positions.js`), which holds every element inside every block.
  * @param opts.styleOf - the computed style of an element — injected, so a plain object tree exercises this without a browser.
  * @param opts.pseudoStyleOf - the computed style of an element's `::before` or `::after`, whose counter operations are logged as the element's first and last child's; absent, a pseudo-element's counters are unread. The `::after` needs the index's `wordCountIn`.
- * @param opts.textOf - an element's text; absent, its `textContent`.
+ * @param opts.textOf - an element's text; absent, {@link contentTextOf}, its `textContent` without what a printer made from its generated content.
  * @param opts.attrOf - an element's attribute; absent, its `getAttribute`.
  * @param opts.ancestors - the elements above the blocks, outermost first (`html`, `body`). They open before the document's first word and are recorded at position −1.
  * @param opts.marks - elements whose counters are asked about after their own operations (`counterStatesAfter`): each is logged even where it does nothing, carrying itself as `mark`, so the replay reaches it in document order (*a pointer is a read*, 2026-10-03).

package/dist/src/document-state.js

@@ -13,13 +13,14 @@
  *
  * **A position is the flat word index** (`positions.js`), and an operation applies when its position is strictly before the one asked about — and not inside a remainder a carried flow has still to show, which stands before the page's first word in document order and is on that page or after it (beltype#43; `positions.js`' `remaindersOf`). That is §6.1's *"the deepest element in the normal flow that spans the page break"* said in this engine's own space: an element whose first word is the page's first word begins on the new page and does not span the break, so its own operation is not yet in force, while an element that spans the break started before that word and is included. The ancestors above the top-level blocks sit at position **−1** — they open before the document's first word and span every break there is — which is what makes the first page's answer fall out of the same comparison rather than needing a case of its own.
  *
- * **What is not read, each a real gap and each showing as a counter reading low.** A list item's implicit increment, so an `<ol>` that runs onto a second page numbers its items from 1 there (measured 2026-11-07, `<ol reversed>` and a `counter-set` of `list-item` likewise); css-lists-3's `reversed()` counters; and a top-level `position: fixed` box, which is not among the flow blocks the position index is built over. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
+ * **What is not read, each a real gap and each showing as a counter reading low.** css-lists-3's `reversed()` counters (an author's `counter-reset: reversed(name)`), a top-level `position: fixed` box, which is not among the flow blocks the position index is built over; and a scope that ended before the position asked about with no operation logged between its end and the position, since the replay closes a scope only when an operation at or above its depth arrives: a `counter(list-item)` read on a page past a list whose last item holds a list reads the inner list's count (3 where Chromium prints 2, measured 2026-11-07), and an author's nested reset is read the same way. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A list's and a list item's implicit `list-item` operations are read since 2026-11-07 (`implicitListOps`), so a `counter(list-item)` read on a page a list continued onto or past it counts the items before it. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
  *
  * @packageDocumentation
  */
 import { STRING_SET_PROP, RUNNING_PROP } from './gcpm-encoding.js';
 import { format as formatCounter } from './counter-styles.js';
 import { inRemainders } from './positions.js';
+import { GENERATED_ATTRIBUTE } from './data-beltype.js';
 /** `counter-reset: a 2 b` → `[['a', 2], ['b', 0]]`. The computed value normalizes name/value pairs, but an absent number still defaults per property, so the default is a parameter. `none` and the empty string yield nothing. */
 export function pairsOf(value, fallback) {
     const out = [];
@@ -180,6 +181,24 @@ function splitArgs(raw) {
 const unquote = (s) => (/^(["']).*\1$/.test(s) ? s.slice(1, -1) : s);
 /** The whitespace collapsing GCPM asks for: `content()` is *"the string value of the element, determined as if `white-space: normal` had been set"*. */
 export const collapse = (text) => String(text ?? '').replace(/\s+/g, ' ').trim();
+/** An element's text without the elements a printer made from its generated content ({@link GENERATED_ATTRIBUTE}): css-gcpm-3's `content()`, the element's text and not its pseudo-elements'. An element holding none answers its `textContent`, as before. */
+export function contentTextOf(el) {
+    if (!el?.querySelector?.(`[${GENERATED_ATTRIBUTE}]`))
+        return el?.textContent ?? '';
+    let out = '';
+    for (const node of el.childNodes) {
+        if (node.nodeType === 3 || node.nodeType === 4)
+            out += node.data;
+        else if (node.nodeType === 1 && !node.hasAttribute(GENERATED_ATTRIBUTE))
+            out += contentTextOf(node);
+    }
+    return out;
+}
+/** The text of an element's own `::before` or `::after` where a printer made it real: its children carrying {@link GENERATED_ATTRIBUTE} with that value, or `null` where it has none. */
+function generatedTextOf(el, which) {
+    const made = [...(el?.children ?? [])].filter((child) => child.getAttribute?.(GENERATED_ATTRIBUTE) === which);
+    return made.length ? made.map((child) => child.textContent).join('') : null;
+}
 /** One element's entry in the log, or `null` where it does nothing and is not marked: its three counter declarations, its rewritten `string-set` with the text and attributes its terms name, and the mark, read off the one `styleOf` answer. */
 function opAt(el, pos, depth, { styleOf, textOf, attrOf, marks }) {
     const style = styleOf(el) ?? {};
@@ -191,6 +210,10 @@ function opAt(el, pos, depth, { styleOf, textOf, attrOf, marks }) {
             name,
             terms,
             text: collapse(textOf(el)),
+            ...Object.fromEntries(['before', 'after'].flatMap((which) => {
+                const made = terms.some((t) => t.kind === 'content' && t.which === which) ? generatedTextOf(el, which) : null;
+                return made === null ? [] : [[which, collapse(made)]];
+            })),
             attrs: Object.fromEntries(terms.filter((t) => t.kind === 'attr').map((t) => [t.name, attrOf(el, t.name) ?? '']))
         }))
         : null;
@@ -205,7 +228,7 @@ function pseudoOpOf(el, pseudo, styleOf) {
 /** One top-level block's part of the log: its operations in document order, each with its position and depth relative to the block — the words of the block before the element, and its depth below the block (*a resumed run keeps its reads*, 2026-10-22). {@link documentOpsOf} lays the parts end to end, a part's positions offset by its block's base and its depths by the ancestors above the blocks. */
 export function blockOpsOf(block, index, reads) {
     const ops = [];
-    const walk = (el, depth) => {
+    const walk = (el, depth, list) => {
         const style = reads.styleOf(el) ?? {};
         if (style.display === 'none')
             return; // CSS 2.1 §12.4.3: an element with `display: none` does not increment or reset counters
@@ -213,7 +236,18 @@ export function blockOpsOf(block, index, reads) {
         if (style.position === 'fixed' || String(customOf(style, RUNNING_PROP)).trim())
             return;
         const pos = index.wordsBefore(el);
-        const op = opAt(el, pos, depth, reads);
+        const implicit = implicitListOps(el, style, list, reads);
+        let op = opAt(el, pos, depth, reads);
+        if (implicit.reset || implicit.increment || implicit.set) {
+            op ??= { reset: [], increment: [], set: [], strings: null, pos, depth };
+            const names = (pairs) => pairs.some(([name]) => name === 'list-item');
+            if (implicit.reset && !names(op.reset))
+                op.reset = [...op.reset, implicit.reset];
+            if (implicit.increment && !names(op.increment))
+                op.increment = [...op.increment, implicit.increment];
+            if (implicit.set && !names(op.set))
+                op.set = [...op.set, implicit.set];
+        }
         // A `::before` is the element's first child and an `::after` its last (CSS 2.1 §12.1), so their counter operations are logged one level down, the one at the element's first word and the other at its end. The element's named strings and its mark are evaluated after its `::before`: the number a heading or a figure prints there is the one its `string-set` and a `target-counter()` to it read.
         const before = pseudoOpOf(el, '::before', reads.pseudoStyleOf);
         if (before) {
@@ -224,14 +258,56 @@ export function blockOpsOf(block, index, reads) {
         else if (op)
             ops.push(op);
         for (const child of el.children ?? [])
-            walk(child, depth + 1);
+            walk(child, depth + 1, implicit.inner);
         const after = index.wordCountIn ? pseudoOpOf(el, '::after', reads.pseudoStyleOf) : null;
         if (after)
             ops.push({ ...after, strings: null, pos: pos + index.wordCountIn(el), depth: depth + 1 });
     };
-    walk(block, 0);
+    walk(block, 0, OUTSIDE_LISTS);
     return ops;
 }
+const OUTSIDE_LISTS = { step: 1, ol: false };
+/** The list items a list owns, as HTML's list owner has them: the elements displayed as `list-item` below it, nested lists' own left out. */
+function ownedItemCount(list, styleOf) {
+    let n = 0;
+    for (const c of list.children ?? []) {
+        if (/^(?:OL|UL|MENU)$/i.test(c.tagName ?? ''))
+            continue;
+        const display = String(styleOf(c)?.display ?? '');
+        if (display === 'none')
+            continue;
+        if (display.includes('list-item'))
+            n++;
+        n += ownedItemCount(c, styleOf);
+    }
+    return n;
+}
+/**
+ * The `list-item` operations an element has with no declaration of them: css-lists-3 §4.3 and HTML's list rendering.
+ *
+ * @remarks
+ * A list (`ol`, `ul`, `menu`) resets `list-item`: an `<ol>` to one step before its `start`, which under `reversed` defaults to the number of items it owns, and a list of another kind to 0. Each element displayed as `list-item` adds its list's step, 1 or −1 under `reversed`, and an `<li>` an `<ol>` owns is set to its `value`. Each is the element's only where its own `counter-reset`, `counter-increment` or `counter-set` does not name `list-item`, which the caller tests. The walk read none of it before 2026-11-07, so a `counter(list-item)` read on a page past a list, in a margin box or in the list's scope after it, read 0.
+ *
+ * Measured 2026-11-07, Chromium's own `counter(list-item)` differs from this in two places, both left as the spec has them because the marker Cicero numbers by (`fragments.js`' `listOrdinals`) is HTML's and agrees with it: under `reversed` without a `start` Chromium counts down from 0 (0, −1, −2 for HTML's 3, 2, 1), and it ignores `value` (an item after `value="20"` reads 3 where its marker prints 21).
+ */
+function implicitListOps(el, style, list, reads) {
+    const tag = String(el.tagName ?? '').toUpperCase();
+    const item = String(style.display ?? '').includes('list-item');
+    const value = item && list.ol && tag === 'LI' ? parseInt(reads.attrOf(el, 'value') ?? '', 10) : NaN;
+    const out = { reset: null, increment: item ? ['list-item', list.step] : null, set: Number.isFinite(value) ? ['list-item', value] : null, inner: list };
+    if (tag === 'OL') {
+        const reversed = reads.attrOf(el, 'reversed') != null;
+        const start = parseInt(reads.attrOf(el, 'start') ?? '', 10);
+        const step = reversed ? -1 : 1;
+        out.reset = ['list-item', (Number.isFinite(start) ? start : reversed ? ownedItemCount(el, reads.styleOf) : 1) - step];
+        out.inner = { step, ol: true };
+    }
+    else if (tag === 'UL' || tag === 'MENU') {
+        out.reset = ['list-item', 0];
+        out.inner = OUTSIDE_LISTS;
+    }
+    return out;
+}
 /**
  * The counter operations of a document, in document order, each with the flat word position it sits at and its depth in the tree.
  *
@@ -239,14 +315,14 @@ export function blockOpsOf(block, index, reads) {
  * @param index - the position index (`positions.js`), which holds every element inside every block.
  * @param opts.styleOf - the computed style of an element — injected, so a plain object tree exercises this without a browser.
  * @param opts.pseudoStyleOf - the computed style of an element's `::before` or `::after`, whose counter operations are logged as the element's first and last child's; absent, a pseudo-element's counters are unread. The `::after` needs the index's `wordCountIn`.
- * @param opts.textOf - an element's text; absent, its `textContent`.
+ * @param opts.textOf - an element's text; absent, {@link contentTextOf}, its `textContent` without what a printer made from its generated content.
  * @param opts.attrOf - an element's attribute; absent, its `getAttribute`.
  * @param opts.ancestors - the elements above the blocks, outermost first (`html`, `body`). They open before the document's first word and are recorded at position −1.
  * @param opts.marks - elements whose counters are asked about after their own operations (`counterStatesAfter`): each is logged even where it does nothing, carrying itself as `mark`, so the replay reaches it in document order (*a pointer is a read*, 2026-10-03).
  * @param opts.running - the document's running elements in document order (`driver.js`' `runningBoxes`), each with the flat position the flow stood at where it was written (`driver.js`' `runningPosition`): each is logged as an assignment of its name there, carrying its place in this list as `running.at` (*a running element is a named node*, 2026-10-21). A running element is out of the flow at any depth, so the walk does not enter one, and its own counters and strings are unread, as a fixed box's are.
  * @param opts.keep - the memo's door (`forcing-memo.js`): each block's {@link blockOpsOf} part is asked of it, and a part kept from an earlier run is laid in place of a walk (*a resumed run keeps its reads*, 2026-10-22). A part read under marks is kept apart from one read without, and answers only while the marks that fall in its block are the ones it was read under (the position index says which block a mark is in). Absent, every block is walked.
  */
-export function documentOpsOf(blocks, index, { styleOf, pseudoStyleOf = null, textOf = (el) => el.textContent, attrOf = (el, name) => el.getAttribute(name), ancestors = [], marks = null, running = [], keep = null }) {
+export function documentOpsOf(blocks, index, { styleOf, pseudoStyleOf = null, textOf = contentTextOf, attrOf = (el, name) => el.getAttribute(name), ancestors = [], marks = null, running = [], keep = null }) {
     const reads = { styleOf, textOf, attrOf, marks, pseudoStyleOf };
     const ops = [];
     ancestors.forEach((el, i) => {
@@ -423,11 +499,11 @@ function replay(ops, { until = Infinity, onOp = null, away = [] } = {}) {
     return snapshot();
 }
 /** One `<content-list>` term against the element's own facts and the counter state in force at it. */
-function evaluateTerm(term, { text, attrs, counters }) {
+function evaluateTerm(term, { text, before, after, attrs, counters }) {
     switch (term.kind) {
         case 'string': return term.value;
-        // `before`, `after` and `first-letter` are read as `text`: a pseudo-element's own string is generated content this walk does not see, and the module header states the limit rather than pretending to four readings.
-        case 'content': return text;
+        // `before` and `after` read the pseudo a printer made real, where it did; otherwise they and `first-letter` are read as `text`: a native pseudo-element's own string is generated content this walk does not see, and the module header states the limit rather than pretending to four readings.
+        case 'content': return (term.which === 'before' ? before : term.which === 'after' ? after : undefined) ?? text;
         case 'attr': return attrs?.[term.name] ?? '';
         case 'counter': return formatCounter(counterValue(counters, term.name), term.style);
         case 'counters': return counterValues(counters, term.name).map((v) => formatCounter(v, term.style)).join(term.separator);
@@ -444,7 +520,7 @@ export function stringAssignmentsOf(ops) {
     replay(ops, {
         onOp: (op, counters) => {
             for (const s of op.strings ?? [])
-                out.push({ name: s.name, pos: op.pos, value: s.terms.map((t) => evaluateTerm(t, { text: s.text, attrs: s.attrs, counters })).join('') });
+                out.push({ name: s.name, pos: op.pos, value: s.terms.map((t) => evaluateTerm(t, { text: s.text, before: s.before, after: s.after, attrs: s.attrs, counters })).join('') });
         }
     });
     return out;

package/dist/src/driver.d.ts

@@ -253,6 +253,12 @@ export declare function forcingIndexOf(blocks: Element[], { styleOf, pageNameOf,
         };
     } | null;
 };
+/**
+ * The element children of `root` (the body, unless a host names another) minus what is not the document's: engine scaffolding (an `id` starting `__beltype`), the tags that never render ({@link NEVER_RENDERED}), and any element carrying the host word ({@link HOST}), a host's own machinery standing among the boxes (ruled 2026-11-08). Every top-level box the document declares, in or out of the flow. The two functions below divide it. **This is the one filter**: the client's intake (`seam/client.js`) calls it too, so a box this passes over has no address anywhere. A host that holds the document in an element of its own still names it with `root` first.
+ *
+ * @param root - the element the boxes stand in.
+ */
+export declare function topLevelBoxes(doc: Document, root?: Element): Element[];
 /**
  * The document's top-level blocks — the flow, which is what the cuts divide. One definition, shared by the build loop and the differential's judge measure.
  *

package/dist/src/driver.js

@@ -14,19 +14,19 @@
  * @packageDocumentation
  */
 import { Ledger, createEntry } from './ledger.js';
-import { assertRenderConditions, awaitCloneImages, awaitFonts, awaitImages, createMeasureContext } from './measure.js';
+import { assertRenderConditions, awaitCloneImages, awaitFonts, eagerImages, createMeasureContext } from './measure.js';
 import { holdsAnonymousBlocks, takeReport } from './gauge.js';
 import { adjudicate, adjudicateFlow, firstBelowTheEdge, isAbsolutelyPositioned, isOutOfFlow, isMonolith, neverCutInside, reachesBelowTheEdge, processionBottoms, fitsPage } from './stonehand.js';
 import { composeDocument, applyRecordsUnder } from './compose-dom.js';
 import { CompositionCache } from './composition-key.js';
-import { readGeometryTable, effectivePageName, pageRulesOf, styleSheetsOf, registerGcpmProperties, sheetsUseHas, sheetReach, sheetsCountInPseudos } from './capture.js';
+import { readGeometryTable, effectivePageName, pageRulesOf, styleSheetsOf, registerGcpmProperties, sheetsUseHas, sheetReachOf, sheetsCountInPseudos } from './capture.js';
 import { snapshotOfStyle } from './forcing-memo.js';
 import { cloneFlowPiece, declineRepeats, mayRepeat, mutateToContinuation, truncateFrom } from './fragments.js';
 import { cutAfter, divides, elAtIn, flattenResume, indexBlocks, inFlowIndex, inRemainders, normalizePath, pathOf, placeAt, remaindersOf } from './positions.js';
 import { documentOpsOf, counterStateAt, pageNumberAt, withoutPageCounters, stringAssignmentsOf, runningAssignmentsOf, namedStringsForPage } from './document-state.js';
 import { RUNNING_PROP } from './gcpm-encoding.js';
-import { ARTIFACT, hasWord } from './data-beltype.js';
-import { blockChildrenOf, footerBeforeRows, headerAfterRows, isFixedBox, SIDE_BY_SIDE, sourceOf } from './word-space.js';
+import { ARTIFACT, HOST, hasWord } from './data-beltype.js';
+import { blockChildrenOf, footerBeforeRows, inDisplayOrder, isFixedBox, SIDE_BY_SIDE, sourceOf } from './word-space.js';
 import { changedPairs, settleReads } from './reads.js';
 import { converge, holderPage, namesNoPlace, priorKeys, restartPage } from './resume.js';
 import { answerHas, boxesWhoseWordsMoved } from './has-words.js';
@@ -38,31 +38,28 @@ function toPx(len) {
     return parseFloat(m[1]) * PX_PER[m[2]];
 }
 /**
- * The message a table shape refuses with (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): the table, by its id or class or its first words, and the shape. Both shapes lost rows with no message, and a refusal by name is the detector until the address can say where §17.2 lays the group out.
+ * The message a table shape refuses with (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): the table, by its id or class or its first words, and the shape. The one shape left is a footer group written before its rows and taller than the page area, refused by name as a box taller than its page is rather than lose rows with no message.
  *
- * @remarks The two shapes, both groups whose words and box disagree in order. A header group written after the rows is laid out above them (CSS 2.1 §17.2) while its words stand after them in the word space: one that repeats is walked first and shown by its copy on every page before its words, and one too tall to repeat, in a divided table, is refused, because which page shows it is the open ruling on §17.2's display order in the word space. A footer group written before the rows is walked where it is laid out, last and whole, and one taller than the page area could be placed nowhere, so the table ended on its first page.
- *
- * @param group - the source `thead` or `tfoot`.
+ * @param group - the source `tfoot`.
  * @param shape - the shape, in words.
  * @param remedy - what the author can write instead.
  */
-function refusedTable(group, shape, remedy = 'write the groups in HTML\'s order: thead, tbody, tfoot') {
+function refusedTable(group, shape, remedy) {
     const table = group.closest('table');
     const words = (table?.textContent ?? '').trim().replace(/\s+/g, ' ').slice(0, 40);
     const name = table?.id ? `<table id="${table.id}">` : table?.className ? `<table class="${table.className}">` : `the table beginning "${words}"`;
     return `cicero: ${name} has ${shape}, which this engine cannot divide across pages yet; it refuses rather than lose rows. To print it, ${remedy}.`;
 }
-/** The nearest copy the engine repeats (`artifact`) standing ahead of this element among its siblings — the table's header, in front of its rows — or null. */
+/** The nearest copy the engine repeats (`artifact`) standing ahead of this element among its siblings in display order (`inDisplayOrder`) — the table's header, in front of its rows, wherever it is written — or null. */
 const artifactBefore = (el) => {
+    const isCopy = (s) => typeof s.getAttribute === 'function' && hasWord(s, ARTIFACT);
+    const parent = el?.parentElement;
+    const written = parent ? [...parent.children] : [];
+    const shown = parent ? inDisplayOrder(parent, written) : written;
+    if (shown !== written)
+        return shown.slice(0, shown.indexOf(el)).reverse().find(isCopy) ?? null;
     for (let s = el?.previousElementSibling; s; s = s.previousElementSibling)
-        if (typeof s.getAttribute === 'function' && hasWord(s, ARTIFACT))
-            return s;
-    return null;
-};
-/** The header group written after this element among its siblings, which §17.2 lays out ahead of it all the same (`headerAfterRows`), or null. It is a copy on the pages before its words and the original in a feed, which pours it whole, and it stands ahead of the rows either way. */
-const headerCopyAfter = (el) => {
-    for (let s = el?.nextElementSibling; s; s = s.nextElementSibling)
-        if (headerAfterRows(s))
+        if (isCopy(s))
             return s;
     return null;
 };
@@ -82,10 +79,9 @@ export function gapAbove(box, report, win) {
     for (let child = box, a = box.parent; a; child = a, a = a.parent) {
         const cs = win.getComputedStyle(a.el);
         // A copy the engine repeats ahead of the child (the table's header) is furniture with a footprint, not a spent lead (*the header repeats*): the level owes only what stands above the copy, which under separated borders is the table's `border-spacing` above its first row, and Chromium draws none above a repeated header (*a repeated header joins the rows as Chromium prints them*, 2026-10-22). Under collapsed borders the copy's top is the table's own and nothing is owed.
-        const late = headerCopyAfter(child.el);
-        if (late || standsAfterArtifact(child.el)) {
-            // The header's copy, never a footer's: a footer written before its rows stands among the siblings too, and is laid out at the foot (*the footer before the rows*). A header written after its rows is laid out ahead of them, and its copy is the one.
-            let copy = cs.borderCollapse === 'separate' ? late ?? artifactBefore(child.el) : null;
+        if (standsAfterArtifact(child.el)) {
+            // The header's copy, never a footer's: the siblings are in display order, where a footer stands after the rows wherever it is written (*the-word-space-follows-the-table-display-order*).
+            let copy = cs.borderCollapse === 'separate' ? artifactBefore(child.el) : null;
             while (copy && !/^THEAD$/i.test(copy.tagName))
                 copy = artifactBefore(copy);
             const box = copy ? report.boxOf(copy) : null;
@@ -363,13 +359,15 @@ export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posO
         }
     };
 }
+/** The tags that never render, so the intake passes over them wherever a host leaves one among the document's boxes: `TEMPLATE`, whose content is inert; `LINK`, `META`, `BASE`, `TITLE` and `HEAD`, metadata the HTML parser may leave in the body and the UA sheet hides; and `NOSCRIPT`, which renders only when scripts are off, and the engine is a script. A closed list, beside `STYLE` and `SCRIPT`, which were passed over before it (ruled 2026-11-08). */
+const NEVER_RENDERED = new Set(['STYLE', 'SCRIPT', 'TEMPLATE', 'LINK', 'META', 'BASE', 'TITLE', 'HEAD', 'NOSCRIPT']);
 /**
- * The element children of `root` (the body, unless a host names another) minus engine scaffolding — every top-level box the document declares, in or out of the flow. The two functions below divide it.
+ * The element children of `root` (the body, unless a host names another) minus what is not the document's: engine scaffolding (an `id` starting `__beltype`), the tags that never render ({@link NEVER_RENDERED}), and any element carrying the host word ({@link HOST}), a host's own machinery standing among the boxes (ruled 2026-11-08). Every top-level box the document declares, in or out of the flow. The two functions below divide it. **This is the one filter**: the client's intake (`seam/client.js`) calls it too, so a box this passes over has no address anywhere. A host that holds the document in an element of its own still names it with `root` first.
  *
  * @param root - the element the boxes stand in.
  */
-function topLevelBoxes(doc, root = doc.body) {
-    return [...root.children].filter((el) => !el.id.startsWith('__beltype') && !['STYLE', 'SCRIPT'].includes(el.tagName));
+export function topLevelBoxes(doc, root = doc.body) {
+    return [...root.children].filter((el) => !el.id.startsWith('__beltype') && !NEVER_RENDERED.has(el.tagName) && !hasWord(el, HOST));
 }
 /**
  * The document's top-level blocks — the flow, which is what the cuts divide. One definition, shared by the build loop and the differential's judge measure.
@@ -538,7 +536,7 @@ export function paginate(doc, opts = {}) {
 /**
  * The memo this call reads through, settled once before any walk, or `null` (*the forced-break index is kept across runs*, 2026-10-09; *a resumed run keeps its reads*, 2026-10-22).
  *
- * The boxes a resumed call names as edited — `dirtyAt` and `edited`, resolved against the blocks as they stand now — are reported through the memo's one door, {@link ForcingMemo.replaced}, beside the boxes `patchBox` reported there: a host that edits a box in place, as the venue's pins do, replaces no element and would leave the walks' parts of its box standing. Then the memo is settled against the sheets' reach; a sheet by which a box could change an ancestor's style (`sheetReach` 2) empties it for this call, and the console says so once.
+ * The boxes a resumed call names as edited — `dirtyAt` and `edited`, resolved against the blocks as they stand now — are reported through the memo's one door, {@link ForcingMemo.replaced}, beside the boxes `patchBox` reported there: a host that edits a box in place, as the venue's pins do, replaces no element and would leave the walks' parts of its box standing. Then the memo is settled against the sheets' reach; a sheet by which a box could change an ancestor's style (`sheetReach` 2) empties it for this call and a sheet by which it could change a sibling's (1) narrows it, and the console says each once, naming the rule ({@link ForcingMemo.notice}).
  */
 function settledMemo(doc, { forcingMemo = null, prior, dirtyAt, edited = [], blocks }) {
     if (!forcingMemo)
@@ -551,13 +549,12 @@ function settledMemo(doc, { forcingMemo = null, prior, dirtyAt, edited = [], blo
                 forcingMemo.replaced(elAtIn(block, at.path) ?? block);
         }
     }
-    if (forcingMemo.settle(sheetReach(doc)))
-        return forcingMemo;
-    if (!forcingMemo.said) {
-        forcingMemo.said = true;
-        doc.defaultView?.console?.info('BelType/Cicero: a stylesheet uses :has(), an @container rule or a selector the engine cannot read, so the forced-break index and the run-level walks are read afresh on every run rather than kept. The pages are the same; an edit costs more.');
-    }
-    return null;
+    const read = sheetReachOf(doc);
+    const usable = forcingMemo.settle(read.reach);
+    const line = forcingMemo.notice(read);
+    if (line)
+        doc.defaultView?.console?.info(line);
+    return usable ? forcingMemo : null;
 }
 /**
  * One run: the document laid out once, from its first word to its last, or from the page an edit dirtied to the page where the run converges. A layout the reads send round again resumes from the layout before it, at the boxes whose lines the delivered values moved (*delivery resumes from the moved page*, 2026-10-21): `laid.resume` names them and that layout, and they stand in for `prior`, `dirtyAt` and `edited`.
@@ -569,13 +566,13 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
     assertRenderConditions(doc, { relaxDpr });
     // The two rewritten GCPM declarations, registered before anything reads a computed style: unregistered, a custom property inherits, and `string-set` on a heading would reach every descendant of it (*the host rewrites what the parser drops*, 2026-09-14).
     registerGcpmProperties(doc.defaultView);
-    // Once each, before the first measure — late-arriving truth never enters adjudication. one call site covers every host, because the seam's bootstrap, the editing tools' `beltype:ready` call and the venue's own client all enter through here. The images are a stand-in for the first run, and `measure.js`'s `awaitImages` carries the whole reason (*images are awaited at intake*, beltype#39).
+    // Once each, before the first measure — late-arriving truth never enters adjudication. one call site covers every host, because the seam's bootstrap, the editing tools' `beltype:ready` call and the venue's own client all enter through here. The images are not awaited (ruled 2026-11-08): they are made eager and the run goes on, and an arrival that changes a box is the rim's (`measure.js`'s `eagerImages` carries the reason).
     // The run keeps time in the User Timing API (*the run keeps time*, 2026-09-25): one running timestamp, one `performance.measure` per phase, `detail` carrying the count a reader normalizes by. A measure is read by nothing here and decides nothing.
     let t = performance.now();
     await awaitFonts(doc);
     performance.measure('cicero:fonts', { start: t, end: (t = performance.now()) });
-    const images = await awaitImages(originals ?? intakeBlocks ?? doc);
-    performance.measure('cicero:images', { start: t, end: (t = performance.now()), detail: { images } });
+    const images = eagerImages(originals ?? intakeBlocks ?? doc);
+    performance.measure('cicero:images', { start: t, end: (t = performance.now()), detail: { images, awaited: false } }); // the eager pass alone: nothing is waited for since 2026-11-08
     const table = intakeTable ?? readGeometryTable(doc);
     await awaitFonts(doc, table.furnitureFaces); // the faces page furniture names, requested now and not when the first margin box is presented (the table is read after the first wait, so its lengths are measured as they always were)
     const win = doc.defaultView;
@@ -1231,7 +1228,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
             performance.measure('cicero:feed', { start: t, end: (t = performance.now()), detail: { page: account.length, blocks: items.length, carried: (cursor.carried ?? []).length, bound: bounded ? words : null, reach: (bounded ? posOfCut(place.cut) : forcingCuts ? posOfCut(forcedEvent.cut) : index.total) - cursor.pos, pours } });
             container = ctx.measure(items.map((it) => it.clone), laid.facts?.[account.length] ?? null); // a page fact a flow site reads stands as the run before decided it, or at its reservation (*the page carries its conditions*)
             performance.measure('cicero:layout', { start: t, end: (t = performance.now()), detail: { page: account.length, blocks: items.length } });
-            // The clones' own images, settled before the report is taken: a clone of a loaded image is not always available in the turn it is mounted (`measure.js`'s `awaitCloneImages`), and a figure measured at no height moves every cut after it.
+            // The clones' own images, settled before the report is taken: a clone of a loaded image is not always available in the turn it is mounted (`measure.js`'s `awaitCloneImages`), and a figure measured at no height moves every cut after it. Kept when the first run's awaits went (2026-11-08), until the Service Worker case is measured without it.
             const waited = await awaitCloneImages(container);
             performance.measure('cicero:clone-images', { start: t, end: (t = performance.now()), detail: { page: account.length, waited } });
             report = takeReport(container, { contentHeight: conditions.contentH });
@@ -1479,17 +1476,10 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
         if (!fits && hasGroups) {
             const ct = container.getBoundingClientRect().top;
             const edge = pageStart + conditions.contentH;
-            // A header written after its rows that does not repeat, in a table the page's edge divides, is refused (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): its words are on the table's last fragment and its box above the first, and which page shows it is the open ruling on §17.2's display order in the word space. Undivided, the one fragment holds both.
-            for (const h of container.querySelectorAll('thead')) {
-                const src = sourceOf(h);
-                const r = h.closest('table')?.getBoundingClientRect();
-                if (src && r && declined.has(src) && headerAfterRows(src) && r.top - ct < edge && r.bottom - ct > edge)
-                    throw new Error(refusedTable(src, 'a header group written after its rows, too tall to repeat'));
-            }
             for (const f of container.querySelectorAll('tfoot')) {
                 const src = sourceOf(f);
-                // A footer written before its rows that does not repeat is still reserved where it is shown: its words stand before the rows, so it is on the table's first fragment and nowhere after (*the footer before the rows*, 2026-10-15; Chromium shows it on the last, which the address cannot say).
-                if (!f.getClientRects().length || !src || (declined.has(src) && !footerBeforeRows(src)) || !mayRepeat(src))
+                // A footer that does not repeat is not reserved: its words follow the rows wherever it is written (*the-word-space-follows-the-table-display-order*), so it stands on the table's last fragment alone, where Chromium prints it.
+                if (!f.getClientRects().length || !src || declined.has(src) || !mayRepeat(src))
                     continue;
                 const table = f.closest('table');
                 if (!table)

package/dist/src/forcing-memo.d.ts

@@ -13,9 +13,12 @@
  *
  * **Who must keep the promise.** The host: a box replaced any other way than `patchBox` (which calls {@link ForcingMemo.replaced}) must be reported the same way or the run must ask for a fresh memo. Under the top-level unit, a top-level box whose name or attributes change is a new element, and the box it replaced is reported too. The seam fills the memo only from runs on a presented frame, never from the first run after load, whose realm (the sources are children of `body`, not of `<beltype-root>`) can answer a `body > …` or `:first-child` selector otherwise than later runs do.
  *
+ * **A rule that only paints reaches nothing** (ruled 2026-11-08). Both readings pass over a style rule whose declarations all set a property on `capture.js`' `PAINT_ONLY` list, whatever its selector, and an `@container` or `@scope` rule every rule under which paints. Where a reach of 2 puts the memo out of use or a reach of 1 narrows it, {@link ForcingMemo.notice} gives the console one line per memo life at each level, naming the first rule that set the level and its sheet.
+ *
  * @see .claude/decisions/cicero/the-forced-break-index-is-kept-across-runs.md
  * @packageDocumentation
  */
+import type { Reach } from './capture.ts';
 /** The computed style properties `forcingIndexOf` and the predicates it calls (`isAbsolutelyPositioned`, `isOutOfFlow`, `isMonolith`, `neverCutInside`, `notYetDivided`) read of a box, and so the whole of a snapshot. `test/forcing-memo.test.js` records the reads of a real walk against this list. */
 export declare const FORCING_STYLE_READS: readonly string[];
 /** The door a run-level walk asks a per-box part through (*a resumed run keeps its reads*, 2026-10-22): `kind` names the walk, `box` is the top-level box the part is of, `read` takes the part, and `still`, where given, says whether a kept part still answers this run's question. {@link ForcingMemo.keep} is the one implementation; a walk handed none reads every box. */
@@ -29,6 +32,8 @@ export declare class ForcingMemo {
     misses: number;
     /** Whether the console has said, for this memo's life, that a sheet's reach put it out of use. */
     said: boolean;
+    /** Whether the console has said, for this memo's life, that a sheet's reach of 1 narrowed what it keeps. */
+    saidNarrowed: boolean;
     /** Per walk, the boxes whose part was kept and the boxes read, since the last {@link ForcingMemo.settle}. */
     tally: Record<string, {
         kept: number;
@@ -36,6 +41,11 @@ export declare class ForcingMemo {
     }>;
     /** The top-level boxes the memo was last settled with under the top-level unit, in order, which `capture.js`' `topLevelReach` takes as `before`; empty where it keeps nothing. */
     get boxes(): Element[];
+    /**
+     * The console line for a reach that put this memo out of use (2) or narrowed it (1), once per memo life at each level, or `null` (ruled 2026-11-08): it names the first rule that set the level, its sheet, and how many more rules reached as far, so an author can find the rule that costs the edit.
+     * @param read - `capture.js`' `sheetReachOf` or `topLevelReachOf`.
+     */
+    notice(read: Reach): string | null;
     /** Forget everything: the conditions moved, the run was not a resume, or it threw. */
     clear(): void;
     /** Begin a run: the tally starts again. */

package/dist/src/forcing-memo.js

@@ -14,6 +14,8 @@
  *
  * **Who must keep the promise.** The host: a box replaced any other way than `patchBox` (which calls {@link ForcingMemo.replaced}) must be reported the same way or the run must ask for a fresh memo. Under the top-level unit, a top-level box whose name or attributes change is a new element, and the box it replaced is reported too. The seam fills the memo only from runs on a presented frame, never from the first run after load, whose realm (the sources are children of `body`, not of `<beltype-root>`) can answer a `body > …` or `:first-child` selector otherwise than later runs do.
  *
+ * **A rule that only paints reaches nothing** (ruled 2026-11-08). Both readings pass over a style rule whose declarations all set a property on `capture.js`' `PAINT_ONLY` list, whatever its selector, and an `@container` or `@scope` rule every rule under which paints. Where a reach of 2 puts the memo out of use or a reach of 1 narrows it, {@link ForcingMemo.notice} gives the console one line per memo life at each level, naming the first rule that set the level and its sheet.
+ *
  * @see .claude/decisions/cicero/the-forced-break-index-is-kept-across-runs.md
  * @packageDocumentation
  */
@@ -32,6 +34,8 @@ export class ForcingMemo {
     misses = 0;
     /** Whether the console has said, for this memo's life, that a sheet's reach put it out of use. */
     said = false;
+    /** Whether the console has said, for this memo's life, that a sheet's reach of 1 narrowed what it keeps. */
+    saidNarrowed = false;
     #facts = new WeakMap();
     #pageName = new WeakMap();
     #children = new WeakMap();
@@ -47,6 +51,24 @@ export class ForcingMemo {
     get boxes() {
         return this.#boxes;
     }
+    /**
+     * The console line for a reach that put this memo out of use (2) or narrowed it (1), once per memo life at each level, or `null` (ruled 2026-11-08): it names the first rule that set the level, its sheet, and how many more rules reached as far, so an author can find the rule that costs the edit.
+     * @param read - `capture.js`' `sheetReachOf` or `topLevelReachOf`.
+     */
+    notice(read) {
+        const { reach, culprit, count } = read;
+        if (reach === 0 || !culprit || (reach === 2 ? this.said : this.saidNarrowed))
+            return null;
+        if (reach === 2)
+            this.said = true;
+        else
+            this.saidNarrowed = true;
+        const what = culprit.kind === 'style' ? `the rule "${culprit.selector}" in ${culprit.sheet}` : culprit.kind === 'unreadable' ? `the sheet ${culprit.sheet}, which the engine cannot read,` : `an @${culprit.kind} rule in ${culprit.sheet}`;
+        const more = count ? `${culprit.kind === 'unreadable' ? '' : ','} and ${count} more ${count === 1 ? 'rule' : 'rules'},` : '';
+        return reach === 2
+            ? `BelType/Cicero: ${what}${more} can change the style of a box an edit did not touch, so the forced-break index and the run-level walks are read afresh on every run rather than kept; the pages are the same and an edit costs more.`
+            : `BelType/Cicero: ${what}${more} can make a box change the style of the boxes beside it, so the forced-break index and the run-level walks read the boxes beside an edited one again rather than keep them; the pages are the same and an edit costs more.`;
+    }
     /** Forget everything: the conditions moved, the run was not a resume, or it threw. */
     clear() {
         this.#facts = new WeakMap();

package/dist/src/fragmentation.d.ts

@@ -2,18 +2,18 @@
  * The fragmentation face: the engine's members a view adapter builds on, `@beltype/cicero/fragmentation`.
  *
  * @remarks
- * Exactly the names the first view adapter imported by deep path on 2026-10-29 (68 of them, from 16 modules), re-exported unchanged; nothing is new and nothing is un-exported. Which of them stay public, merge or leave is the shape round's question. The face loads in node: `chase.ts`, which defines the `<beltype-page>` element and so needs a DOM at load, is not here; a view imports it for that effect as `@beltype/cicero/internal/chase`.
+ * Exactly the names the first view adapter imported by deep path on 2026-10-29 (68 of them, from 16 modules), re-exported unchanged, and the names a view has asked for since (the leading-decoration door, `WRAPPED`, `clonesDecoration` and `truncateLeadingDecoration`, 2026-11-07); nothing is un-exported. Which of them stay public, merge or leave is the shape round's question. The face loads in node: `chase.ts`, which defines the `<beltype-page>` element and so needs a DOM at load, is not here; a view imports it for that effect as `@beltype/cicero/internal/chase`.
  *
  * @packageDocumentation
  */
 export { effectivePageName, readGeometryTable, registerGcpmProperties, topLevelReach, transliterateContent } from './capture.ts';
-export { ADJOIN, ARTIFACT, AWAY, END, FRAGMENT, SHELL, SPLIT, START, addWord, hasWord, removeWord } from './data-beltype.ts';
+export { ADJOIN, ARTIFACT, AWAY, END, FRAGMENT, SHELL, SPLIT, START, WRAPPED, addWord, hasWord, removeWord } from './data-beltype.ts';
 export { counterStateAt, documentOpsOf, namedStringsForPage, runningAssignmentsOf, stringAssignmentsOf } from './document-state.ts';
 export { ensureContinuationDressing, ensureDressing } from './dressing.ts';
 export { forcingIndexOf, gapAbove, pageNameDownFrom, runningBoxes, runningPosition, topLevelBlocks } from './driver.ts';
 export { ForcingMemo } from './forcing-memo.ts';
 export type { Keep } from './forcing-memo.ts';
-export { joinedWords, mutateToContinuation, mutateToFirstFragment, pinTrack } from './fragments.ts';
+export { joinedWords, mutateToContinuation, mutateToFirstFragment, pinTrack, truncateLeadingDecoration } from './fragments.ts';
 export { takeReport } from './gauge.ts';
 export { STRING_KEYWORDS, encodeStringProp } from './gcpm-encoding.ts';
 export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureContext } from './measure.ts';
@@ -21,4 +21,4 @@ export { divides, elAt, extensionPx, indexBlocks, normalizePath, pageContaining,
 export { present, presentation } from './presenters.ts';
 export { cssString, findPageSites, settleReads } from './reads.ts';
 export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.ts';
-export { BREAKING_SPACE, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.ts';
+export { BREAKING_SPACE, clonesDecoration, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.ts';