@beltype/cicero 0.1.9 → 0.1.11

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";
@@ -159,3 +163,9 @@ export declare const CUT_OFF: string;
  * - `adjoin`: the box a bare-path cut resumes at, and the first-child chain through which its margin collapses, give up the margin that adjoins the break (css-break-3 §5.2) and nothing else — they are not divided.
  */
 export declare const WORDS_RULES: string;
+/**
+ * The id a URL fragment names, percent-decoded; the raw text when it is not valid percent-encoding (`#%E0%A4%A`), where `decodeURIComponent` throws.
+ *
+ * @param hash - A `location.hash`, with or without its `#`.
+ */
+export declare function decodeFragment(hash: string): string;

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';
@@ -307,3 +312,17 @@ export const WORDS_RULES = `
   ${w(ADJOIN)} { margin-top: 0 !important; }
 }
 `;
+/**
+ * The id a URL fragment names, percent-decoded; the raw text when it is not valid percent-encoding (`#%E0%A4%A`), where `decodeURIComponent` throws.
+ *
+ * @param hash - A `location.hash`, with or without its `#`.
+ */
+export function decodeFragment(hash) {
+    const raw = hash.startsWith('#') ? hash.slice(1) : hash;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+}

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 a `counter(list-item)` an author's own content reads, a margin box's among them, reads low on a page a list continues onto; the list's markers are right since 2026-11-07, because each divided `<ol>`'s copy carries a `start` of HTML's own numbering (`fragments.js`'s `numberDividedLists`); 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 a `counter(list-item)` an author's own content reads, a margin box's among them, reads low on a page a list continues onto; the list's markers are right since 2026-11-07, because each divided `<ol>`'s copy carries a `start` of HTML's own numbering (`fragments.js`'s `numberDividedLists`); 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.
  *