@beltype/cicero 0.1.9 → 0.1.11

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,11 +2,11 @@
  * 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, 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`.
+ * 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/page`.
  *
  * @packageDocumentation
  */
-export { effectivePageName, readGeometryTable, registerGcpmProperties, topLevelReach, transliterateContent } from './capture.ts';
+export { effectivePageName, readGeometryTable, registerGcpmProperties, sheetReach, topLevelReach, transliterateContent } from './capture.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';
@@ -19,6 +19,6 @@ export { STRING_KEYWORDS, encodeStringProp } from './gcpm-encoding.ts';
 export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureContext } from './measure.ts';
 export { divides, elAt, extensionPx, indexBlocks, normalizePath, pageContaining, pageIntervals, pathOf, placeAt } from './positions.ts';
 export { present, presentation } from './presenters.ts';
-export { cssString, findPageSites, settleReads } from './reads.ts';
+export { cssString, findPageSites, findSites, settleReads } from './reads.ts';
 export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.ts';
 export { BREAKING_SPACE, clonesDecoration, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.ts';

package/dist/src/fragmentation.js

@@ -2,11 +2,11 @@
  * 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, 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`.
+ * 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/page`.
  *
  * @packageDocumentation
  */
-export { effectivePageName, readGeometryTable, registerGcpmProperties, topLevelReach, transliterateContent } from './capture.js';
+export { effectivePageName, readGeometryTable, registerGcpmProperties, sheetReach, topLevelReach, transliterateContent } from './capture.js';
 export { ADJOIN, ARTIFACT, AWAY, END, FRAGMENT, SHELL, SPLIT, START, WRAPPED, addWord, hasWord, removeWord } from './data-beltype.js';
 export { counterStateAt, documentOpsOf, namedStringsForPage, runningAssignmentsOf, stringAssignmentsOf } from './document-state.js';
 export { ensureContinuationDressing, ensureDressing } from './dressing.js';
@@ -18,6 +18,6 @@ export { STRING_KEYWORDS, encodeStringProp } from './gcpm-encoding.js';
 export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureContext } from './measure.js';
 export { divides, elAt, extensionPx, indexBlocks, normalizePath, pageContaining, pageIntervals, pathOf, placeAt } from './positions.js';
 export { present, presentation } from './presenters.js';
-export { cssString, findPageSites, settleReads } from './reads.js';
+export { cssString, findPageSites, findSites, settleReads } from './reads.js';
 export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.js';
 export { BREAKING_SPACE, clonesDecoration, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.js';

package/dist/src/fragments.d.ts

@@ -144,7 +144,7 @@ export declare function mutateToContinuation(clone: Element, { cut, remainderPx,
 /**
  * The ordinal value of each item an `<ol>` owns, as HTML numbers them (§4.4.8) and css-lists-3 states it as the `list-item` counter: the list resets the counter one step before its `start`, which under `reversed` defaults to the number of items; each item adds its step, 1 or −1 under `reversed` unless a `counter-increment` names `list-item`, and a `counter-set` of `list-item`, or else a `value` attribute, sets it.
  *
- * @remarks A `counter-reset` of `list-item` on an item, which opens a list of its own inside the list, is not modelled.
+ * @remarks A `counter-reset` of `list-item` on an item is left out on purpose: Chromium's print numbers the markers on through it, its ordinals HTML's and not the reset counter's (measured 2026-11-07, `test/browser/list-continuation.browser.ts`), so the `start` this ordinal becomes is the browser's own number for the item.
  */
 export declare function listOrdinals(ol: Element): Map<Element, number>;
 /**

package/dist/src/fragments.js

@@ -18,10 +18,10 @@
  * @packageDocumentation
  */
 import { applyRecordsUnder, hyphenCharOf } from './compose-dom.js';
-import { addWord, ADJOIN, ARTIFACT, AWAY, END, ENGINE_MARKS, hasAnyWord, hasWord, removeWord, SHELL, SPLIT, START, WRAPPED } from './data-beltype.js';
+import { addWord, ADJOIN, ARTIFACT, AWAY, BREAK, END, ENGINE_MARKS, hasAnyWord, hasWord, removeWord, SHELL, SPLIT, START, WRAPPED } from './data-beltype.js';
 import { pairsOf } from './document-state.js';
 import { divides, elAtIn, flowsOf } from './positions.js';
-import { BREAKING_SPACE, clonesDecoration, cutRanges, emptyText, leaveOut, replaceChars, isEngineText, isFixedBox, isInlineBox, isLineBreak, copyOf, shellOf, noteText, READS_ITS_CHILDREN, sourceOf, sourceStyle } from './word-space.js';
+import { BREAKING_SPACE, clonesDecoration, cutRanges, emptyText, inDisplayOrder, leaveOut, replaceChars, isEngineText, mayBeAutoHyphenated, noteEngineText, splitTextAt, isFixedBox, isInlineBox, isLineBreak, copyOf, shellOf, noteText, READS_ITS_CHILDREN, sourceOf, sourceStyle } from './word-space.js';
 /** The word space, clone side: words are maximal non-whitespace runs of the subtree's joined text — a run crossing a text-node or inline-element seam is one word, exactly as the Gauge reads, and exactly as the position index counts over sources (src/positions.js — the two tokenizations must never drift; counting per node instead shifts every offset by the seam-spanning words before it, which the test-document's inline markup caught). **A non-inline boundary ends the run** (word-space.js), which is where this stopped agreeing with the page for two months. This walk survives on the clone side only: consumption must find the resume word's actual text nodes in the mutated copy, which no source-side index can answer. */
 export function joinedWords(root, isInline = isInlineBox) {
     const words = [];
@@ -59,7 +59,7 @@ export function joinedWords(root, isInline = isInlineBox) {
             current = null;
     };
     const walk = (el) => {
-        for (const node of el.childNodes) {
+        for (const node of inDisplayOrder(el, [...el.childNodes])) {
             if (node.nodeType === 3)
                 scan(node);
             else if (node.nodeType === 1) {
@@ -326,11 +326,10 @@ export function truncateFrom(clone, el, { keep = false, hollow = false } = {}) {
         return clone;
     const chain = [];
     for (let e = el; e && e !== clone; e = e.parentElement) {
-        for (let sib = e.nextSibling; sib;) {
-            const next = sib.nextSibling;
+        // What follows in display order, which inside a table puts a footer written first after the rows and a header written last before them (*the-word-space-follows-the-table-display-order*).
+        const siblings = inDisplayOrder(e.parentElement, [...e.parentElement.childNodes]);
+        for (const sib of siblings.slice(siblings.indexOf(e) + 1))
             putAway(sib, hollow);
-            sib = next;
-        }
         if (e !== el || keep)
             chain.push(e);
     }
@@ -546,6 +545,7 @@ function consumeTrailingWords(clone, n, char = 0, hollow = false) {
     for (const [node, ranges] of perNode)
         cutRanges(node, ranges);
     // The hyphen is written at the cut (*the hyphen is written at the cut*, 2026-10-06). A soft hyphen the browser broke the line at is drawn there; one at the end of a fragment's last line is not, because nothing breaks after it. So the last kept character, where it is a soft hyphen, becomes the hyphenation character the browser drew — the box's own `hyphenate-character`, else U+2010 (css-text-4 §6.3.2) — and the empty string, which the property allows, removes it. A replacement: the word keeps its length, and the Compositor's own break, whose hyphen is already written and whose soft hyphen stands after it, cuts before the soft hyphen and never meets this.
+    let autoHyphen = null;
     if (char > 0 && words[n].text[char - 1] === '\u00AD') {
         const soft = charRanges(words[n], char - 1, char).find((r) => !r.engine);
         if (soft) {
@@ -553,6 +553,14 @@ function consumeTrailingWords(clone, n, char = 0, hollow = false) {
             replaceChars(soft.node, soft.start, soft.end, hyphen); // one character for one character maps one to one; the empty string, or several, is a removal and the engine's own text (`word-space.js`)
         }
     }
+    else if (char > 0) {
+        // A cut between two letters under `hyphens: auto` is one the Gauge minted only where it measured the hyphen the browser drew (`gauge.js`, `piecesOf`), so the same predicate on the same characters says the first fragment ends with it: the hyphenation character is added after the last kept letter, as the engine's own text. A Compositor's break already carries its written hyphen, an engine part at the boundary, and gets none.
+        const last = charRanges(words[n], char - 1, char);
+        const kept = last.find((r) => !r.engine);
+        const style = kept && sourceStyle(kept.node.parentElement);
+        if (kept && style && !last.some((r) => r.engine) && mayBeAutoHyphenated(words[n].text[char - 1], words[n].text[char], style.hyphens))
+            autoHyphen = { node: kept.node, end: kept.end, char: hyphenCharOf(style) };
+    }
     leaveOutAfter(clone, keepNode);
     // Structural pass: an element with no remaining words, standing entirely after the boundary, is spent — its edges adjoin the cut (§5.2) and it leaves the fragment.
     // A block standing wholly before the first dropped character is not after the boundary, words or none (*the anonymous box is in the procession*, 2026-09-29): a word cut in a box that holds blocks falls at a run's first word, and a wordless block between the last kept word and the run — a figure after the paragraph before it — is before the cut. Inside a line stack no block stands there, so the leaf's reading is the one it always was.
@@ -575,6 +583,19 @@ function consumeTrailingWords(clone, n, char = 0, hollow = false) {
     })(clone);
     for (const el of spent)
         putAway(el, hollow);
+    // Written last, after the leave-out and the structural pass that would take an element and a text with no source for spent: the hyphen the browser drew stands where the Compositor's stands, a text node of its own, the engine's, before a break mark (*the hyphen is written at the cut*; the printer finds the hyphen by that shape and the letters before it in the source's own run).
+    if (autoHyphen && autoHyphen.char) {
+        const { node, end } = autoHyphen;
+        const parent = node.parentNode;
+        const doc = node.parentElement.ownerDocument;
+        const before = end < node.data.length ? splitTextAt(node, end) : node.nextSibling;
+        const written = doc.createTextNode(autoHyphen.char);
+        noteEngineText(written);
+        const br = doc.createElement('br');
+        addWord(br, BREAK);
+        parent.insertBefore(written, before);
+        parent.insertBefore(br, before);
+    }
     for (let el = inner; el && el !== clone; el = el.parentElement)
         truncateTrailingDecoration(el);
     return inner;
@@ -752,7 +773,7 @@ export function mutateToContinuation(clone, { cut = null, remainderPx = null, so
             // Everything standing before the target leaves, at every level. Walked by sibling and never by index: the Compositor inserts `<br>`s and filler spans into a composed leaf, so a hint standing before the resume point is consumed with the rest rather than counted as a box.
             let el = clone;
             for (const step of chain) {
-                for (const sib of [...el.childNodes]) {
+                for (const sib of inDisplayOrder(el, [...el.childNodes])) {
                     if (sib === step)
                         break;
                     if (keep.has(sib))
@@ -814,7 +835,7 @@ function ownedItems(ol) {
 /**
  * The ordinal value of each item an `<ol>` owns, as HTML numbers them (§4.4.8) and css-lists-3 states it as the `list-item` counter: the list resets the counter one step before its `start`, which under `reversed` defaults to the number of items; each item adds its step, 1 or −1 under `reversed` unless a `counter-increment` names `list-item`, and a `counter-set` of `list-item`, or else a `value` attribute, sets it.
  *
- * @remarks A `counter-reset` of `list-item` on an item, which opens a list of its own inside the list, is not modelled.
+ * @remarks A `counter-reset` of `list-item` on an item is left out on purpose: Chromium's print numbers the markers on through it, its ordinals HTML's and not the reset counter's (measured 2026-11-07, `test/browser/list-continuation.browser.ts`), so the `start` this ordinal becomes is the browser's own number for the item.
  */
 export function listOrdinals(ol) {
     const items = ownedItems(ol);
@@ -836,14 +857,14 @@ export function listOrdinals(ol) {
     return out;
 }
 /**
- * Every `<ol>` a cut divides is numbered from the first item its piece keeps: the piece's copy carries a `start` attribute of that item's ordinal, so the browser's own marker counts on from the source's numbering. Without it a continued list numbered from 1 again on every page, and the first piece of a `reversed` list counted down from the items it kept (measured 2026-11-07 against Chromium's print, `test/browser/list-continuation.browser.ts`). Read from the source, so it holds whichever cut ran first.
+ * Every `<ol>` (or numbered `<ul>` or `<menu>`) a cut divides is numbered from the first item its piece keeps: the piece's copy carries a `start` attribute of that item's ordinal, so the browser's own marker counts on from the source's numbering. Without it a continued list numbered from 1 again on every page, and the first piece of a `reversed` list counted down from the items it kept (measured 2026-11-07 against Chromium's print, `test/browser/list-continuation.browser.ts`). Read from the source, so it holds whichever cut ran first.
  */
 function numberDividedLists(root, cut, source, cloneOf) {
     if (!divides(cut) || !source || !cloneOf)
         return;
     const target = elAtIn(source, cut.path);
     for (let a = target?.parentElement ?? null; a; a = a === source ? null : a.parentElement) {
-        if (!/^OL$/i.test(a.tagName))
+        if (!/^(?:OL|UL|MENU)$/i.test(a.tagName))
             continue;
         const copy = cloneOf.get(a);
         if (!copy)
@@ -852,7 +873,11 @@ function numberDividedLists(root, cut, source, cloneOf) {
             const c = cloneOf.get(li);
             if (!c || !root.contains(c) || hasWord(c, AWAY))
                 continue;
-            copy.setAttribute('start', String(n));
+            // HTML's `start` belongs to `<ol>` alone, and Chromium's marker ignores a `counter-reset` of `list-item` (both measured 2026-11-08), so a `ul` or `menu` continues by the first kept item's own `value`.
+            if (/^OL$/i.test(a.tagName))
+                copy.setAttribute('start', String(n));
+            else
+                c.setAttribute('value', String(n));
             break;
         }
     }
@@ -870,7 +895,7 @@ function shellAt(clone, target, px, keep = new Set(), hollow = false) {
             markShelled(el);
         for (let i = 0; i < chain.length; i++) {
             const step = chain[i];
-            for (const sib of [...el.childNodes]) {
+            for (const sib of inDisplayOrder(el, [...el.childNodes])) {
                 if (sib === step)
                     break;
                 if (keep.has(sib))
@@ -956,10 +981,18 @@ export function cloneInterval(source, { start = null, end = null, items = [], ho
         const c = register(s);
         const startStep = stepOf(s, onStart, startBox);
         const endStep = stepOf(s, onEnd, endBox);
+        // Before, in or after the interval is asked in display order (*the-word-space-follows-the-table-display-order*), and the copy keeps the order written.
+        const phases = new Map();
         let phase = startStep ? 'before' : 'in';
-        for (const node of s.childNodes) {
+        for (const node of inDisplayOrder(s, [...s.childNodes])) {
             if (node === startStep)
                 phase = 'in';
+            phases.set(node, phase);
+            if (node === endStep)
+                phase = 'after';
+        }
+        for (const node of s.childNodes) {
+            const phase = phases.get(node);
             let out;
             if (node.nodeType !== 1) {
                 out = node.cloneNode(false);
@@ -973,8 +1006,6 @@ export function cloneInterval(source, { start = null, end = null, items = [], ho
             else
                 out = deep(node);
             c.appendChild(out);
-            if (node === endStep)
-                phase = 'after';
         }
         return c;
     };

package/dist/src/gauge.d.ts

@@ -43,10 +43,6 @@ export type Box = {
     blockChildren: Box[];
     /** An anonymous block box (CSS 2.1 §9.2.1.1): no element of its own, no decoration, and every break property `auto`. */
     anonymous?: boolean;
-    /** A table's footer group written before its rows (`footerBeforeRows`), moved to the end of the table's procession, where §17.2 lays it out. */
-    laidOutLast?: boolean;
-    /** A table's header group written after its rows (`headerAfterRows`), moved to the front of the table's procession, where §17.2 lays it out. */
-    laidOutFirst?: boolean;
 };
 /** One line box, recovered arithmetically from the rects clustered onto it and the line-heights they are set on (`computeLines`). */
 export type LineBox = {

package/dist/src/gauge.js

@@ -15,7 +15,7 @@
  * @packageDocumentation
  */
 import { BREAK, selectorOf } from './data-beltype.js';
-import { blockChildrenOf, footerBeforeRows, headerAfterRows, isAtom, isEngineText, isInlineBox, isLineBreak, mayBeAutoHyphenated, rangeOf, READS_ITS_CHILDREN, rowsAmong, SIDE_BY_SIDE, wordRuns } from './word-space.js';
+import { blockChildrenOf, inDisplayOrder, isAtom, isEngineText, isInlineBox, isLineBreak, mayBeAutoHyphenated, rangeOf, READS_ITS_CHILDREN, rowsAmong, SIDE_BY_SIDE, wordRuns } from './word-space.js';
 /** The Compositor's own `<br>`, found by the browser and never by splitting the attribute here (the walkers below run per box). */
 const BREAK_SELECTOR = `br${selectorOf(BREAK)}`;
 /**
@@ -71,37 +71,17 @@ export function takeReport(container, { contentHeight }) {
         if (!box.inline)
             box.blockChildren = blockChildrenOf(box.el).map((el) => byEl.get(el)).filter(Boolean);
     const flowProcession = blockChildrenOf(container).map((el) => byEl.get(el)).filter(Boolean);
-    /** The footer stands last (*the footer before the rows*, 2026-10-15). CSS 2.1 §17.2 lays a `table-footer-group` out *"after all other rows and row groups"*, wherever it is written, and HTML lets it be written before them. The procession and the box list are the order the Stonehand walks and stops at the edge in, and that order is the layout's: such a footer is moved behind the table's last row or row group in both, and marked `laidOutLast`. Walked in the document's order it stood first and far below the edge, so the walk stopped at it and the page held the header alone (measured, `packages/essay/cases/110-the-footer-before-the-rows`: a 40-row table on two pages holding the header and the last two rows). The address stays the document's: the footer's words come before the rows in the word space, which is why the Stonehand offers no place before the footer or inside it. */
+    /** A table's procession is in display order (*the-word-space-follows-the-table-display-order*, 2026-11-07; `word-space.js`' `inDisplayOrder`): CSS 2.1 §17.2 lays a header group out before every row and row group and a footer group after them, wherever each is written, and the procession and the box list are the order the Stonehand walks and stops at the edge in. The word space and the paths follow the same order, so a place among a table's groups is addressed as it is laid out. Walked as written, a footer written first stood first and far below the edge, and the walk stopped at it with the page holding the header alone (measured, `packages/essay/cases/110-the-footer-before-the-rows`). */
     let moved = false;
     for (const box of boxes) {
-        if (box.inline || box.blockChildren.length < 2 || !/^(inline-)?table$/.test(win.getComputedStyle(box.el).display))
+        if (box.inline || box.blockChildren.length < 2)
             continue;
         for (const list of [box.blockChildren, box.children]) {
-            const f = list.findIndex((c) => footerBeforeRows(c.el));
-            if (f < 0)
+            const ordered = inDisplayOrder(box.el, list, (c) => c.el);
+            if (ordered === list)
                 continue;
-            let last = -1;
-            list.forEach((c, i) => {
-                if (/^table-row(-group)?$/.test(win.getComputedStyle(c.el).display))
-                    last = i;
-            });
-            if (last < f)
-                continue;
-            const [footer] = list.splice(f, 1);
-            list.splice(last, 0, footer); // `last` moved down by one with the removal, so this is the place after it
-            footer.laidOutLast = moved = true;
-        }
-        // The header stands first, the mirror (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): §17.2 lays a `table-header-group` out *"before all other rows and row groups"*, so one written after them is moved before the first. Its words stay after the rows in the word space, which is why the Stonehand offers no place inside it or right after it, and why the driver refuses one that does not repeat: only a copy can show it on a page before its words.
-        for (const list of [box.blockChildren, box.children]) {
-            const h = list.findIndex((c) => headerAfterRows(c.el));
-            if (h < 0)
-                continue;
-            const first = list.findIndex((c) => /^table-row(-group)?$/.test(win.getComputedStyle(c.el).display));
-            if (first < 0 || first > h)
-                continue;
-            const [header] = list.splice(h, 1);
-            list.splice(first, 0, header);
-            header.laidOutFirst = moved = true;
+            list.splice(0, list.length, ...ordered);
+            moved = true;
         }
     }
     /**
@@ -185,7 +165,7 @@ export function takeReport(container, { contentHeight }) {
         box.blockChildren = procession;
     }
     if (runSlot.size || moved) {
-        // Into the box list at their places in document order, the order the Stonehand walks and stops at the edge in: before the block child each precedes, and a trailing one after its container's whole subtree. A footer laid out last is visited where its table's children now put it.
+        // Into the box list at their places in document order, the order the Stonehand walks and stops at the edge in: before the block child each precedes, and a trailing one after its container's whole subtree. A table's groups are visited in display order, where its children now put them.
         const ordered = [];
         const visit = (box) => {
             ordered.push(box);
@@ -278,7 +258,7 @@ export function takeReport(container, { contentHeight }) {
      * One rect per word, largest top (the soft-wrap rule); duplicates from nested inlines collapse by construction — and one piece per line for a word the browser set on several lines at silent breaks or at a soft hyphen (*a line inside a word is a break point*, 2026-09-23; *the hyphen is written at the cut*, 2026-10-06).
      *
      * @remarks
-     * A word is a run of non-whitespace and a line box is not: CJK text, `word-break: break-all` and `overflow-wrap`'s emergency break set one word on many lines, and a word homed on its last line left every line above it out of the stack — no Class B point between them, and a page edge that divided a line through its glyphs (`packages/essay/cases/63-the-line-inside-a-word`). So where a word's inked rects (width over half a pixel: the soft-wrap rule's zero-width leading rect is not ink) cluster onto more than one line, the character each later line begins at is found by a binary search over single-character ranges, and each silent break opens a piece. A break after a soft hyphen opens a piece at the character after it, and the fragment writes the hyphen the browser drew there (*the hyphen is written at the cut*, 2026-10-06); a break the browser may have hyphenated between two letters under `hyphens: auto` (`word-space.js`' `mayBeAutoHyphenated`) opens none: that line joins the next, exactly as the largest-top rule always homed it. **A box carrying the Compositor's own breaks is split at them and nowhere else**: its lines are set by hints, so a word's later lines begin at the source characters its `<br>`s stand before, counted without the hyphen the Compositor wrote.
+     * A word is a run of non-whitespace and a line box is not: CJK text, `word-break: break-all` and `overflow-wrap`'s emergency break set one word on many lines, and a word homed on its last line left every line above it out of the stack — no Class B point between them, and a page edge that divided a line through its glyphs (`packages/essay/cases/63-the-line-inside-a-word`). So where a word's inked rects (width over half a pixel: the soft-wrap rule's zero-width leading rect is not ink) cluster onto more than one line, the character each later line begins at is found by a binary search over single-character ranges, and each silent break opens a piece. A break after a soft hyphen opens a piece at the character after it, and the fragment writes the hyphen the browser drew there (*the hyphen is written at the cut*, 2026-10-06); a break between two letters under `hyphens: auto` (`word-space.js`' `mayBeAutoHyphenated`) opens a piece where the browser drew a hyphen there, read in the range rects (`drewHyphen`), and the fragment writes it; one that drew none opens none, and that line joins the next, exactly as the largest-top rule always homed it. **A box carrying the Compositor's own breaks is split at them and nowhere else**: its lines are set by hints, so a word's later lines begin at the source characters its `<br>`s stand before, counted without the hyphen the Compositor wrote.
      */
     function measureWords(box) {
         if (wordCache.has(box))
@@ -301,6 +281,12 @@ export function takeReport(container, { contentHeight }) {
                     ink = r;
             return ink;
         };
+        /** Did the browser draw a hyphen at the line break before character `i`? Chromium leaves the glyph it drew in that character's range: an inked rect on the line the break ends, beside the character's own on the next (measured 2026-11-07 on Chromium 153, as *the hyphen is written at the cut* measured 2026-10-06; an `overflow-wrap` emergency break leaves none). */
+        const drewHyphen = (i, line) => {
+            range.setStart(...pointFor(nodes, i));
+            range.setEnd(...pointFor(nodes, i + 1, true));
+            return [...range.getClientRects()].some((r) => r.width > 0.5 && sharesLine(r.top, r.bottom, line.top, line.bottom));
+        };
         /** The pieces of the word at `[at, at + w.length)` whose inked rects are `rects`, or null for a word on one line. */
         const piecesOf = (at, w, rects) => {
             // The word's own lines, by the one rule `computeLines` reads a line by: sorted by top, a rect joins the line above it where it shares it.
@@ -339,7 +325,7 @@ export function takeReport(container, { contentHeight }) {
                     break;
                 const last = pieces[pieces.length - 1];
                 const line = { top: tops[j].top, height: tops[j].bottom - tops[j].top };
-                if (mayBeAutoHyphenated(w[lo - 1], w[lo], hyphens))
+                if (mayBeAutoHyphenated(w[lo - 1], w[lo], hyphens) && !drewHyphen(at + lo, tops[j - 1]))
                     Object.assign(last, line);
                 else
                     pieces.push({ char: lo, ...line });