@beltype/cicero 0.1.10 → 0.1.12

package/dist/src/driver.d.ts

@@ -30,12 +30,12 @@ export type ForcingEvent = {
     b: number;
     el: Element;
     cut: Address;
-    /** Its effective page name. */
-    name: string;
+    /** A class A break point stands in front of it where the end page value before and its start page value differ (css-page-3 §8.1), so a page break is forced there and the page after it takes its start page value. */
+    nameBreak: boolean;
     /** Its `break-before` is forced. */
     before: boolean;
     beforeParity: 'left' | 'right' | null;
-    /** Its `break-after` is forced, read only of an in-flow box. */
+    /** Its `break-after` is forced, read of an in-flow box and of a float (css-break-3 §3.1). */
     after: boolean;
     afterParity: 'left' | 'right' | null;
     /** The index just past its subtree. */
@@ -99,9 +99,22 @@ export declare const standsAfterArtifact: (el: Element) => boolean;
  */
 export declare function gapAbove(box: Box, report: ReturnType<typeof takeReport>, win: Window): number;
 /**
- * The effective page name of the deepest in-flow block that begins where a box does (css-page-3 §8.1): down the box's first in-flow block child while no run of words stands before that child, then `effectivePageName` from the box found. A first in-flow block child begins exactly where its parent does (§3.1.1's own coincidence), so the deepest box that starts the page is the end of the first-child chain.
+ * Does the `page` property apply to a box (css-page-3 §8.1, *"boxes that create class A break points"*)? An in-flow block-level box whose parent lays its children at class A break points (css-break-3 §4.1), and a table's row group or row.
  *
- * @remarks The driver's `nameAt` asks this of a cut that resumes at a box whole, with the position index's word counts for `runBefore`; a host with no index passes its own reading of the same question (*the engine knows no view*). Two reads are the host's: how a box's style is asked, and whether a run stands before a child.
+ * @remarks
+ * css-break-3 §4.1 counts *"a float and an immediately-adjacent in-flow or floated box"* among class A points too; the WPT tests `css-page/page-name-float-001` and `-002` have a name on a float force nothing, as Chromium prints them, and the engine follows the tests. A flex item, a grid item, a table cell and an inline-level box are not boxes it applies to (`page-name-flex-*`, `page-name-inline-block-003`).
+ *
+ * @param parent - the parent box's style, or null where the box stands in the body and nothing reads it.
+ */
+export declare function pageApplies(st: CSSStyleDeclaration, parent: CSSStyleDeclaration | null): boolean;
+/**
+ * The used page name of the box at `el` (css-page-3 §8.1): `effectivePageName` where the property applies to it, else its parent's. A box it does not apply to takes no name of its own; an inline box standing among blocks is in an anonymous block box, which the property applies to, named as its parent is.
+ */
+export declare function usedPageName(el: Element, styleOf: (el: Element) => CSSStyleDeclaration): string;
+/**
+ * The start page value of a box (css-page-3 §8.1): *"the value (if any) propagated from its first … child box, else the used value on the box itself"*, where *"a child propagates its own start … page value if and only if the page property applies to it"*. So down the first in-flow child while it is a box the property applies to ({@link pageApplies}) and no run of words stands before it, then {@link usedPageName} from the box found. The driver's `nameAt` names a page by it, and the forcing index compares it against the end page value before it.
+ *
+ * @remarks The driver's `nameAt` asks this of a cut that resumes at a box whole, with the position index's word counts for `runBefore`; a host with no index passes its own reading of the same question (*the engine knows no view*). Two reads are the host's: how a box's style is asked, and whether a run stands before a child. A run before the child is the box's first child box, an anonymous block box, which carries the box's own used value.
  *
  * @param el - The box the page begins in.
  * @param reads.runBefore - Whether a line of words stands before `child` in `parent`, which is the page's first content and the container's.
@@ -182,7 +195,7 @@ export declare const combineParity: (earlier: 'left' | 'right' | null, later: 'l
  *
  * This used to be a loop over consecutive feed items, and a feed item is a top-level block — so a command declared on a descendant was invisible, which is every heading in every BelType document since the belt began wrapping them in sections. The law (*no forced break lies inside an interval*, C1) always required this reading; the mechanism was narrower than the law. Descending closes it at word granularity, and §3.1.1's child→parent propagation falls out as a corollary rather than as walks: a `break-before` on a first in-flow child sits at the same word position as its container's start edge, and a `break-after` on a last in-flow child at the same position as its container's end, so the descent finds both where a promotion would have put them. `forcedBreakAfter` — the third of the rule's four walks, and the only forced one ever built — is deleted for exactly that reason.
  *
- * What the walk refuses to enter, each for its own citation: an absolutely positioned box (§3.1's must not — it neither carries forcing nor receives it, and §4.3's name switch is forcing under another name), a float's interior (§2.1 — a forced break inside a parallel flow does not affect the content outside it), and a monolith's interior (*the line box is the atom*, I3, and §4.1 in as many words: a forced break inside monolithic content must be ignored). A float's and a monolith's own commands are still read, which keeps case 14's declared §3.1 divergence exactly where the sixth round left it — except `break-after` on an out-of-flow box, which `forcedBreakAfter` never read either and which this walk goes on not reading rather than changing two things at once.
+ * What the walk refuses to enter, each for its own citation: an absolutely positioned box (§3.1's must not — it neither carries forcing nor receives it, and §4.3's name switch is forcing under another name), a float's interior (§2.1 — a forced break inside a parallel flow does not affect the content outside it), and a monolith's interior (*the line box is the atom*, I3, and §4.1 in as many words: a forced break inside monolithic content must be ignored). A float's and a monolith's own commands are still read: §3.1 says *"User agents should also apply these properties to floated boxes whose containing block is in the normal flow of the root fragmented element"*, so a float's forced `break-before` falls before its place in the flow and its forced `break-after` is pending into the box or run after it, never inside the float. A float the walk reaches has a containing block in that flow, since it never enters a float's or an absolutely positioned box's interior.
  *
  * `namesOnly` answers the composition region's version of the question. A name switch is the only forcing that changes the measure, so it is the only forcing a region must stop at: lines past a forced break are composed at the right width and merely unused.
  *
@@ -214,8 +227,12 @@ export declare function forcingIndexOf(blocks: Element[], { styleOf, pageNameOf,
     }) | null;
 }): {
     size: number;
-    /** The first forcing event strictly after `cursorCut` for a page named `name`, or null. */
-    find(cursorCut: Address, name: string, { namesOnly }?: {
+    /**
+     * The first forcing event strictly after `cursorCut`, or null.
+     *
+     * @param _name - the page's name, which a host still passes; a name break is the index's own, the end page value before a class A break point against the start page value after it (css-page-3 §8.1), and no longer a box's name against the page's.
+     */
+    find(cursorCut: Address, _name: string, { namesOnly }?: {
         namesOnly?: boolean;
     }): {
         b: number;

package/dist/src/driver.js

@@ -23,12 +23,13 @@ import { readGeometryTable, effectivePageName, pageRulesOf, styleSheetsOf, regis
 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 { documentOpsOf, withRunning, counterStateAt, pageNumberAt, withoutPageCounters, stringAssignmentsOf, runningAssignmentsOf, namedStringsForPage } from './document-state.js';
 import { RUNNING_PROP } from './gcpm-encoding.js';
 import { ARTIFACT, HOST, hasWord } from './data-beltype.js';
-import { blockChildrenOf, footerBeforeRows, inDisplayOrder, isFixedBox, SIDE_BY_SIDE, sourceOf } from './word-space.js';
+import { blockChildrenOf, footerBeforeRows, inDisplayOrder, isFixedBox, isInlineLevel, SIDE_BY_SIDE, sourceOf } from './word-space.js';
 import { changedPairs, settleReads } from './reads.js';
 import { converge, holderPage, namesNoPlace, priorKeys, restartPage } from './resume.js';
+import { readScope, foldTallColumns } from './scope.js';
 import { answerHas, boxesWhoseWordsMoved } from './has-words.js';
 const PX_PER = { px: 1, pt: 96 / 72, in: 96, cm: 96 / 2.54, mm: 96 / 25.4, q: 96 / 101.6 };
 function toPx(len) {
@@ -93,10 +94,37 @@ export function gapAbove(box, report, win) {
     }
     return gap;
 }
+/** The displays besides a block container's whose children stand at class A break points: a table's row groups and a row group's rows (css-break-3 §4.1). */
+const ROWS_HOLDER = /^(inline-)?table$|^table-(row-group|header-group|footer-group)$/;
+/** Does a box of this display lay its children out at class A break points, a block container's in-flow block-level children or a table's rows (css-break-3 §4.1)? A flex or grid container does not: css-page-3 §8.1 gives `page` to no flex or grid item. */
+const laysClassA = (display) => holdsAnonymousBlocks(display) || ROWS_HOLDER.test(display);
 /**
- * The effective page name of the deepest in-flow block that begins where a box does (css-page-3 §8.1): down the box's first in-flow block child while no run of words stands before that child, then `effectivePageName` from the box found. A first in-flow block child begins exactly where its parent does (§3.1.1's own coincidence), so the deepest box that starts the page is the end of the first-child chain.
+ * Does the `page` property apply to a box (css-page-3 §8.1, *"boxes that create class A break points"*)? An in-flow block-level box whose parent lays its children at class A break points (css-break-3 §4.1), and a table's row group or row.
  *
- * @remarks The driver's `nameAt` asks this of a cut that resumes at a box whole, with the position index's word counts for `runBefore`; a host with no index passes its own reading of the same question (*the engine knows no view*). Two reads are the host's: how a box's style is asked, and whether a run stands before a child.
+ * @remarks
+ * css-break-3 §4.1 counts *"a float and an immediately-adjacent in-flow or floated box"* among class A points too; the WPT tests `css-page/page-name-float-001` and `-002` have a name on a float force nothing, as Chromium prints them, and the engine follows the tests. A flex item, a grid item, a table cell and an inline-level box are not boxes it applies to (`page-name-flex-*`, `page-name-inline-block-003`).
+ *
+ * @param parent - the parent box's style, or null where the box stands in the body and nothing reads it.
+ */
+export function pageApplies(st, parent) {
+    if (isOutOfFlow(st))
+        return false;
+    const display = st.display ?? '';
+    if (isInlineLevel(display) || /^table-(cell|column|column-group|caption)$/.test(display))
+        return false;
+    return laysClassA(parent?.display ?? 'block');
+}
+/**
+ * The used page name of the box at `el` (css-page-3 §8.1): `effectivePageName` where the property applies to it, else its parent's. A box it does not apply to takes no name of its own; an inline box standing among blocks is in an anonymous block box, which the property applies to, named as its parent is.
+ */
+export function usedPageName(el, styleOf) {
+    const parent = el.parentElement;
+    return !parent || pageApplies(styleOf(el), styleOf(parent)) ? effectivePageName(el) : effectivePageName(parent);
+}
+/**
+ * The start page value of a box (css-page-3 §8.1): *"the value (if any) propagated from its first … child box, else the used value on the box itself"*, where *"a child propagates its own start … page value if and only if the page property applies to it"*. So down the first in-flow child while it is a box the property applies to ({@link pageApplies}) and no run of words stands before it, then {@link usedPageName} from the box found. The driver's `nameAt` names a page by it, and the forcing index compares it against the end page value before it.
+ *
+ * @remarks The driver's `nameAt` asks this of a cut that resumes at a box whole, with the position index's word counts for `runBefore`; a host with no index passes its own reading of the same question (*the engine knows no view*). Two reads are the host's: how a box's style is asked, and whether a run stands before a child. A run before the child is the box's first child box, an anonymous block box, which carries the box's own used value.
  *
  * @param el - The box the page begins in.
  * @param reads.runBefore - Whether a line of words stands before `child` in `parent`, which is the page's first content and the container's.
@@ -104,12 +132,15 @@ export function gapAbove(box, report, win) {
  */
 export function pageNameDownFrom(el, { styleOf, runBefore, blockChildren = blockChildrenOf }) {
     for (;;) {
+        const st = styleOf(el);
+        if (isOutOfFlow(st) || !laysClassA(st.display ?? ''))
+            break; // a page a float begins is named by the float's place in the flow, never by its interior
         const next = blockChildren(el).find((c) => !isOutOfFlow(styleOf(c)));
-        if (!next || runBefore(el, next))
+        if (!next || runBefore(el, next) || !pageApplies(styleOf(next), st))
             break;
         el = next;
     }
-    return effectivePageName(el);
+    return usedPageName(el, styleOf);
 }
 /**
  * Read the document's @page geometry from the CSSOM — every sheet the document wears, adopted ones included, and the rules inside its layers and conditions (`capture.ts`'s `pageRulesOf`). Returns page and content box sizes in px.
@@ -216,7 +247,7 @@ export const combineParity = (earlier, later) => later ?? earlier;
  *
  * This used to be a loop over consecutive feed items, and a feed item is a top-level block — so a command declared on a descendant was invisible, which is every heading in every BelType document since the belt began wrapping them in sections. The law (*no forced break lies inside an interval*, C1) always required this reading; the mechanism was narrower than the law. Descending closes it at word granularity, and §3.1.1's child→parent propagation falls out as a corollary rather than as walks: a `break-before` on a first in-flow child sits at the same word position as its container's start edge, and a `break-after` on a last in-flow child at the same position as its container's end, so the descent finds both where a promotion would have put them. `forcedBreakAfter` — the third of the rule's four walks, and the only forced one ever built — is deleted for exactly that reason.
  *
- * What the walk refuses to enter, each for its own citation: an absolutely positioned box (§3.1's must not — it neither carries forcing nor receives it, and §4.3's name switch is forcing under another name), a float's interior (§2.1 — a forced break inside a parallel flow does not affect the content outside it), and a monolith's interior (*the line box is the atom*, I3, and §4.1 in as many words: a forced break inside monolithic content must be ignored). A float's and a monolith's own commands are still read, which keeps case 14's declared §3.1 divergence exactly where the sixth round left it — except `break-after` on an out-of-flow box, which `forcedBreakAfter` never read either and which this walk goes on not reading rather than changing two things at once.
+ * What the walk refuses to enter, each for its own citation: an absolutely positioned box (§3.1's must not — it neither carries forcing nor receives it, and §4.3's name switch is forcing under another name), a float's interior (§2.1 — a forced break inside a parallel flow does not affect the content outside it), and a monolith's interior (*the line box is the atom*, I3, and §4.1 in as many words: a forced break inside monolithic content must be ignored). A float's and a monolith's own commands are still read: §3.1 says *"User agents should also apply these properties to floated boxes whose containing block is in the normal flow of the root fragmented element"*, so a float's forced `break-before` falls before its place in the flow and its forced `break-after` is pending into the box or run after it, never inside the float. A float the walk reaches has a containing block in that flow, since it never enters a float's or an absolutely positioned box's interior.
  *
  * `namesOnly` answers the composition region's version of the question. A name switch is the only forcing that changes the measure, so it is the only forcing a region must stop at: lines past a forced break are composed at the right width and merely unused.
  *
@@ -240,41 +271,84 @@ export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posO
     /**
      * @param [rowish]
      */
-    const visit = (el, b, sealedBy, rowish = false) => {
+    /**
+     * css-page-3 §8.1's two values ride the walk: `visit` answers a box's start and end page values where it stands among its siblings at class A break points — a box the property applies to, or an inline box standing among blocks, which is an anonymous block box named as its parent is — and null for any other. Each sibling whose start value differs from the end value before it is a name break.
+     *
+     * @param [rowish]
+     * @param parentStyle - the parent's style, null in the body where nothing reads it.
+     * @param parentName - the parent's used page name, which an anonymous block box in it takes.
+     */
+    const visit = (el, b, sealedBy, rowish, parentStyle, parentName) => {
         const st = styleOf(el);
         if (isAbsolutelyPositioned(st))
-            return; // §3.1's must not: it neither carries forcing nor receives it, so it is not an event at all
+            return null; // §3.1's must not: it neither carries forcing nor receives it, so it is not an event at all
         const parallel = isOutOfFlow(st);
-        const e = { b, el, cut: cutOf(el, b), name: pageNameOf(el), before: isForced(st.breakBefore), beforeParity: parityOf(st.breakBefore), after: false, afterParity: null, end: 0, pos: posOf(el, b), inFlow: !parallel, sealedBy, rowish };
+        const applies = pageApplies(st, parentStyle);
+        const anonymous = !applies && !parallel && isInlineLevel(st.display ?? '') && laysClassA(parentStyle?.display ?? 'block');
+        const used = applies ? pageNameOf(el) : parentName;
+        const e = { b, el, cut: cutOf(el, b), nameBreak: false, before: isForced(st.breakBefore), beforeParity: parityOf(st.breakBefore), after: false, afterParity: null, end: 0, pos: posOf(el, b), inFlow: !parallel, sealedBy, rowish };
         const k = events.length;
         events.push(e);
         const inner = sealedBy >= 0 ? sealedBy : neverCutInside(el, st) ? k : -1;
+        let first = null;
+        let last = null;
         if (!parallel && !monolith(el, st)) {
             const kids = blockChildren(el);
-            const runs = !!extentOf && holdsAnonymousBlocks(st.display ?? '');
+            // A run of lines among block children is an anonymous block box, or in a flex or grid container an anonymous item (CSS Flexbox §4, CSS Grid §6), which a forced break before it reaches the same way.
+            const runs = !!extentOf && (holdsAnonymousBlocks(st.display ?? '') || /^(inline-)?(flex|grid)$/.test(st.display ?? ''));
             const row = rowish || SIDE_BY_SIDE.has(st.display ?? '');
+            const flow = laysClassA(st.display ?? '');
+            const own = pageNameOf(el);
+            // The siblings' sequence: each box's start against the end before it, a run of lines being an anonymous block box named as `el` is.
+            const meet = (at, start, end) => {
+                if (!flow)
+                    return;
+                if (last !== null && last !== start)
+                    events[at].nameBreak = true;
+                first ??= start;
+                last = end;
+            };
+            if (runs && kids.length > 0 && extentOf(kids[0]).before > extentOf(el).before)
+                first = last = own;
             for (let i = 0; i < kids.length; i++) {
-                visit(kids[i], b, inner, row);
+                const at = events.length;
+                const met = visit(kids[i], b, inner, row, st, own);
+                if (met)
+                    meet(at, met.start, met.end);
                 if (!runs)
                     continue;
                 // A run of lines after this child is an anonymous block box, and the box a forced `break-after` closing here is pending into: an event at its first word, in the word space of the box that holds it (*the anonymous box is in the procession*). Words standing between the child's end and the next child's start, or this box's end, are the run; none is no box.
-                const ext = extentOf;
-                const own = ext(el);
-                const done = ext(kids[i]);
+                const extent = extentOf;
+                const ext = extent(el);
+                const done = extent(kids[i]);
                 const word = done.before + done.count;
                 const next = kids[i + 1];
-                if ((next ? ext(next).before : own.before + own.count) <= word)
+                if ((next ? extent(next).before : ext.before + ext.count) <= word)
                     continue;
-                events.push({ b, el, cut: cutOf(el, b, word - own.before), name: e.name, before: false, beforeParity: null, after: false, afterParity: null, end: events.length + 1, pos: e.pos + word - own.before, inFlow: true, sealedBy: inner, rowish: row, runAfter: kids[i] });
+                events.push({ b, el, cut: cutOf(el, b, word - ext.before), nameBreak: false, before: false, beforeParity: null, after: false, afterParity: null, end: events.length + 1, pos: e.pos + word - ext.before, inFlow: true, sealedBy: inner, rowish: row, runAfter: kids[i] });
+                meet(events.length - 1, own, own);
             }
         }
-        e.after = !parallel && isForced(st.breakAfter); // a float's own break-after was never read, and still is not
+        e.after = isForced(st.breakAfter); // a float's too (§3.1's should): pending into what follows its place in the flow
         e.afterParity = parityOf(st.breakAfter);
         e.end = events.length;
+        if (!applies && !anonymous)
+            return null;
+        return { start: applies ? first ?? used : used, end: applies ? last ?? used : used };
     };
+    const root = blocks[0]?.parentElement ?? null;
+    const rootStyle = root ? styleOf(root) : null;
+    const rootName = root ? pageNameOf(root) : '';
+    let before = null;
     for (let b = 0; b < blocks.length; b++) {
         blockStart.push(events.length);
-        visit(blocks[b], b, -1);
+        const at = events.length;
+        const met = visit(blocks[b], b, -1, false, rootStyle, rootName);
+        if (!met)
+            continue;
+        if (before !== null && before !== met.start)
+            events[at].nameBreak = true;
+        before = met.end;
     }
     const n = events.length;
     // What the walk carries as `pending` into event k from the boxes that close just in front of it: those whose subtree ends at k, deepest first — a larger index is a deeper box — so the outermost's parity is the one that stands.
@@ -288,13 +362,13 @@ export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posO
     for (let k = n - 1; k >= 0; k--)
         nextForced[k] = closing[k] || events[k].before ? k : nextForced[k + 1];
     const nextName = new Array(n + 1).fill(n);
-    for (let k = n - 2; k >= 0; k--)
-        nextName[k] = events[k + 1].name !== events[k].name ? k + 1 : nextName[k + 1];
-    const hit = (k, pending, name, namesOnly) => {
+    for (let k = n - 1; k >= 0; k--)
+        nextName[k] = events[k].nameBreak ? k : nextName[k + 1];
+    const hit = (k, pending, namesOnly) => {
         const e = events[k];
         const before = !namesOnly && e.before;
         // §4.3's combination at the one break point where two forced values meet: the `break-after` pending into the box, and the box's own `break-before`, the later element in the flow, whose parity wins where it has one. The address is a copy, so no page can reach into the index through it.
-        return { b: e.b, namedSwitch: e.name !== name, el: e.el, cut: { ...e.cut, path: [...e.cut.path] }, parity: combineParity(pending?.parity ?? null, before ? e.beforeParity : null), rowish: e.rowish, runAfter: e.runAfter };
+        return { b: e.b, namedSwitch: e.nameBreak, el: e.el, cut: { ...e.cut, path: [...e.cut.path] }, parity: combineParity(pending?.parity ?? null, before ? e.beforeParity : null), rowish: e.rowish, runAfter: e.runAfter };
     };
     /** The first event strictly after the cursor — a binary search, because a bare address never precedes the one before it in walk order — or `n` where there is none. */
     const firstAfter = (cursorCut) => {
@@ -314,20 +388,24 @@ export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posO
     };
     return {
         size: n,
-        /** The first forcing event strictly after `cursorCut` for a page named `name`, or null. */
-        find(cursorCut, name, { namesOnly = false } = {}) {
+        /**
+         * The first forcing event strictly after `cursorCut`, or null.
+         *
+         * @param _name - the page's name, which a host still passes; a name break is the index's own, the end page value before a class A break point against the start page value after it (css-page-3 §8.1), and no longer a box's name against the page's.
+         */
+        find(cursorCut, _name, { namesOnly = false } = {}) {
             const s = firstAfter(cursorCut);
             if (s >= n)
                 return null;
             // Pending into s: the forced break-afters whose subtree closes exactly in front of it — never one that closed earlier, which was spent where it fell (*a box is not its first child*).
             const pending = namesOnly ? null : closing[s];
-            if (pending || events[s].name !== name || (!namesOnly && events[s].before))
-                return hit(s, pending, name, namesOnly);
+            if (pending || events[s].nameBreak || (!namesOnly && events[s].before))
+                return hit(s, pending, namesOnly);
             const k = s + 1;
             if (k >= n)
                 return null;
-            const f = Math.min(events[k].name !== name ? k : nextName[k], namesOnly ? n : nextForced[k]);
-            return f < n ? hit(f, namesOnly ? null : closing[f], name, namesOnly) : null;
+            const f = Math.min(nextName[k], namesOnly ? n : nextForced[k]);
+            return f < n ? hit(f, namesOnly ? null : closing[f], namesOnly) : null;
         },
         /**
          * The Cast-off's place (*the Cast-off bounds the feed*, 2026-09-26): the first block boundary strictly after `cursorCut` whose word position is at least `pos`, where a feed may be cut without moving any box before it — or null, where no such place is left and the feed is the whole remainder.
@@ -531,6 +609,8 @@ export function paginate(doc, opts = {}) {
     const boxes = opts.originals ?? topLevelBoxes(doc);
     const hasMarks = answerHas(doc, boxes, keep);
     performance.measure('cicero:has-words', { start: t0, end: performance.now(), detail: { boxes: boxes.length, marked: hasMarks.size, ...(memo ? { memo: memo.tally.has ?? null } : {}) } });
+    // Before the reads' counter walk, whose log the run takes: the reason is paginateOnce's, where the call stays for a caller that runs once.
+    registerGcpmProperties(doc.defaultView);
     return settleReads(doc, { run: (laid) => paginateOnce(doc, opts, laid, { boxes, hasMarks, memo }), blocksOf: () => opts.blocks ?? topLevelBlocks(doc), originals: opts.originals ?? opts.blocks ?? null, warm: opts.prior && opts.dirtyAt ? opts.prior.delivered : null, warmFacts: opts.prior && opts.dirtyAt ? opts.prior.facts ?? null : null, hide: !!opts.pace, keep });
 }
 /**
@@ -577,6 +657,8 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
     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;
     const blocks = intakeBlocks ?? topLevelBlocks(doc);
+    // What is out of scope is refused here, and a multi-column box too tall for a page becomes one column on its copies (`src/scope.ts`).
+    foldTallColumns(doc, readScope(win, blocks), table.pageFor({ first: true }));
     // The running elements and where each was written, handed back with the blocks by a host that took them at intake, for the same reason: by now the body holds the root and nothing else.
     const running = intakeRunning ?? runningBoxes(doc, memo?.keep);
     /** Whether a box outside an interval may be hollow (*the clone is hollow outside the interval*, 2026-09-27; *one attribute has words*, 2026-10-10). It may, unless a stylesheet the document wears has a `:has(` that nothing answers for: the host rewrites every `:has()` it can into a union that a `has:` word on the copy satisfies (`has-words.js`), and only an argument reading user state (`:hover`, `:checked`, `:focus-within`, `:target`, …) is left alone, with a console line from the rewrite naming the rule. Then every feed is built deep, as before, and the console says so once per run. `root.js` asks the same question of the same sheets when it presents. */
@@ -643,11 +725,14 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
      *
      * The ancestors are `html` and `body` — every top-level block is a body child — and they are recorded before the document's first word, which is what puts a `body { counter-reset }` in force on page one.
      */
-    const documentOps = documentOpsOf(blocks, index, {
+    const ancestors = [doc.documentElement, doc.body].filter(Boolean);
+    const runningAt = running.map((r) => ({ name: r.name, pos: runningPosition(r, index) }));
+    // The reads' walk, where they took one, is this walk under their marks: a mark ends what an operation at its depth would end, and adds nothing else (`reads.ts`' `settleReads`).
+    const documentOps = laid.ops ? withRunning(laid.ops, runningAt) : documentOpsOf(blocks, index, {
         styleOf: (el) => win.getComputedStyle(el),
         pseudoStyleOf: sheetsCountInPseudos(doc) ? (el, pseudo) => win.getComputedStyle(el, pseudo) : null,
-        ancestors: [doc.documentElement, doc.body].filter(Boolean),
-        running: running.map((r) => ({ name: r.name, pos: runningPosition(r, index) })),
+        ancestors,
+        running: runningAt,
         keep: memo?.keep
     });
     // The same walk's second reading (*the host rewrites what the parser drops*, 2026-09-14): every named-string assignment the document makes, with the position it sits at. Evaluated here, where the source is still in its real ancestor chain — `content()` is the element's own text and would come back right from an unassigned slottable, but `counter()` inside a content list would not, and neither would anything inherited.
@@ -672,7 +757,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
         : forcingIndexOf(blocks, { styleOf: (el) => win.getComputedStyle(el), pageNameOf: effectivePageName, cutOf: (el, b, word = null) => cutTo(el, b, { word }), posOf: (el, b) => index.posOf(b, index.wordsBefore(el)), posOfCut, extentOf });
     performance.measure('cicero:forcing-index', { start: t, end: (t = performance.now()), detail: { events: forcing.size, ...(memo ? { memoHits: memo.hits, memoMisses: memo.misses } : {}) } });
     /**
-     * The effective page name at an address: the deepest in-flow block that begins there, then css-page-3 §8.1's ancestor walk from it. A page may begin inside a block whose interior named a different page, so the cursor's block is not the thing to ask.
+     * The page name at an address: the start page value of the box that begins there (css-page-3 §8.1, `pageNameDownFrom`), or, where the page resumes inside a box, that box's used page name. A page may begin inside a block whose interior named a different page, so the cursor's block is not the thing to ask.
      *
      * A bare path resumes at a box whole, and a first in-flow block child begins exactly where its parent does (§3.1.1's own coincidence), so the deepest box that starts the page is the end of the first-child chain — which is where the old search for *the box containing word w* arrived, without the ambiguity a wordless first child gave it. A word or a pixel extent names a box the page resumes inside, and that box is itself the deepest; where the old search read the box after an end gap, it was naming the wrong side of a cut that resumes in the gap.
      */
@@ -681,9 +766,10 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
         if (!el)
             return '';
         // A line before a child is the page's first content, and it is the container's (*the anonymous box is in the procession*).
+        const styleOf = (c) => win.getComputedStyle(c);
         if (cut.word == null && cut.px == null)
-            return pageNameDownFrom(el, { styleOf: (c) => win.getComputedStyle(c), runBefore: (parent, child) => index.wordsBefore(child) !== index.wordsBefore(parent) });
-        return effectivePageName(el);
+            return pageNameDownFrom(el, { styleOf, runBefore: (parent, child) => index.wordsBefore(child) !== index.wordsBefore(parent) });
+        return usedPageName(el, styleOf);
     };
     /**
      * The document's own first page — css-page-3 §3.3, and it is a parity offset rather than a blank entry.
@@ -787,6 +873,13 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
             pageCounters.set(key, ops = table.pageFor({ name: c.name, first: i === 0, parity: c.parity, blank: c.blank }).pageCounter);
         return ops;
     };
+    /**
+     * The depth in the counter log's terms of the place a cut names: the element its path reaches, below the ancestors, or one level further in where the cut falls inside it, among its children (a `word` or a `px`).
+     *
+     * @remarks
+     * A place inside an element is taken at its children's depth, so an instance a grandchild opened before the cut is ended there even where the cut falls inside the child that holds it: a counter reset on an inline element nested in another inside a paragraph a page divides. No case claims it.
+     */
+    const depthOfCut = (cut) => ancestors.length + cut.path.length - 1 + (cut.word != null || cut.px != null ? 1 : 0);
     /** The conditions of page `pageIndex`, which begins at `cut` (projected to `pos`) — {@link conditionsFor} with the cursor made a parameter, so a resumed run can write the conditions of a page it keeps from the address that page began at (*the run resumes from an entry*, build two, 2026-10-08). */
     const conditionsAt = (pageIndex, cut, pos, { blank = false, carried = null } = {}) => {
         const name = nameAt(cut);
@@ -796,7 +889,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
         // The run's count, an author's reset of the page counter counted on from the page it begins on, and each page's own `@page` counter rules (`document-state.js`'s `pageNumberAt`). Entry `i` closes page `i`, so page `i` begins where entry `i - 1` ended, under the conditions it closes.
         const pageNumber = pageNumberAt(documentOps, pageIndex, pos, { pages: (i) => ({ start: i === 0 ? 0 : account[i - 1].pos ?? 0, blank: account[i].blank === true, counter: pageCounterOf(i, account[i].closes) }), blank, counter: geo.pageCounter, away });
         // The document's counters as they stand at this page's first word — strictly before it, which is §6.1's *spans the page break* in the flat position space (`document-state.js`) — less what the flows carried onto this page have still to show, which stands before that word and is on this page or after it (beltype#43). The page's own two are not among them: they are the host's, and `pageNumber` carries the reset.
-        const counters = withoutPageCounters(counterStateAt(documentOps, pos, away));
+        const counters = withoutPageCounters(counterStateAt(documentOps, pos, away, depthOfCut(cut)));
         return Object.freeze({ ...geo, name, pageNumber, parity, blank, counters, dpr: win.devicePixelRatio });
     };
     /**
@@ -1139,6 +1232,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
         const conditions = conditionsFor(account.length);
         const recreated = ctx === null || conditions.contentW !== ctxWidth;
         if (recreated) {
+            ctx?.dispose(); // each context seats a container of its own (since 2026-11-06), and one left standing is laid out in the document and printed
             ctx = createMeasureContext(doc, conditions.contentW);
             ctxWidth = conditions.contentW;
         }
@@ -1218,10 +1312,15 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
         let container;
         let pageStart;
         let spentLead;
+        /** The place the last pour stood at when the check failed: a doubled bound that names it again is the same feed. */
+        let short = null;
         for (;;) {
             pours++;
             // The place first, then the feed cloned to it (*the clone is hollow outside the interval*, 2026-09-27): neither the Cast-off's place nor the forced event needs anything but the cursor and the index.
-            const place = castOff.bound(cursor, words);
+            let place = castOff.bound(cursor, words);
+            // A doubled bound whose place is the one the last pour stopped above the edge at, its words landing inside the same long paragraph or the same box the bound never cuts inside, would pour the same feed again: it is doubled on without pouring (critic2-long-paragraph-quadratic, 2026-11-09).
+            while (place && place.el === short)
+                place = castOff.bound(cursor, (words = words * 2));
             const forcingCuts = !!forcedEvent && !rowForced && (!place || !cutAfter(forcedEvent.cut, place.cut, posOfCut));
             bounded = !forcingCuts && !!place;
             ({ items, cloneOfSource } = buildFeed(forcingCuts ? forcedEvent : bounded ? place : null, forcingCuts ? 'the grab' : 'the Cast-off'));
@@ -1240,7 +1339,9 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
             pageStart = (truncateLead ? report.contentTop : 0) + spentLead;
             if (rowForced) {
                 /** A forced break inside a box that lays its children side by side is not the grab's to cut at (*a parallel flow is a fragmentainer*, 2026-10-08; *a forced break inside a cell*, P37c): the cut falls in the item's flow and only the row's height crosses the wall, so the feed is not cut at the event — a word position cannot say a cell's place, and cutting there put away the neighbour cell with everything after the paragraph in document order. Whether the event is inside a row item is a fact of the layout, asked here of the report: the box stands inside an item of a row that is not itself inside another item's, and after a sibling in the item's procession (a break before an item's first block is the item's own start). Where it is not, the grab cuts as it always did. An event past the feed the Cast-off bounded is not this page's, and a longer pour may reach it. */
-                const clone = cloneOfSource.get(forcedEvent.el);
+                // A run has no box: its event is asked through the block child it follows, after which it stands, so it is never its item's start.
+                const ev = forcedEvent;
+                const clone = cloneOfSource.get(ev.runAfter ?? ev.el);
                 const at = clone ? report.boxOf(clone) : null;
                 rowEventIn = !!clone;
                 if (clone) {
@@ -1254,7 +1355,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
                                 item = a;
                         }
                     const sequence = at ? report.processionOf(at) : [];
-                    if (!at || !item || nested || sequence.indexOf(at) < 1 || at.rect.top <= item.rect.top + 0.25) {
+                    if (!at || !item || nested || (!ev.runAfter && (sequence.indexOf(at) < 1 || at.rect.top <= item.rect.top + 0.25))) {
                         rowForced = false; // not a row's: the grab's, as before
                         continue;
                     }
@@ -1262,6 +1363,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
             }
             if (!bounded || reachesBelowTheEdge({ report, sourceOf, pageStart, contentHeight: conditions.contentH }))
                 break;
+            short = place.el;
             // @ts-expect-error `words` is a number wherever the feed is bounded, and a feed that is not bounded broke out above
             words *= 2;
         }

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.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, inDisplayOrder, leaveOut, replaceChars, isEngineText, mayBeAutoHyphenated, 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 = [];
@@ -545,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) {
@@ -558,7 +559,7 @@ function consumeTrailingWords(clone, n, char = 0, hollow = false) {
         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));
+            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.
@@ -582,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;
@@ -748,6 +762,10 @@ export function mutateToContinuation(clone, { cut = null, remainderPx = null, so
     const mine = itemsOf(flows ?? flowsOf(items), path, source, cloneOf);
     // The items of a divided row stand before the place this cut resumes at, and are not spent: each has a place of its own, applied below.
     const keep = new Set(mine.map((m) => m.itemClone));
+    // A row a spanning cell's group reaches stands before the place too (the Gauge's rows: a `rowspan` makes the cells of every row it spans one row), and every cell in it is an item with a place of its own, so the row stays and its cells are cut below.
+    for (const m of mine)
+        if (m.itemClone.parentElement && m.itemClone.parentElement !== clone && /^TR$/i.test(m.itemClone.parentElement.tagName))
+            keep.add(m.itemClone.parentElement);
     if (divides(cut)) {
         const target = targetOf(cut, source, cloneOf);
         if (!target)
@@ -843,14 +861,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)
@@ -859,7 +877,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;
         }
     }
@@ -896,6 +918,9 @@ function shellAt(clone, target, px, keep = new Set(), hollow = false) {
             el.style.boxSizing = 'border-box';
             el.style.height = `${Math.max(0, px.remaining)}px`;
             el.style.minHeight = '0';
+            // Its block-end padding is spent with the rest (`block-end-padding-taller-than-page`, assessment 2026-11-07): the shell has no content, so its padding paints exactly as the content box it gives way to, and the border box is the remainder alone. A padding taller than the page area otherwise held every shell at its own height, the remainder never shrank, and the walk refused. A box that clones its decoration wears its padding on every fragment, so it keeps it.
+            if (!clonesDecoration(el))
+                el.style.setProperty('padding-bottom', '0', 'important');
             return clone;
         }
         // The painted shell: a slice wrapper takes the box's place in flow at exactly the leftover height and clips there; the box keeps its natural size — an image must never be resized into the remainder — and a negative top margin pulls the already-shown part above the clip.