@beltype/cicero 0.1.5 → 0.1.7

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

@@ -128,6 +128,33 @@ export declare function counterStateAt(ops: ReturnType<typeof documentOpsOf>, po
     from: number;
     to: number;
 }>): Record<string, number[]>;
+/**
+ * The page number of page `pageIndex`, which begins at `pos`: the run's own count, or, where an element reset the page counter, that element's value counted on from the page it begins on.
+ *
+ * @remarks
+ * css-page-3 names a reset of the page counter only in the page context, but an author writes `counter-reset: page 1` on a chapter or on each letter of a print run to number its pages from one, and once the engine applies it the pages after must count on from there rather than stay at the value (Codeberg issue 1). The page counter is the page's own, reset on the host as `page N` (`chase.js`'s `setCounters`), so the reset is folded into N here and never delivered as an author counter: delivered, it reset the flow and the margin cells to the same value on every later page in the reset's scope. `target-counter()` to a page reads the same N (`reads.js`'s `pageValues`), so a reference answers the value the counter has at its target (Codeberg issue 2).
+ *
+ * The last `counter-reset` or `counter-set` of `page` at or before `pos` is the one in force: **at**, not strictly before, because the element that begins on the page is the one that numbers it, where an author counter's reset waits for the next page (css-page-3 §6.1 is about author counters). Scope is not replayed, since the page counter has one instance: a reset stands until the next one, whatever the depth of either. A reset on an element that begins mid-page numbers the next page.
+ *
+ * **A blank page the engine makes to bring the element to its side begins where the element does and stands before it** (Codeberg issue 13): the reset is not in force on it, so it continues the count it stands in, and it is not counted toward the pages after it, so the element's page bears the value. A blank page inside the scope, after the element began, counts as every page does.
+ *
+ * @param pages - each page before `pageIndex`, by index: its first word position and whether it is blank.
+ * @param blank - whether page `pageIndex` is one the engine made blank.
+ * @param away - the remainders the page's opening cut carries in, as for {@link counterStateAt}.
+ */
+export declare function pageNumberAt(ops: ReadonlyArray<Op>, pageIndex: number, pos: number, { pages, blank, away }: {
+    pages: (i: number) => {
+        start: number;
+        blank: boolean;
+    };
+    blank?: boolean;
+    away?: ReadonlyArray<{
+        from: number;
+        to: number;
+    }>;
+}): number;
+/** The author's counters alone: the page's own two, `page` and `pages`, are the host's (`pageNumberAt`), and delivered as an author's they would reset the flow and the cells under the host's. */
+export declare function withoutPageCounters(state: Record<string, number[]>): Record<string, number[]>;
 /**
  * Every named-string assignment the document makes, in document order.
  *

package/dist/src/document-state.js

@@ -289,6 +289,53 @@ const runningOp = (r, at) => ({ reset: [], increment: [], set: [], strings: null
 export function counterStateAt(ops, pos, away = []) {
     return replay(ops, { until: pos, away });
 }
+/**
+ * The page number of page `pageIndex`, which begins at `pos`: the run's own count, or, where an element reset the page counter, that element's value counted on from the page it begins on.
+ *
+ * @remarks
+ * css-page-3 names a reset of the page counter only in the page context, but an author writes `counter-reset: page 1` on a chapter or on each letter of a print run to number its pages from one, and once the engine applies it the pages after must count on from there rather than stay at the value (Codeberg issue 1). The page counter is the page's own, reset on the host as `page N` (`chase.js`'s `setCounters`), so the reset is folded into N here and never delivered as an author counter: delivered, it reset the flow and the margin cells to the same value on every later page in the reset's scope. `target-counter()` to a page reads the same N (`reads.js`'s `pageValues`), so a reference answers the value the counter has at its target (Codeberg issue 2).
+ *
+ * The last `counter-reset` or `counter-set` of `page` at or before `pos` is the one in force: **at**, not strictly before, because the element that begins on the page is the one that numbers it, where an author counter's reset waits for the next page (css-page-3 §6.1 is about author counters). Scope is not replayed, since the page counter has one instance: a reset stands until the next one, whatever the depth of either. A reset on an element that begins mid-page numbers the next page.
+ *
+ * **A blank page the engine makes to bring the element to its side begins where the element does and stands before it** (Codeberg issue 13): the reset is not in force on it, so it continues the count it stands in, and it is not counted toward the pages after it, so the element's page bears the value. A blank page inside the scope, after the element began, counts as every page does.
+ *
+ * @param pages - each page before `pageIndex`, by index: its first word position and whether it is blank.
+ * @param blank - whether page `pageIndex` is one the engine made blank.
+ * @param away - the remainders the page's opening cut carries in, as for {@link counterStateAt}.
+ */
+export function pageNumberAt(ops, pageIndex, pos, { pages, blank = false, away = [] }) {
+    const inForce = (at, start, isBlank) => at < start || (at === start && !isBlank);
+    let reset = null;
+    for (const op of ops) {
+        if (op.pos > pos)
+            break;
+        if (!inForce(op.pos, pos, blank))
+            continue;
+        if (away.length && inRemainders(away, op.pos))
+            continue;
+        for (const [name, value] of [...op.reset, ...op.set])
+            if (name === 'page')
+                reset = { pos: op.pos, value };
+    }
+    if (!reset)
+        return pageIndex + 1;
+    let since = 0;
+    for (let i = 0; i < pageIndex; i++) {
+        const page = pages(i);
+        if (inForce(reset.pos, page.start, page.blank))
+            since++;
+    }
+    return reset.value + since;
+}
+/** The author's counters alone: the page's own two, `page` and `pages`, are the host's (`pageNumberAt`), and delivered as an author's they would reset the flow and the cells under the host's. */
+export function withoutPageCounters(state) {
+    if (!('page' in state) && !('pages' in state))
+        return state;
+    const out = { ...state };
+    delete out.page;
+    delete out.pages;
+    return out;
+}
 /** One replay, two readers. `counterStateAt` stops at a position and returns the state there; `stringAssignmentsOf` runs the log out and is handed the state at each element that assigns a named string. Written once because the scope arithmetic is the delicate part and two copies of it would agree only until one of them was fixed. */
 function replay(ops, { until = Infinity, onOp = null, away = [] } = {}) {
     /**

package/dist/src/driver.d.ts

@@ -47,6 +47,8 @@ export type ForcingEvent = {
     sealedBy: number;
     /** It stands inside a box that lays its children side by side. */
     rowish: boolean;
+    /** For a run of lines after a block child, the event is the run's first word in `el`, which holds it, and this is the block child it follows; the feed is cut after it (*the anonymous box is in the procession*). */
+    runAfter?: Element;
 };
 /** One block of a page's feed: its clone, the source it was cloned from, and the address it resumes at. */
 export type FeedItem = {
@@ -111,7 +113,7 @@ export declare function pageNameDownFrom(el: Element, { styleOf, runBefore, bloc
     blockChildren?: typeof blockChildrenOf;
 }): string;
 /**
- * Read the document's @page geometry from the CSSOM — every sheet the document wears, adopted ones included (`capture.js`'s `styleSheetsOf`; the capture reads adopted sheets). Returns page and content box sizes in px.
+ * 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.
  *
  * **Margins only, and that is now a stated limit rather than the whole story** *(a page box has a border and a padding, 2026-09-07)*. The capture models a page's `border` and `padding` and subtracts both from the page area; this reader does not, so a document declaring either gets a content box too large here. Its one caller is `packages/essay`'s benchmark, over a corpus that writes `size` and margins into its page rules and nothing else — so the difference is unreachable there. It is not widened rather than left quietly wrong: this is the legacy single-geometry reader, and a second implementation of the page area is exactly what `readGeometryTable` exists to be the only one of.
  */
@@ -198,14 +200,18 @@ export declare const combineParity: (earlier: 'left' | 'right' | null, later: 'l
  *
  * @param blocks - the top-level blocks, in document order.
  */
-export declare function forcingIndexOf(blocks: Element[], { styleOf, pageNameOf, cutOf, posOf, posOfCut, isMonolith: monolith, blockChildren }: {
+export declare function forcingIndexOf(blocks: Element[], { styleOf, pageNameOf, cutOf, posOf, posOfCut, isMonolith: monolith, blockChildren, extentOf }: {
     styleOf: (el: Element) => CSSStyleDeclaration;
     pageNameOf: (el: Element) => string;
-    cutOf: (el: Element, b: number) => Address;
+    cutOf: (el: Element, b: number, word?: number | null) => Address;
     posOf: (el: Element, b: number) => number;
     posOfCut?: ((cut: Address) => number) | null;
     isMonolith?: typeof isMonolith;
     blockChildren?: typeof blockChildrenOf;
+    extentOf?: ((el: Element) => {
+        before: number;
+        count: number;
+    }) | null;
 }): {
     size: number;
     /** The first forcing event strictly after `cursorCut` for a page named `name`, or null. */
@@ -226,6 +232,7 @@ export declare function forcingIndexOf(blocks: Element[], { styleOf, pageNameOf,
         };
         parity: "left" | "right" | null;
         rowish: boolean;
+        runAfter: Element | undefined;
     } | 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.

package/dist/src/driver.js

@@ -15,18 +15,18 @@
  */
 import { Ledger, createEntry } from './ledger.js';
 import { assertRenderConditions, awaitCloneImages, awaitFonts, awaitImages, createMeasureContext } from './measure.js';
-import { takeReport } from './gauge.js';
+import { holdsAnonymousBlocks, takeReport } from './gauge.js';
 import { adjudicate, adjudicateFlow, firstBelowTheEdge, isAbsolutelyPositioned, isOutOfFlow, isMonolith, neverCutInside, reachesBelowTheEdge, processionBottoms, fitsPage } from './stonehand.js';
 import { composeDocument, applyRecordsUnder } from './compose-dom.js';
 import { CompositionCache } from './composition-key.js';
-import { readGeometryTable, effectivePageName, styleSheetsOf, registerGcpmProperties, sheetsUseHas, sheetReach } from './capture.js';
+import { readGeometryTable, effectivePageName, pageRulesOf, styleSheetsOf, registerGcpmProperties, sheetsUseHas, sheetReach } from './capture.js';
 import { snapshotOfStyle } from './forcing-memo.js';
 import { cloneFlowPiece, declineRepeats, mayRepeat, mutateToContinuation, truncateFrom } from './fragments.js';
 import { cutAfter, divides, elAtIn, flattenResume, indexBlocks, inFlowIndex, inRemainders, normalizePath, pathOf, placeAt, remaindersOf } from './positions.js';
-import { documentOpsOf, counterStateAt, stringAssignmentsOf, runningAssignmentsOf, namedStringsForPage } from './document-state.js';
+import { documentOpsOf, counterStateAt, pageNumberAt, withoutPageCounters, stringAssignmentsOf, runningAssignmentsOf, namedStringsForPage } from './document-state.js';
 import { RUNNING_PROP } from './gcpm-encoding.js';
 import { ARTIFACT, hasWord } from './data-beltype.js';
-import { blockChildrenOf, footerBeforeRows, isFixedBox, SIDE_BY_SIDE, sourceOf } from './word-space.js';
+import { blockChildrenOf, footerBeforeRows, headerAfterRows, isFixedBox, SIDE_BY_SIDE, sourceOf } from './word-space.js';
 import { changedPairs, settleReads } from './reads.js';
 import { converge, holderPage, namesNoPlace, priorKeys, restartPage } from './resume.js';
 import { answerHas, boxesWhoseWordsMoved } from './has-words.js';
@@ -37,6 +37,21 @@ function toPx(len) {
         throw new Error(`unsupported page length: ${len}`);
     return parseFloat(m[1]) * PX_PER[m[2]];
 }
+/**
+ * The message a table shape refuses with (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): the table, by its id or class or its first words, and the shape. Both shapes lost rows with no message, and a refusal by name is the detector until the address can say where §17.2 lays the group out.
+ *
+ * @remarks The two shapes, both groups whose words and box disagree in order. A header group written after the rows is laid out above them (CSS 2.1 §17.2) while its words stand after them in the word space: one that repeats is walked first and shown by its copy on every page before its words, and one too tall to repeat, in a divided table, is refused, because which page shows it is the open ruling on §17.2's display order in the word space. A footer group written before the rows is walked where it is laid out, last and whole, and one taller than the page area could be placed nowhere, so the table ended on its first page.
+ *
+ * @param group - the source `thead` or `tfoot`.
+ * @param shape - the shape, in words.
+ * @param remedy - what the author can write instead.
+ */
+function refusedTable(group, shape, remedy = 'write the groups in HTML\'s order: thead, tbody, tfoot') {
+    const table = group.closest('table');
+    const words = (table?.textContent ?? '').trim().replace(/\s+/g, ' ').slice(0, 40);
+    const name = table?.id ? `<table id="${table.id}">` : table?.className ? `<table class="${table.className}">` : `the table beginning "${words}"`;
+    return `cicero: ${name} has ${shape}, which this engine cannot divide across pages yet; it refuses rather than lose rows. To print it, ${remedy}.`;
+}
 /** The nearest copy the engine repeats (`artifact`) standing ahead of this element among its siblings — the table's header, in front of its rows — or null. */
 const artifactBefore = (el) => {
     for (let s = el?.previousElementSibling; s; s = s.previousElementSibling)
@@ -44,6 +59,13 @@ const artifactBefore = (el) => {
             return s;
     return null;
 };
+/** The header group written after this element among its siblings, which §17.2 lays out ahead of it all the same (`headerAfterRows`), or null. It is a copy on the pages before its words and the original in a feed, which pours it whole, and it stands ahead of the rows either way. */
+const headerCopyAfter = (el) => {
+    for (let s = el?.nextElementSibling; s; s = s.nextElementSibling)
+        if (headerAfterRows(s))
+            return s;
+    return null;
+};
 /** Does a copy the engine repeats (`artifact`) stand ahead of this element among its siblings — the table's header, in front of its rows? */
 export const standsAfterArtifact = (el) => artifactBefore(el) !== null;
 /**
@@ -60,9 +82,10 @@ export function gapAbove(box, report, win) {
     for (let child = box, a = box.parent; a; child = a, a = a.parent) {
         const cs = win.getComputedStyle(a.el);
         // A copy the engine repeats ahead of the child (the table's header) is furniture with a footprint, not a spent lead (*the header repeats*): the level owes only what stands above the copy, which under separated borders is the table's `border-spacing` above its first row, and Chromium draws none above a repeated header (*a repeated header joins the rows as Chromium prints them*, 2026-10-22). Under collapsed borders the copy's top is the table's own and nothing is owed.
-        if (standsAfterArtifact(child.el)) {
-            // The header's copy, never a footer's: a footer written before its rows stands among the siblings too, and is laid out at the foot (*the footer before the rows*).
-            let copy = cs.borderCollapse === 'separate' ? artifactBefore(child.el) : null;
+        const late = headerCopyAfter(child.el);
+        if (late || standsAfterArtifact(child.el)) {
+            // The header's copy, never a footer's: a footer written before its rows stands among the siblings too, and is laid out at the foot (*the footer before the rows*). A header written after its rows is laid out ahead of them, and its copy is the one.
+            let copy = cs.borderCollapse === 'separate' ? late ?? artifactBefore(child.el) : null;
             while (copy && !/^THEAD$/i.test(copy.tagName))
                 copy = artifactBefore(copy);
             const box = copy ? report.boxOf(copy) : null;
@@ -93,28 +116,25 @@ export function pageNameDownFrom(el, { styleOf, runBefore, blockChildren = block
     return effectivePageName(el);
 }
 /**
- * Read the document's @page geometry from the CSSOM — every sheet the document wears, adopted ones included (`capture.js`'s `styleSheetsOf`; the capture reads adopted sheets). Returns page and content box sizes in px.
+ * 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.
  *
  * **Margins only, and that is now a stated limit rather than the whole story** *(a page box has a border and a padding, 2026-09-07)*. The capture models a page's `border` and `padding` and subtracts both from the page area; this reader does not, so a document declaring either gets a content box too large here. Its one caller is `packages/essay`'s benchmark, over a corpus that writes `size` and margins into its page rules and nothing else — so the difference is unreachable there. It is not widened rather than left quietly wrong: this is the legacy single-geometry reader, and a second implementation of the page area is exactly what `readGeometryTable` exists to be the only one of.
  */
 export function readPageGeometry(doc) {
-    for (const sheet of styleSheetsOf(doc)) {
-        for (const rule of sheet.cssRules) {
-            if (!(rule instanceof doc.defaultView.CSSPageRule))
-                continue;
-            const text = rule.cssText;
-            const size = /size:\s*([^;}]+)/.exec(text)?.[1].trim().split(/\s+/) ?? [];
-            const marginRaw = /(?:^|[\s{;])margin:\s*([^;}]+)/.exec(text)?.[1].trim().split(/\s+/) ??
-                ['top', 'right', 'bottom', 'left'].map((side) => new RegExp(`margin-${side}:\\s*([^;}]+)`).exec(text)?.[1].trim() ?? '0px');
-            if (size.length === 0)
-                throw new Error('@page without an explicit size — the corpus always pins geometry (I5)');
-            const [w, h] = size.length === 1 ? [size[0], size[0]] : size;
-            const [mt, mr = mt, mb = mt, ml = mr] = marginRaw;
-            const pageW = toPx(w);
-            const pageH = toPx(h);
-            const margins = { top: toPx(mt), right: toPx(mr), bottom: toPx(mb), left: toPx(ml) };
-            return { pageW, pageH, margins, contentW: pageW - margins.left - margins.right, contentH: pageH - margins.top - margins.bottom };
-        }
+    const { layered, unlayered } = pageRulesOf(doc);
+    for (const rule of [...unlayered, ...layered]) {
+        const text = rule.cssText;
+        const size = /size:\s*([^;}]+)/.exec(text)?.[1].trim().split(/\s+/) ?? [];
+        const marginRaw = /(?:^|[\s{;])margin:\s*([^;}]+)/.exec(text)?.[1].trim().split(/\s+/) ??
+            ['top', 'right', 'bottom', 'left'].map((side) => new RegExp(`margin-${side}:\\s*([^;}]+)`).exec(text)?.[1].trim() ?? '0px');
+        if (size.length === 0)
+            throw new Error('@page without an explicit size — the corpus always pins geometry (I5)');
+        const [w, h] = size.length === 1 ? [size[0], size[0]] : size;
+        const [mt, mr = mt, mb = mt, ml = mr] = marginRaw;
+        const pageW = toPx(w);
+        const pageH = toPx(h);
+        const margins = { top: toPx(mt), right: toPx(mr), bottom: toPx(mb), left: toPx(ml) };
+        return { pageW, pageH, margins, contentW: pageW - margins.left - margins.right, contentH: pageH - margins.top - margins.bottom };
     }
     throw new Error('no @page rule found');
 }
@@ -218,7 +238,7 @@ export const combineParity = (earlier, later) => later ?? earlier;
  *
  * @param blocks - the top-level blocks, in document order.
  */
-export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posOfCut = null, isMonolith: monolith = isMonolith, blockChildren = blockChildrenOf }) {
+export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posOfCut = null, isMonolith: monolith = isMonolith, blockChildren = blockChildrenOf, extentOf = null }) {
     const events = [];
     const blockStart = [];
     /**
@@ -233,9 +253,25 @@ export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posO
         const k = events.length;
         events.push(e);
         const inner = sealedBy >= 0 ? sealedBy : neverCutInside(el, st) ? k : -1;
-        if (!parallel && !monolith(el, st))
-            for (const child of blockChildren(el))
-                visit(child, b, inner, rowish || SIDE_BY_SIDE.has(st.display ?? ''));
+        if (!parallel && !monolith(el, st)) {
+            const kids = blockChildren(el);
+            const runs = !!extentOf && holdsAnonymousBlocks(st.display ?? '');
+            const row = rowish || SIDE_BY_SIDE.has(st.display ?? '');
+            for (let i = 0; i < kids.length; i++) {
+                visit(kids[i], b, inner, row);
+                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 word = done.before + done.count;
+                const next = kids[i + 1];
+                if ((next ? ext(next).before : own.before + own.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] });
+            }
+        }
         e.after = !parallel && isForced(st.breakAfter); // a float's own break-after was never read, and still is not
         e.afterParity = parityOf(st.breakAfter);
         e.end = events.length;
@@ -262,7 +298,7 @@ export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posO
         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 };
+        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 };
     };
     /** 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) => {
@@ -318,6 +354,8 @@ export function forcingIndexOf(blocks, { styleOf, pageNameOf, cutOf, posOf, posO
                     k = events[e.sealedBy].end;
                 else if (!e.inFlow)
                     k = e.end;
+                else if (e.runAfter)
+                    k++; // a run's place is the grab's alone: the Cast-off cuts at a box, and moving forward only grows the feed
                 else
                     return { b: e.b, el: e.el, cut: { ...e.cut, path: [...e.cut.path] } };
             }
@@ -622,16 +660,18 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
     /** The grab's events, indexed here, once (*the page asks the index*, 2026-09-25) — beside the document's own counters and for the same reason: the source is never written (*the source document is never written*, C5), so what the grab reads about a box is the same on every page, and the walk that asked it of the tree on every page cost the BGD manual 66 ms a page whatever the cursor. `forcingIndexOf` above carries the question and its rules; the page asks `forcing.find`. */
     // The memo, if the seam offered one and the sheets leave it standing (*the forced-break index is kept across runs*, 2026-10-09; settled once for the call by `settledMemo`): the reads below are answered from it where an element was read before, and read from the browser and kept where not.
     memo?.restart();
+    const extentOf = (el) => ({ before: index.wordsBefore(el), count: index.wordCountIn(el) });
     const forcing = memo
         ? forcingIndexOf(blocks, {
             styleOf: (el) => memo.facts(el, () => snapshotOfStyle(win.getComputedStyle(el))),
             pageNameOf: (el) => memo.pageName(el, () => effectivePageName(el)),
             blockChildren: (el) => memo.blockChildren(el, () => blockChildrenOf(el)),
-            cutOf: (el, b) => cutTo(el, b, { rawPath: pathOf(el, blocks[b], b, isFixedBox, (e) => memo.indexIn(e, () => inFlowIndex(e))) }),
+            cutOf: (el, b, word = null) => cutTo(el, b, { word, rawPath: pathOf(el, blocks[b], b, isFixedBox, (e) => memo.indexIn(e, () => inFlowIndex(e))) }),
             posOf: (el, b) => index.posOf(b, index.wordsBefore(el)),
-            posOfCut
+            posOfCut,
+            extentOf
         })
-        : forcingIndexOf(blocks, { styleOf: (el) => win.getComputedStyle(el), pageNameOf: effectivePageName, cutOf: (el, b) => cutTo(el, b), posOf: (el, b) => index.posOf(b, index.wordsBefore(el)), posOfCut });
+        : 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.
@@ -720,10 +760,18 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
      * @param who - the caller, for the error.
      */
     const cutCloneAt = (clone, cloneOfSource, place, who) => {
-        const target = cloneOfSource.get(place.el);
+        const target = cloneOfSource.get(place.runAfter ?? place.el);
         if (!target || !clone.contains(target))
             throw new Error(`${who} could not address its own place in block ${place.b} — a defect to file, not a bail to hide`);
-        truncateFrom(clone, target, { hollow });
+        if (!place.runAfter)
+            return void truncateFrom(clone, target, { hollow });
+        // A run has no element: the feed is cut at the first node after the block child it follows, which stands in the run, so the child stays whole and the run leaves with everything after it.
+        let at = target;
+        while (!at.nextSibling && at.parentNode && at !== clone)
+            at = at.parentNode;
+        if (!at.nextSibling)
+            throw new Error(`${who} found no run after its block child in block ${place.b}: a defect to file, not a bail to hide`);
+        truncateFrom(clone, at.nextSibling, { hollow });
     };
     const ledger = new Ledger();
     // The cursor is the document's own first address — the path to block zero, which divides nothing — plus its projection and whatever flows are still running beside it.
@@ -735,11 +783,13 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
     /** 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);
-        const pageNumber = pageIndex + 1;
+        const away = remaindersOf(carried, index.endOf);
+        // The run's count, or an author's reset of the page counter counted on from the page it begins on (`document-state.js`'s `pageNumberAt`). Entry `i` closes page `i`, so page `i` begins where entry `i - 1` ended.
+        const pageNumber = pageNumberAt(documentOps, pageIndex, pos, { pages: (i) => ({ start: i === 0 ? 0 : account[i - 1].pos ?? 0, blank: account[i].blank === true }), blank, away });
         const parity = parityAt(pageIndex);
         const geo = table.pageFor({ name, first: pageIndex === 0, parity, blank });
-        // 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).
-        const counters = counterStateAt(documentOps, pos, remaindersOf(carried, index.endOf));
+        // 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));
         return Object.freeze({ ...geo, name, pageNumber, parity, blank, counters, dpr: win.devicePixelRatio });
     };
     /**
@@ -778,7 +828,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
             const source = blocks[b];
             const cut = b === first ? cursor.cut : null;
             const ends = !!place && b === place.b;
-            if (ends && place.cut.path.length === 1)
+            if (ends && place.cut.path.length === 1 && place.cut.word == null)
                 break; // the place is this block's own start: the whole block leaves, exactly as the item-granular grab always cut
             const { clone } = cloneFlowPiece(source, { start: divides(cut) ? cut : null, end: ends ? place.cut : null, items: itemsIn(b), hollow, into: cloneOfSource }); // no composition: the tail is cut first, then the hints
             if (ends)
@@ -1013,6 +1063,8 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
             if (!mayRepeat(src))
                 continue;
             decided.add(src);
+            if (footerBeforeRows(src) && g.getBoundingClientRect().height > conditions.contentH)
+                throw new Error(refusedTable(src, 'a footer group taller than the page area, written before its rows', 'write the footer after the rows, where it is divided like them, or keep it within the page area'));
             const repeat = g.getBoundingClientRect().height <= conditions.contentH / 4;
             const b = blocks.findIndex((block) => block === src || block.contains(src));
             madeHere.push({ path: pathOf(src, blocks[b], b), repeat });
@@ -1416,6 +1468,13 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
         if (!fits && hasGroups) {
             const ct = container.getBoundingClientRect().top;
             const edge = pageStart + conditions.contentH;
+            // A header written after its rows that does not repeat, in a table the page's edge divides, is refused (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): its words are on the table's last fragment and its box above the first, and which page shows it is the open ruling on §17.2's display order in the word space. Undivided, the one fragment holds both.
+            for (const h of container.querySelectorAll('thead')) {
+                const src = sourceOf(h);
+                const r = h.closest('table')?.getBoundingClientRect();
+                if (src && r && declined.has(src) && headerAfterRows(src) && r.top - ct < edge && r.bottom - ct > edge)
+                    throw new Error(refusedTable(src, 'a header group written after its rows, too tall to repeat'));
+            }
             for (const f of container.querySelectorAll('tfoot')) {
                 const src = sourceOf(f);
                 // A footer written before its rows that does not repeat is still reserved where it is shown: its words stand before the rows, so it is on the table's first fragment and nowhere after (*the footer before the rows*, 2026-10-15; Chromium shows it on the last, which the address cannot say).

package/dist/src/fragmentation.d.ts

@@ -20,5 +20,5 @@ export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureCont
 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 { adjudicate, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.ts';
+export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.ts';
 export { BREAKING_SPACE, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.ts';

package/dist/src/fragmentation.js

@@ -19,5 +19,5 @@ export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureCont
 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 { adjudicate, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.js';
+export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.js';
 export { BREAKING_SPACE, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.js';

package/dist/src/fragments.d.ts

@@ -96,10 +96,10 @@ export declare function mayRepeat(src: Element): boolean;
  * **`keep` is the first fragment's door into the same surgery** (*the first fragment is constructed*, 2026-09-15). A shell continues a box whose own content closed on the page before, so page one wants everything after that box gone and the box itself standing — the one difference from the grab's reading, where the boundary box is what resumes. With `keep`, the boundary element stays and is dressed as a fragment that ends there, which it is.
  *
  * @param clone - the top-level block's clone, already hinted and already consumed to the cursor.
- * @param el - the boundary element, addressed in the clone's own coordinates.
+ * @param el - the boundary node, addressed in the clone's own coordinates: an element, or the first node of a run of lines, which has no element (*the anonymous box is in the procession*).
  * @param opts - `keep`: the boundary element stays in the fragment (and is dressed), rather than leaving with its successors. `hollow`: what leaves is kept hollow (`putAway`).
  */
-export declare function truncateFrom(clone: Element, el: Element, { keep, hollow }?: {
+export declare function truncateFrom(clone: Element, el: ChildNode, { keep, hollow }?: {
     keep?: boolean;
     hollow?: boolean;
 }): Element;

package/dist/src/fragments.js

@@ -317,7 +317,7 @@ function liftRepeatedHeader(group) {
  * **`keep` is the first fragment's door into the same surgery** (*the first fragment is constructed*, 2026-09-15). A shell continues a box whose own content closed on the page before, so page one wants everything after that box gone and the box itself standing — the one difference from the grab's reading, where the boundary box is what resumes. With `keep`, the boundary element stays and is dressed as a fragment that ends there, which it is.
  *
  * @param clone - the top-level block's clone, already hinted and already consumed to the cursor.
- * @param el - the boundary element, addressed in the clone's own coordinates.
+ * @param el - the boundary node, addressed in the clone's own coordinates: an element, or the first node of a run of lines, which has no element (*the anonymous box is in the procession*).
  * @param opts - `keep`: the boundary element stays in the fragment (and is dressed), rather than leaving with its successors. `hollow`: what leaves is kept hollow (`putAway`).
  */
 export function truncateFrom(clone, el, { keep = false, hollow = false } = {}) {
@@ -377,22 +377,59 @@ function charRanges(word, from, to) {
     }
     return out;
 }
+/** Whether the whitespace of a text node stands in its layout (css-text-4 §4.1): where it collapses it is nothing at a line's edge, and where it is preserved each newline draws a line. */
+const preservesSpace = (t) => !!t.parentElement && /^(pre|pre-wrap|pre-line|break-spaces)$/.test(sourceStyle(t.parentElement)?.whiteSpace ?? '');
+/** Take a stretch of a cut's whitespace out of the fragment: leave it where it collapses, so layout reads the data exactly as before, and remove it where it is preserved, or a continuation opens on the empty lines of every line cut away. Either way the record says it is not shown. */
+function dropSpace(t, from, to) {
+    if (to <= from)
+        return;
+    if (preservesSpace(t))
+        cutRanges(t, [{ start: from, end: to }]);
+    else
+        leaveOut(t, from, to);
+}
 /**
- * Say that everything before the resume point is held and not shown (*the engine names the source point*, 2026-10-13). Consuming blanks the words and leaves the whitespace between them, so a continuation's data still begins with the spaces of every word cut away; those are the source's characters and no part of the interval, and so are the whitespace before the first kept word and every text node that stands wholly before it. Records only: layout reads the data exactly as before.
+ * The indentation of the line a resume word opens: the whitespace before it back to a newline, in characters. Read before the words before it go, because only they tell the space that opens a line from the space that followed a word. A cut at a soft wrap has no newline in that gap and no indentation, the space hanging at the end of the line before; a line after a `<br>` looks the same and loses its indentation at the top of a page.
+ */
+function indentationBefore(clone, node, start) {
+    let text = '';
+    for (const t of textsIn(clone)) {
+        if (t === node) {
+            text += t.data.slice(0, start);
+            break;
+        }
+        text += t.data;
+    }
+    let i = text.length;
+    while (i > 0 && BREAKING_SPACE.test(text[i - 1]))
+        i--;
+    const newline = text.lastIndexOf('\n');
+    return newline < i ? 0 : text.length - newline - 1;
+}
+/**
+ * Say that everything before the resume point is held and not shown (*the engine names the source point*, 2026-10-13). Consuming blanks the words and leaves the whitespace between them, so a continuation's data still begins with the spaces of every word cut away; those are the source's characters and no part of the interval, and so are the whitespace before the first kept word and every text node that stands wholly before it. Where the whitespace collapses these are records only, and where it is preserved they leave the data (`dropSpace`), all but the indentation of the line the page opens on.
  *
  * @param resume - the node holding the first kept character, or null when nothing is kept.
+ * @param indent - the characters immediately before it to keep, from {@link indentationBefore}.
  */
-function leaveOutBefore(clone, resume) {
+function leaveOutBefore(clone, resume, indent) {
+    const lead = [];
     for (const t of textsIn(clone)) {
         if (t === resume)
             break;
-        leaveOut(t, 0, t.data.length);
+        lead.push({ node: t, end: t.data.length });
     }
     if (resume) {
         let at = 0;
         while (at < resume.data.length && BREAKING_SPACE.test(resume.data[at]))
             at++;
-        leaveOut(resume, 0, at);
+        lead.push({ node: resume, end: at });
+    }
+    let left = indent;
+    for (const { node, end } of lead.reverse()) {
+        const kept = preservesSpace(node) ? Math.min(left, end) : 0;
+        left -= kept;
+        dropSpace(node, 0, end - kept);
     }
 }
 /** The mirror: everything after the last kept character is held and not shown.@param keep - the node holding the last kept character. */
@@ -400,14 +437,14 @@ function leaveOutAfter(clone, keep) {
     let end = keep.data.length;
     while (end > 0 && BREAKING_SPACE.test(keep.data[end - 1]))
         end--;
-    leaveOut(keep, end, keep.data.length);
     let after = false;
-    for (const t of textsIn(clone)) {
+    for (const t of [...textsIn(clone)]) {
         if (after)
-            leaveOut(t, 0, t.data.length);
+            dropSpace(t, 0, t.data.length);
         else if (t === keep)
             after = true;
     }
+    dropSpace(keep, end, keep.data.length);
 }
 /** The text nodes under an element, in document order — by `childNodes`, as `joinedWords` reads, so the DOM-free suites' trees serve. */
 function* textsIn(el) {
@@ -426,7 +463,9 @@ function consumeLeadingWords(clone, n, char = 0, hollow = false) {
     // A resume inside word n (*a line inside a word is a break point*, 2026-09-23): its first `char` characters were shown on the page before, and go with the words before it. The page resumes at the part holding the first character left.
     const inside = char > 0 && n < words.length ? charRanges(words[n], 0, char) : [];
     const resumeWord = words[Math.min(n, words.length - 1)];
-    const resumeNode = n < words.length ? (partAt(resumeWord, char) ?? resumeWord.parts[0]).node : null;
+    const resumePart = n < words.length ? partAt(resumeWord, char) ?? resumeWord.parts[0] : null;
+    const resumeNode = resumePart?.node ?? null;
+    const indent = resumePart && char === 0 ? indentationBefore(clone, resumePart.node, resumePart.start) : 0;
     // Blank the consumed words' exact character ranges, one pass a node (`word-space.js`' `cutRanges`, which records what went).
     const perNode = new Map();
     for (const part of [...words.slice(0, n).flatMap((w) => w.parts), ...inside]) {
@@ -436,7 +475,7 @@ function consumeLeadingWords(clone, n, char = 0, hollow = false) {
     }
     for (const [node, ranges] of perNode)
         cutRanges(node, ranges);
-    leaveOutBefore(clone, resumeNode);
+    leaveOutBefore(clone, resumeNode, indent);
     // Structural pass: an element with no remaining words, standing entirely before the resume point, is spent — its edges adjoin the cut (§5.2) and it leaves the fragment.
     const spent = [];
     (function walk(el) {

package/dist/src/gauge.d.ts

@@ -45,6 +45,8 @@ export type Box = {
     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 = {
@@ -95,6 +97,8 @@ export type Tracks = {
 };
 /** The sealed report {@link takeReport} hands back. */
 export type MeasureReport = ReturnType<typeof takeReport>;
+/** A `display` whose inline content CSS 2.1 §9.2.1.1 wraps in anonymous block boxes — a block container's. A flex or grid container makes a run an anonymous item and a table an anonymous cell, which are other boxes and other questions. */
+export declare const holdsAnonymousBlocks: (display: string) => boolean;
 /**
  * Read one settled layout into an immutable snapshot — obtaining it seals the mutation phase (*render-identical conditions*, I5, by type).
  *

package/dist/src/gauge.js

@@ -15,7 +15,7 @@
  * @packageDocumentation
  */
 import { BREAK, selectorOf } from './data-beltype.js';
-import { blockChildrenOf, footerBeforeRows, isAtom, isEngineText, isInlineBox, isLineBreak, mayBeAutoHyphenated, rangeOf, READS_ITS_CHILDREN, rowsAmong, SIDE_BY_SIDE, wordRuns } from './word-space.js';
+import { blockChildrenOf, footerBeforeRows, headerAfterRows, 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)}`;
 /**
@@ -28,7 +28,7 @@ const sharesLine = (aTop, aBottom, bTop, bBottom) => Math.min(aBottom, bBottom)
 /** A character a word is made of: anything `BREAKING_SPACE` does not divide at. */
 const WORD_CHAR = /[\S  ]/;
 /** A `display` whose inline content CSS 2.1 §9.2.1.1 wraps in anonymous block boxes — a block container's. A flex or grid container makes a run an anonymous item and a table an anonymous cell, which are other boxes and other questions. */
-const holdsAnonymousBlocks = (display) => !/flex|grid|-webkit-box/.test(display) && (!/table/.test(display) || /^table-(cell|caption)$/.test(display));
+export const holdsAnonymousBlocks = (display) => !/flex|grid|-webkit-box/.test(display) && (!/table/.test(display) || /^table-(cell|caption)$/.test(display));
 const GAP_MIN = 0.75; // px — a third rect-reading rule, learned from the differential: half-leading float arithmetic leaves sub-pixel residue between a text box's last line and its border, and reporting that residue as a gap fabricates Class C cuts that bypass keeps. Real gaps (padding, margins, constrained heights) are ≥ 1px; noise stays under half a pixel.
 /**
  * Read one settled layout into an immutable snapshot — obtaining it seals the mutation phase (*render-identical conditions*, I5, by type).
@@ -91,6 +91,18 @@ export function takeReport(container, { contentHeight }) {
             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;
+        }
     }
     /**
      * The anonymous boxes (*the anonymous box is in the procession*, 2026-09-29; CSS 2.1 §9.2.1.1). A block container holding a block-level box beside inline content wraps each maximal run of that content in an anonymous block box, and css-break-3 §4.1 divides the result like any procession: a Class A point between the run and the block beside it, Class B points between its lines, and no Class C point where it stands, since a line is child content. The procession used to be the element tree's block children alone, so a run had no box: its lines were read as nothing but the distance they opened, a start gap before the first block child and an end gap after the last, and a page edge crossing thirteen trailing lines shelled them blank (`packages/essay/cases/76-the-line-before-the-first-block`).