@beltype/cicero 0.1.8 → 0.1.10

package/dist/src/fragmentation.js

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

package/dist/src/fragments.d.ts

@@ -141,6 +141,12 @@ export declare function mutateToContinuation(clone: Element, { cut, remainderPx,
     hollow?: boolean;
     forced?: boolean;
 }): Element;
+/**
+ * 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 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>;
 /**
  * A clone of a top-level block for one interval, hollow outside it (*the clone is hollow outside the interval*, 2026-09-27) — the one construction behind the measure feed and every presented fragment, and the one place the clone-to-source map is filled.
  *

package/dist/src/fragments.js

@@ -19,8 +19,9 @@
  */
 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 { 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, 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 = [];
@@ -58,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) {
@@ -325,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);
     }
@@ -552,6 +552,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))
+            replaceChars(kept.node, kept.end, kept.end, 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.
@@ -751,7 +759,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))
@@ -790,8 +798,72 @@ export function mutateToContinuation(clone, { cut = null, remainderPx = null, so
         applyCarriedRemainder(clone, source, remainderPx);
     for (const m of mine)
         mutateToContinuation(m.itemClone, { cut: m.cut, remainderPx: m.e.remainingPx ?? null, source: m.itemSource, cloneOf, flows: m.nested, rootPath: m.e.item, hollow });
+    numberDividedLists(root, cut, source, cloneOf);
     return root;
 }
+/** The list items an `<ol>` owns, in tree order: HTML's list owner is the nearest `ol`, `ul` or `menu` ancestor. An item that is not displayed as a list item has no ordinal, where a style can be read. */
+function ownedItems(ol) {
+    const out = [];
+    (function walk(el) {
+        for (const c of el.children) {
+            if (/^(?:OL|UL|MENU)$/i.test(c.tagName))
+                continue;
+            if (/^LI$/i.test(c.tagName)) {
+                const display = sourceStyle(c)?.display;
+                if (display == null || display.includes('list-item'))
+                    out.push(c);
+            }
+            walk(c);
+        }
+    })(ol);
+    return out;
+}
+/**
+ * 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 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);
+    const reversed = ol.hasAttribute('reversed');
+    const dflt = reversed ? -1 : 1;
+    const start = parseInt(ol.getAttribute('start') ?? '', 10);
+    let n = (Number.isFinite(start) ? start : reversed ? items.length : 1) - dflt;
+    const out = new Map();
+    for (const li of items) {
+        const style = sourceStyle(li);
+        const named = (value, fallback) => pairsOf(value, fallback).find(([name]) => name === 'list-item')?.[1];
+        n += named(style?.counterIncrement, 1) ?? dflt;
+        const value = parseInt(li.getAttribute('value') ?? '', 10);
+        const set = named(style?.counterSet, 0) ?? (Number.isFinite(value) ? value : null);
+        if (set != null)
+            n = set;
+        out.set(li, n);
+    }
+    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.
+ */
+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))
+            continue;
+        const copy = cloneOf.get(a);
+        if (!copy)
+            continue;
+        for (const [li, n] of listOrdinals(a)) {
+            const c = cloneOf.get(li);
+            if (!c || !root.contains(c) || hasWord(c, AWAY))
+                continue;
+            copy.setAttribute('start', String(n));
+            break;
+        }
+    }
+}
 /** The shell branch of the start cut: the box the path names continues at exactly the extent it has left, blank or painted. */
 function shellAt(clone, target, px, keep = new Set(), hollow = false) {
     const painted = px.paint != null;
@@ -805,7 +877,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))
@@ -891,10 +963,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);
@@ -908,8 +988,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;
     };
@@ -1004,6 +1082,7 @@ export function mutateToFirstFragment(clone, { cut = null, extPx = 0, source = n
     /** And the cut line stays justified. css-text-3 §7.2 says a line before a forced or fragmentation break is not the last line of its block, so `text-align: justify` binds it — but in a clone cut AT the break it is the last line and the browser would set it ragged. The alignment is restated rather than inherited, and it is read from the source through the word space's map, because a detached clone has no computed style to ask. The Compositor makes the same move for the same reason (`compose-dom.js`), which is what makes this the engine's one answer written twice for two different line providers rather than two answers. */
     if (sourceStyle(inner)?.textAlign === 'justify')
         inner.style.textAlignLast = 'justify';
+    numberDividedLists(clone, cut, source, cloneOf);
     return clone;
 }
 /**

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 });

package/dist/src/measure.d.ts

@@ -1,9 +1,9 @@
 /**
  * The measure pass (first-coding-round.md, item 2): a hidden measurement container at true content width, off-viewport, one block flow, shared by every page of one geometry. The Chase is not in it and does not measure. Geometry comes from clones laid out here; law (break-* constraints, orphans, widows) is read from the source elements in the live document, so neutralization below never blinds legality reading.
  *
- * *Render-identical conditions* (I5) are pinned here: they are asserted at intake (unit DPR, explicit line-height — the DPR ruling), fonts and images are awaited once before the first measure, and native break properties plus orphans/widows are neutralized in the measure context. They are inert in an unfragmented column anyway — neutralization is stated, not assumed.
+ * *Render-identical conditions* (I5) are pinned here: they are asserted at intake (unit DPR, explicit line-height — the DPR ruling), fonts are awaited once before the first measure, and native break properties plus orphans/widows are neutralized in the measure context. They are inert in an unfragmented column anyway — neutralization is stated, not assumed.
  *
- * The images are awaited as a stand-in for the first run, and `awaitImages` says why in full.
+ * The first run no longer awaits the document's images (ruled 2026-11-08): it makes them eager ({@link eagerImages}), and the rim answers an arrival that changed a box. A measured slice's own images are still awaited ({@link awaitCloneImages}).
  *
  * @packageDocumentation
  */
@@ -28,26 +28,31 @@ export declare function assertRenderConditions(doc: Document, { relaxDpr }?: {
  */
 export declare function awaitFonts(doc: Document, faces?: string[]): Promise<void>;
 /**
- * Await every image that has not settled — [*images are awaited at intake*](../../../.claude/decisions/cicero/images-are-awaited-at-intake.md), reported as beltype#39.
+ * Make every `loading="lazy"` image eager, and wait for none: what the first run does with the document's pictures since 2026-11-08.
  *
- * **This is a stand-in, and the difference matters to whoever reads it next.** The tablet's model does not say images are awaited: it says they are *measured at declared or placeholder sizes*, and that the wrong measurement is then corrected through the one machinery all late-arriving truth shares — void from the box, rebuild forward — which since 2026-10-13 is the resumable run, called by the rim at the seam (`seam/rim.js`, *late truth is an edit*): a picture that becomes pending after the first measure is heard and resumed from, so for such a picture the correction exists. The await below is therefore a stand-in for the first run only: the choice there is still between awaiting and measuring an `<img>` at zero for the first paint, which is what the engine did until 2026-09-18, and what put whole blocks on no page. Retiring it trades a known-good first paint for one resume per image, and what that costs on the manual is a measurement owed (the record's Consequences), not a ruling.
+ * @remarks Egildo ruled on 2026-11-08 that the intake's and the driver's first-run awaits are retired, on the measurement `.claude/plans/quick-rulings-2026-11-08/image-await.md` in the monorepo: on a 59-page document with 60 images served 300 to 800 ms late, the first paint fell from 5.8 s to 0.74 s, the final layout was the same, and with declared sizes nothing moved on arrival. A picture measured before it arrived is late truth, and the rim answers it (`seam/rim.js`, *late truth is an edit*, amended 2026-11-08): one resume where its arrival changed its box, none where it did not. So the fast first paint is the author's to give: an image that declares its `width` and `height` is measured at its size before a byte of it arrives.
  *
- * **A measurement the engine has no way to correct must not be taken early.** The first run has the way now and does not use it; the await goes when that trade is measured and ruled.
+ * **A lazy image is still made eager** (*late truth is an edit*, 2026-10-13). Measured that day: a lazy image with no box never issues its request, and a parked original has no box, so it was measured at zero and never revisited. Lazy loading optimises for a viewport, and print has no viewport: there is nothing for it to save, and *the source document is never written* (C5) is untouched because the attribute is set on the original's `loading` property, which is a request for the bytes and not a change to what the document says. The clones the measure container receives copy the attribute, so they are eager too.
  *
- * A failed load settles at its error size: the wait resolves on `error` as it resolves on `load`, because what adjudication needs is that the geometry has stopped changing, not that it is the one the author wanted. `allSettled` for the same reason — one picture that never arrives must not hold the others.
+ * **It reads the originals and never the copies** (2026-10-08). A presented document carries a clone of every box on every page, and `document.images` met each picture once per copy (19 468 images for 157 real ones on a 123-page manual). A host that has presented hands the top-level boxes it took at intake; a first run has no copies and is handed the document.
  *
- * **A `loading="lazy"` image is made eager and awaited like the others** (*late truth is an edit*, 2026-10-13). Measured that day: a lazy image with no box never issues its request, and a parked original has no box, so the load the old paragraph hoped for ("the event may simply never come") was not a risk but the rule — the picture was measured at zero and never revisited. Lazy loading optimises for a viewport, and print has no viewport: there is nothing for it to save, and *the source document is never written* (C5) is untouched because the attribute is set on the original's `loading` property, which is a request for the bytes and not a change to what the document says. The clones the measure container receives copy the attribute, so they are eager too.
+ * @param scope - as {@link awaitImages}'s.
+ * @returns how many images were looked at, which the run's timing reads and nothing that decides does.
+ */
+export declare function eagerImages(scope: Document | Element | Element[]): number;
+/**
+ * Await every image in a scope that has not settled, a lazy one made eager first as {@link eagerImages} makes it. Since 2026-11-08 its one caller in the engine is {@link awaitCloneImages}: the first run no longer waits for the document's pictures (*images are awaited at intake*, retired that day for the first run).
  *
- * **It reads the originals and never the copies** (2026-10-08). A presented document carries a clone of every box on every page, and `document.images` met each picture once per copy — 19 468 images for 157 real ones on a 123-page manual, walked on every edit. A host that has presented hands the top-level boxes it took at intake and only their pictures are asked; a first run has no copies and is handed the document.
+ * A failed load settles at its error size: the wait resolves on `error` as it resolves on `load`, because what adjudication needs is that the geometry has stopped changing, not that it is the one the author wanted. `allSettled` for the same reason — one picture that never arrives must not hold the others.
  *
- * @param scope - a Document answers `images`; an element is asked for its own; a list of elements (the intake's top-level boxes) is asked box by box, each box included.
- * @returns how many images were looked at — read by the run's timing and by nothing that decides.
+ * @param scope - a Document answers `images`; an element is asked for its own; a list of elements is asked box by box, each box included.
+ * @returns how many images were looked at.
  */
 export declare function awaitImages(scope: Document | Element | Element[]): Promise<number>;
 /**
- * The clones' images, awaited where they are measured — the same stand-in, one step further in (2026-09-21, found by the Chromium 153 census).
+ * The clones' images, awaited where they are measured (2026-09-21, found by the Chromium 153 census). **It stays when the first run's two awaits went (ruled 2026-11-08) until the Service Worker case below is measured without it**: the measurement behind that ruling ran under no worker, and with this await gone too its first paint fell again, from 0.74 s to 0.39 s, and undeclared sizes refilled the pages as each picture came.
  *
- * `awaitImages(doc)` settles the document's own `<img>` elements, and the engine measures clones of them, mounted in the measure container. That was sound only on an unstated premise: that a clone of a loaded image is available synchronously — HTML's *list of available images*, which lets a second `<img>` for an already-fetched URL be `complete` the moment it is inserted. Chromium 150 honoured it everywhere. **Chromium 153 does not in a document a Service Worker controls**: measured in the editing tools' pane, every clone answered `complete: false` and a height of 0 in the turn it was mounted, and its real height 300 ms later — so every figure measured nothing, the cuts fell late, and the presentation then clipped what the account believed it had placed (the Caster specimen lost Figure 2 and the drawing after it, on no page at all). The CLI's dev server has no worker and was untouched, which is why the battery did not see it.
+ * Until 2026-11-08 `awaitImages(doc)` settled the document's own `<img>` elements first, and the engine measures clones of them, mounted in the measure container. That was sound only on an unstated premise: that a clone of a loaded image is available synchronously — HTML's *list of available images*, which lets a second `<img>` for an already-fetched URL be `complete` the moment it is inserted. Chromium 150 honoured it everywhere. **Chromium 153 does not in a document a Service Worker controls**: measured in the editing tools' pane, every clone answered `complete: false` and a height of 0 in the turn it was mounted, and its real height 300 ms later — so every figure measured nothing, the cuts fell late, and the presentation then clipped what the account believed it had placed (the Caster specimen lost Figure 2 and the drawing after it, on no page at all). The CLI's dev server has no worker and was untouched, which is why the battery did not see it.
  *
  * So the premise is checked instead of assumed: after a mount, if any image in the container has not settled, wait for it and lay out again. It costs nothing where the premise holds, and *a measurement the engine has no way to correct must not be taken early* is already this file's rule.
  *

package/dist/src/measure.js

@@ -1,9 +1,9 @@
 /**
  * The measure pass (first-coding-round.md, item 2): a hidden measurement container at true content width, off-viewport, one block flow, shared by every page of one geometry. The Chase is not in it and does not measure. Geometry comes from clones laid out here; law (break-* constraints, orphans, widows) is read from the source elements in the live document, so neutralization below never blinds legality reading.
  *
- * *Render-identical conditions* (I5) are pinned here: they are asserted at intake (unit DPR, explicit line-height — the DPR ruling), fonts and images are awaited once before the first measure, and native break properties plus orphans/widows are neutralized in the measure context. They are inert in an unfragmented column anyway — neutralization is stated, not assumed.
+ * *Render-identical conditions* (I5) are pinned here: they are asserted at intake (unit DPR, explicit line-height — the DPR ruling), fonts are awaited once before the first measure, and native break properties plus orphans/widows are neutralized in the measure context. They are inert in an unfragmented column anyway — neutralization is stated, not assumed.
  *
- * The images are awaited as a stand-in for the first run, and `awaitImages` says why in full.
+ * The first run no longer awaits the document's images (ruled 2026-11-08): it makes them eager ({@link eagerImages}), and the rim answers an arrival that changed a box. A measured slice's own images are still awaited ({@link awaitCloneImages}).
  *
  * @packageDocumentation
  */
@@ -45,30 +45,44 @@ export async function awaitFonts(doc, faces = []) {
     await Promise.all(faces.map((face) => doc.fonts.load(face).catch(() => [])));
     await doc.fonts.ready;
 }
+/** The `<img>` elements of a scope: a Document answers `images`; an element is asked for its own; a list of elements (the intake's top-level boxes) is asked box by box, each box included. */
+const imagesOf = (scope) => Array.isArray(scope)
+    ? scope.flatMap((el) => (el.localName === 'img' ? [el] : [...el.querySelectorAll('img')]))
+    : scope.images ?? scope.querySelectorAll('img');
 /**
- * Await every image that has not settled — [*images are awaited at intake*](../../../.claude/decisions/cicero/images-are-awaited-at-intake.md), reported as beltype#39.
+ * Make every `loading="lazy"` image eager, and wait for none: what the first run does with the document's pictures since 2026-11-08.
  *
- * **This is a stand-in, and the difference matters to whoever reads it next.** The tablet's model does not say images are awaited: it says they are *measured at declared or placeholder sizes*, and that the wrong measurement is then corrected through the one machinery all late-arriving truth shares — void from the box, rebuild forward — which since 2026-10-13 is the resumable run, called by the rim at the seam (`seam/rim.js`, *late truth is an edit*): a picture that becomes pending after the first measure is heard and resumed from, so for such a picture the correction exists. The await below is therefore a stand-in for the first run only: the choice there is still between awaiting and measuring an `<img>` at zero for the first paint, which is what the engine did until 2026-09-18, and what put whole blocks on no page. Retiring it trades a known-good first paint for one resume per image, and what that costs on the manual is a measurement owed (the record's Consequences), not a ruling.
+ * @remarks Egildo ruled on 2026-11-08 that the intake's and the driver's first-run awaits are retired, on the measurement `.claude/plans/quick-rulings-2026-11-08/image-await.md` in the monorepo: on a 59-page document with 60 images served 300 to 800 ms late, the first paint fell from 5.8 s to 0.74 s, the final layout was the same, and with declared sizes nothing moved on arrival. A picture measured before it arrived is late truth, and the rim answers it (`seam/rim.js`, *late truth is an edit*, amended 2026-11-08): one resume where its arrival changed its box, none where it did not. So the fast first paint is the author's to give: an image that declares its `width` and `height` is measured at its size before a byte of it arrives.
  *
- * **A measurement the engine has no way to correct must not be taken early.** The first run has the way now and does not use it; the await goes when that trade is measured and ruled.
+ * **A lazy image is still made eager** (*late truth is an edit*, 2026-10-13). Measured that day: a lazy image with no box never issues its request, and a parked original has no box, so it was measured at zero and never revisited. Lazy loading optimises for a viewport, and print has no viewport: there is nothing for it to save, and *the source document is never written* (C5) is untouched because the attribute is set on the original's `loading` property, which is a request for the bytes and not a change to what the document says. The clones the measure container receives copy the attribute, so they are eager too.
  *
- * A failed load settles at its error size: the wait resolves on `error` as it resolves on `load`, because what adjudication needs is that the geometry has stopped changing, not that it is the one the author wanted. `allSettled` for the same reason — one picture that never arrives must not hold the others.
+ * **It reads the originals and never the copies** (2026-10-08). A presented document carries a clone of every box on every page, and `document.images` met each picture once per copy (19 468 images for 157 real ones on a 123-page manual). A host that has presented hands the top-level boxes it took at intake; a first run has no copies and is handed the document.
  *
- * **A `loading="lazy"` image is made eager and awaited like the others** (*late truth is an edit*, 2026-10-13). Measured that day: a lazy image with no box never issues its request, and a parked original has no box, so the load the old paragraph hoped for ("the event may simply never come") was not a risk but the rule — the picture was measured at zero and never revisited. Lazy loading optimises for a viewport, and print has no viewport: there is nothing for it to save, and *the source document is never written* (C5) is untouched because the attribute is set on the original's `loading` property, which is a request for the bytes and not a change to what the document says. The clones the measure container receives copy the attribute, so they are eager too.
+ * @param scope - as {@link awaitImages}'s.
+ * @returns how many images were looked at, which the run's timing reads and nothing that decides does.
+ */
+export function eagerImages(scope) {
+    let seen = 0;
+    for (const img of imagesOf(scope)) {
+        seen++;
+        if (!img.complete && img.loading === 'lazy')
+            img.loading = 'eager'; // setting it starts the request a lazy image never made
+    }
+    return seen;
+}
+/**
+ * Await every image in a scope that has not settled, a lazy one made eager first as {@link eagerImages} makes it. Since 2026-11-08 its one caller in the engine is {@link awaitCloneImages}: the first run no longer waits for the document's pictures (*images are awaited at intake*, retired that day for the first run).
  *
- * **It reads the originals and never the copies** (2026-10-08). A presented document carries a clone of every box on every page, and `document.images` met each picture once per copy — 19 468 images for 157 real ones on a 123-page manual, walked on every edit. A host that has presented hands the top-level boxes it took at intake and only their pictures are asked; a first run has no copies and is handed the document.
+ * A failed load settles at its error size: the wait resolves on `error` as it resolves on `load`, because what adjudication needs is that the geometry has stopped changing, not that it is the one the author wanted. `allSettled` for the same reason — one picture that never arrives must not hold the others.
  *
- * @param scope - a Document answers `images`; an element is asked for its own; a list of elements (the intake's top-level boxes) is asked box by box, each box included.
- * @returns how many images were looked at — read by the run's timing and by nothing that decides.
+ * @param scope - a Document answers `images`; an element is asked for its own; a list of elements is asked box by box, each box included.
+ * @returns how many images were looked at.
  */
 export async function awaitImages(scope) {
     const pending = [];
     let seen = 0;
-    const images = Array.isArray(scope)
-        ? scope.flatMap((el) => (el.localName === 'img' ? [el] : [...el.querySelectorAll('img')]))
-        : scope.images ?? scope.querySelectorAll('img');
     // A snapshot of a live collection, and no event can fire between the test and the listener: the loop is one synchronous turn.
-    for (const img of images) {
+    for (const img of imagesOf(scope)) {
         seen++;
         if (img.complete)
             continue;
@@ -84,9 +98,9 @@ export async function awaitImages(scope) {
     return seen;
 }
 /**
- * The clones' images, awaited where they are measured — the same stand-in, one step further in (2026-09-21, found by the Chromium 153 census).
+ * The clones' images, awaited where they are measured (2026-09-21, found by the Chromium 153 census). **It stays when the first run's two awaits went (ruled 2026-11-08) until the Service Worker case below is measured without it**: the measurement behind that ruling ran under no worker, and with this await gone too its first paint fell again, from 0.74 s to 0.39 s, and undeclared sizes refilled the pages as each picture came.
  *
- * `awaitImages(doc)` settles the document's own `<img>` elements, and the engine measures clones of them, mounted in the measure container. That was sound only on an unstated premise: that a clone of a loaded image is available synchronously — HTML's *list of available images*, which lets a second `<img>` for an already-fetched URL be `complete` the moment it is inserted. Chromium 150 honoured it everywhere. **Chromium 153 does not in a document a Service Worker controls**: measured in the editing tools' pane, every clone answered `complete: false` and a height of 0 in the turn it was mounted, and its real height 300 ms later — so every figure measured nothing, the cuts fell late, and the presentation then clipped what the account believed it had placed (the Caster specimen lost Figure 2 and the drawing after it, on no page at all). The CLI's dev server has no worker and was untouched, which is why the battery did not see it.
+ * Until 2026-11-08 `awaitImages(doc)` settled the document's own `<img>` elements first, and the engine measures clones of them, mounted in the measure container. That was sound only on an unstated premise: that a clone of a loaded image is available synchronously — HTML's *list of available images*, which lets a second `<img>` for an already-fetched URL be `complete` the moment it is inserted. Chromium 150 honoured it everywhere. **Chromium 153 does not in a document a Service Worker controls**: measured in the editing tools' pane, every clone answered `complete: false` and a height of 0 in the turn it was mounted, and its real height 300 ms later — so every figure measured nothing, the cuts fell late, and the presentation then clipped what the account believed it had placed (the Caster specimen lost Figure 2 and the drawing after it, on no page at all). The CLI's dev server has no worker and was untouched, which is why the battery did not see it.
  *
  * So the premise is checked instead of assumed: after a mount, if any image in the container has not settled, wait for it and lay out again. It costs nothing where the premise holds, and *a measurement the engine has no way to correct must not be taken early* is already this file's rule.
  *

package/dist/src/positions.js

@@ -28,7 +28,7 @@
  *
  * @packageDocumentation
  */
-import { BREAKING_SPACE, isFixedBox, isInlineBox, isLineBreak } from './word-space.js';
+import { BREAKING_SPACE, inDisplayOrder, isFixedBox, isInlineBox, isLineBreak } from './word-space.js';
 /** `outer` is a proper prefix of `inner`: the row item at `outer` holds the one at `inner`. */
 const holds = (outer, inner) => outer.length < inner.length && outer.every((n, i) => n === inner[i]);
 /**
@@ -86,11 +86,11 @@ export function flattenResume(tree) {
 }
 /** The address, resolved and compared. Six small functions, all of them pure and all of them touching nothing but `.children`, `.parentElement` and plain arrays — so the DOM-free suites feed them object trees, and so a realm that holds only an account can still say which cut comes first. */
 /**
- * A box's in-flow element children — what a path's indices count.
+ * A box's in-flow element children — what a path's indices count — in display order, which differs from the order written inside a table alone (`word-space.js`' `inDisplayOrder`; *the-word-space-follows-the-table-display-order*, 2026-11-07): a header group written after its rows is a table's child 0, so paths order a table's boxes as its words are ordered.
  *
  * **A `position: fixed` box is not among them, and that is the only exclusion.** Its footprint is zero at any depth (CSS 2.1 §9.6.1, *a fixed box at any depth*), so it is in no flow, no word space, no feed and no presentation — and the address is the flow's own coordinate, so it is in no path either. That is also the only reading that resolves in every tree a path is resolved in, which is a stronger argument than the principle and was measured rather than assumed: the feed's clones have had fixed boxes stripped, the presentation's clones likewise, and the source is not one tree — `root.append(...blocks, ...fixed)` at intake reparents a nested fixed box out of the block it was declared in, so the tree the driver builds a path against and the tree the presentation resolves it against differ by exactly those boxes. Filtering makes the index the same number in all three; counting them raw made it right in one and wrong in the others, which is what put a shell on the box next door (`packages/essay/cases/55-the-shell-behind-the-fixed-box`).
  */
-const inFlowChildren = (el, isFixed) => [...(el.children ?? [])].filter((c) => !isFixed(c));
+const inFlowChildren = (el, isFixed) => inDisplayOrder(el, [...(el.children ?? [])].filter((c) => !isFixed(c)));
 /** The box a path names, descending from the top-level block it starts at. `null` where the tree no longer answers the path, which is an edited document rather than a defect. */
 export function elAtIn(blockEl, path, isFixed = isFixedBox) {
     let el = blockEl ?? null;
@@ -235,7 +235,7 @@ export function indexBlock(block, b, isInline = isInlineBox, isFixed = isFixedBo
         const inside = inWord;
         const start = count;
         const before = inside ? count - 1 : count;
-        for (const node of el.childNodes) {
+        for (const node of inDisplayOrder(el, [...el.childNodes])) {
             if (node.nodeType === 3) {
                 const s = node.data;
                 for (let i = 0; i < s.length; i++) {
@@ -304,25 +304,39 @@ export function indexBlocks(blocks, isInline = isInlineBox, isFixed = isFixedBox
 export function wordsBeforeChar(el, charOffset, isInline = isInlineBox) {
     if (!(charOffset >= 0))
         return null;
+    // The offset counts characters in the order written, and the words are counted in display order (*the-word-space-follows-the-table-display-order*): each text node's first character is found in the first order, and the walk below runs in the second.
+    const startOf = new Map();
     let chars = 0;
+    (function count(node) {
+        for (const child of node.childNodes) {
+            if (child.nodeType === 3) {
+                startOf.set(child, chars);
+                chars += child.data.length;
+            }
+            else if (child.nodeType === 1)
+                count(child);
+        }
+    })(el);
+    if (charOffset > chars)
+        return null;
     let words = 0;
     let inWord = false;
     let done = false;
     let inside = false;
     const walk = (node) => {
-        for (const child of node.childNodes) {
+        for (const child of inDisplayOrder(node, [...node.childNodes])) {
             if (done)
                 return;
             if (child.nodeType === 3) {
                 const s = child.data;
+                const start = startOf.get(child);
                 for (let i = 0; i < s.length; i++) {
                     // The character at the offset continues a word that began before it exactly when the walk is inside a word and this character is not a breaking space: `inWord` is the tokenization's own state, reset at every non-inline boundary, so a word does not straddle across one.
-                    if (chars === charOffset) {
+                    if (start + i === charOffset) {
                         inside = inWord && !BREAKING_SPACE.test(s[i]);
                         done = true;
                         return;
                     }
-                    chars++;
                     if (BREAKING_SPACE.test(s[i]))
                         inWord = false;
                     else if (!inWord) {
@@ -342,8 +356,6 @@ export function wordsBeforeChar(el, charOffset, isInline = isInlineBox) {
         }
     };
     walk(el);
-    if (!done && chars !== charOffset)
-        return null;
     return inside ? words - 1 : words;
 }
 /**