@beltype/cicero 0.1.6 → 0.1.8

package/dist/src/document-state.js

@@ -13,7 +13,7 @@
  *
  * **A position is the flat word index** (`positions.js`), and an operation applies when its position is strictly before the one asked about — and not inside a remainder a carried flow has still to show, which stands before the page's first word in document order and is on that page or after it (beltype#43; `positions.js`' `remaindersOf`). That is §6.1's *"the deepest element in the normal flow that spans the page break"* said in this engine's own space: an element whose first word is the page's first word begins on the new page and does not span the break, so its own operation is not yet in force, while an element that spans the break started before that word and is included. The ancestors above the top-level blocks sit at position **−1** — they open before the document's first word and span every break there is — which is what makes the first page's answer fall out of the same comparison rather than needing a case of its own.
  *
- * **What is not read, each a real gap and each showing as a counter reading low.** A counter operation on a `::before` or `::after`; a list item's implicit increment; css-lists-3's `reversed()` counters; and a top-level `position: fixed` box, which is not among the flow blocks the position index is built over. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
+ * **What is not read, each a real gap and each showing as a counter reading low.** A list item's implicit increment, so an `<ol>` that runs onto a second page numbers its items from 1 there (measured 2026-11-07, `<ol reversed>` and a `counter-set` of `list-item` likewise); css-lists-3's `reversed()` counters; and a top-level `position: fixed` box, which is not among the flow blocks the position index is built over. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
  *
  * @packageDocumentation
  */
@@ -21,7 +21,7 @@ import { STRING_SET_PROP, RUNNING_PROP } from './gcpm-encoding.js';
 import { format as formatCounter } from './counter-styles.js';
 import { inRemainders } from './positions.js';
 /** `counter-reset: a 2 b` → `[['a', 2], ['b', 0]]`. The computed value normalizes name/value pairs, but an absent number still defaults per property, so the default is a parameter. `none` and the empty string yield nothing. */
-function pairsOf(value, fallback) {
+export function pairsOf(value, fallback) {
     const out = [];
     const tokens = String(value ?? '').trim().split(/\s+/).filter(Boolean);
     if (!tokens.length || tokens[0] === 'none')
@@ -197,6 +197,11 @@ function opAt(el, pos, depth, { styleOf, textOf, attrOf, marks }) {
     const mark = marks?.has(el) ? el : null;
     return op || strings || mark ? { reset: [], increment: [], set: [], ...op, strings, pos, depth, ...(mark ? { mark } : {}) } : null;
 }
+/** A pseudo-element's counter operations, or `null` where it has none or is not generated: a `::before` or an `::after` whose `content` is `none` or `normal` is no box, and its computed `counter-increment` counts nothing (measured 2026-11-07: Chromium answers `fig 1` for it and the counter stays at 0). */
+function pseudoOpOf(el, pseudo, styleOf) {
+    const style = styleOf?.(el, pseudo);
+    return style && !/^(?:none|normal)?$/.test(String(style.content ?? '').trim()) ? opOf(style) : null;
+}
 /** One top-level block's part of the log: its operations in document order, each with its position and depth relative to the block — the words of the block before the element, and its depth below the block (*a resumed run keeps its reads*, 2026-10-22). {@link documentOpsOf} lays the parts end to end, a part's positions offset by its block's base and its depths by the ancestors above the blocks. */
 export function blockOpsOf(block, index, reads) {
     const ops = [];
@@ -207,11 +212,22 @@ export function blockOpsOf(block, index, reads) {
         // A `position: fixed` box has zero footprint at any depth (*a fixed box at any depth*, 2026-09-15), so it has no position in the word space this log is ordered by — `indexBlocks` skips it and so does this. A counter operation or a `string-set` inside such a box is therefore unread, which is exactly what was already true of a top-level fixed box and is recorded on the checklist beside it.
         if (style.position === 'fixed' || String(customOf(style, RUNNING_PROP)).trim())
             return;
-        const op = opAt(el, index.wordsBefore(el), depth, reads);
-        if (op)
+        const pos = index.wordsBefore(el);
+        const op = opAt(el, pos, depth, reads);
+        // A `::before` is the element's first child and an `::after` its last (CSS 2.1 §12.1), so their counter operations are logged one level down, the one at the element's first word and the other at its end. The element's named strings and its mark are evaluated after its `::before`: the number a heading or a figure prints there is the one its `string-set` and a `target-counter()` to it read.
+        const before = pseudoOpOf(el, '::before', reads.pseudoStyleOf);
+        if (before) {
+            if (op && (op.reset.length || op.increment.length || op.set.length))
+                ops.push({ ...op, strings: null, mark: undefined });
+            ops.push({ ...before, strings: op?.strings ?? null, pos, depth: depth + 1, ...(op?.mark ? { mark: op.mark } : {}) });
+        }
+        else if (op)
             ops.push(op);
         for (const child of el.children ?? [])
             walk(child, depth + 1);
+        const after = index.wordCountIn ? pseudoOpOf(el, '::after', reads.pseudoStyleOf) : null;
+        if (after)
+            ops.push({ ...after, strings: null, pos: pos + index.wordCountIn(el), depth: depth + 1 });
     };
     walk(block, 0);
     return ops;
@@ -222,6 +238,7 @@ export function blockOpsOf(block, index, reads) {
  * @param blocks - the top-level flow blocks, in order — `driver.js`'s `topLevelBlocks`.
  * @param index - the position index (`positions.js`), which holds every element inside every block.
  * @param opts.styleOf - the computed style of an element — injected, so a plain object tree exercises this without a browser.
+ * @param opts.pseudoStyleOf - the computed style of an element's `::before` or `::after`, whose counter operations are logged as the element's first and last child's; absent, a pseudo-element's counters are unread. The `::after` needs the index's `wordCountIn`.
  * @param opts.textOf - an element's text; absent, its `textContent`.
  * @param opts.attrOf - an element's attribute; absent, its `getAttribute`.
  * @param opts.ancestors - the elements above the blocks, outermost first (`html`, `body`). They open before the document's first word and are recorded at position −1.
@@ -229,8 +246,8 @@ export function blockOpsOf(block, index, reads) {
  * @param opts.running - the document's running elements in document order (`driver.js`' `runningBoxes`), each with the flat position the flow stood at where it was written (`driver.js`' `runningPosition`): each is logged as an assignment of its name there, carrying its place in this list as `running.at` (*a running element is a named node*, 2026-10-21). A running element is out of the flow at any depth, so the walk does not enter one, and its own counters and strings are unread, as a fixed box's are.
  * @param opts.keep - the memo's door (`forcing-memo.js`): each block's {@link blockOpsOf} part is asked of it, and a part kept from an earlier run is laid in place of a walk (*a resumed run keeps its reads*, 2026-10-22). A part read under marks is kept apart from one read without, and answers only while the marks that fall in its block are the ones it was read under (the position index says which block a mark is in). Absent, every block is walked.
  */
-export function documentOpsOf(blocks, index, { styleOf, textOf = (el) => el.textContent, attrOf = (el, name) => el.getAttribute(name), ancestors = [], marks = null, running = [], keep = null }) {
-    const reads = { styleOf, textOf, attrOf, marks };
+export function documentOpsOf(blocks, index, { styleOf, pseudoStyleOf = null, textOf = (el) => el.textContent, attrOf = (el, name) => el.getAttribute(name), ancestors = [], marks = null, running = [], keep = null }) {
+    const reads = { styleOf, textOf, attrOf, marks, pseudoStyleOf };
     const ops = [];
     ancestors.forEach((el, i) => {
         const op = opAt(el, -1, i, reads);
@@ -256,7 +273,7 @@ export function documentOpsOf(blocks, index, { styleOf, textOf = (el) => el.text
         const mine = marksIn?.get(b) ?? new Set();
         const read = () => ({ ops: blockOpsOf(blocks[b], index, reads), marks: mine });
         const part = keep
-            ? keep(marks ? 'ops:marked' : 'ops', blocks[b], read, marks ? (p) => p.marks.size === mine.size && [...mine].every((m) => p.marks.has(m)) : undefined)
+            ? keep(`${marks ? 'ops:marked' : 'ops'}${pseudoStyleOf ? ':pseudo' : ''}`, blocks[b], read, marks ? (p) => p.marks.size === mine.size && [...mine].every((m) => p.marks.has(m)) : undefined)
             : read();
         for (const op of part.ops)
             ops.push({ ...op, pos: start + op.pos, depth: base + op.depth });
@@ -289,6 +306,75 @@ const runningOp = (r, at) => ({ reset: [], increment: [], set: [], strings: null
 export function counterStateAt(ops, pos, away = []) {
     return replay(ops, { until: pos, away });
 }
+/** No page-context rule touches the page counter. */
+export const NO_PAGE_COUNTER_OPS = Object.freeze({ reset: null, increment: null, set: null });
+/**
+ * The page number of page `pageIndex`, which begins at `pos`: the run's own count, with an element's reset of the page counter counted on from the page it begins on, and the page context's own `counter-reset`, `counter-increment` and `counter-set` applied as Chromium's print applies them.
+ *
+ * @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.
+ *
+ * **The page context's rules are the page box's, and each page box is its own scope.** Measured 2026-11-07 on Chromium's print (`test/browser/page-context-counters.browser.ts`): every page adds its `counter-increment` of `page`, or 1 where none is declared, to the count the pages carry; a `counter-set` sets that count, and the pages after count on from it (`@page :first { counter-set: page 7 }` prints 7, 8, 9); a `counter-reset` opens a counter of the page box's own, so the page prints the reset value plus that page's own declared increment and the pages after continue the count as though it had not been there (`@page :first { counter-reset: page 10 }` prints 10, 1, 2, and with `@page { counter-increment: page 2 }` beside it 12, 2, 4). An element's reset is applied to the count before the page's own rules, and the page it begins on takes no implicit increment. Until 2026-11-07 these declarations reached the page host as author style, where `counter-increment: page 2` added to the host's `page N` and the host's inline reset hid every `@page` reset: 3, 4, 5 for Chromium's 7, 2, 4.
+ *
+ * @param pages - each page before `pageIndex`, by index: its first word position, whether it is blank, and its page context's rules.
+ * @param blank - whether page `pageIndex` is one the engine made blank.
+ * @param counter - page `pageIndex`'s page context's rules.
+ * @param away - the remainders the page's opening cut carries in, as for {@link counterStateAt}.
+ */
+export function pageNumberAt(ops, pageIndex, pos, { pages, blank = false, counter = NO_PAGE_COUNTER_OPS, away = [] }) {
+    const inForce = (at, start, isBlank) => at < start || (at === start && !isBlank);
+    const resets = [];
+    for (const op of ops) {
+        if (op.pos > pos)
+            break;
+        for (const [name, value] of [...op.reset, ...op.set])
+            if (name === 'page')
+                resets.push({ pos: op.pos, value });
+    }
+    /** The last element reset in force on a page; the current page alone knows the remainders it carries in. */
+    const resetOn = (start, isBlank, current) => {
+        let found = null;
+        for (const r of resets)
+            if (inForce(r.pos, start, isBlank) && !(current && away.length && inRemainders(away, r.pos)))
+                found = r;
+        return found;
+    };
+    let count = 0;
+    let shown = 0;
+    let before = null;
+    for (let i = 0; i <= pageIndex; i++) {
+        const page = i === pageIndex ? { start: pos, blank, counter } : pages(i);
+        const own = page.counter ?? NO_PAGE_COUNTER_OPS;
+        const reset = resets.length ? resetOn(page.start, page.blank, i === pageIndex) : null;
+        const elementReset = reset !== null && reset !== before;
+        before = reset;
+        if (elementReset)
+            count = reset.value;
+        if (own.reset !== null) {
+            // The page box's own counter: it shows here and the count goes on beneath it.
+            shown = own.set ?? own.reset + (own.increment ?? 0);
+            continue;
+        }
+        count += own.increment ?? (elementReset ? 0 : 1);
+        if (own.set !== null)
+            count = own.set;
+        shown = count;
+    }
+    return shown;
+}
+/** 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/dressing.d.ts

@@ -25,7 +25,11 @@ export type Dressing = {
     /** whether the value words' properties are registered, which is done once a stylesheet the document wears names one. */
     registered: boolean;
 };
-/** Make sure the document has the words sheet's rules, once; later calls answer the same record. A document the provision reached already has them and nothing is seated; any other gets the layer named first in the head and the rules adopted after whatever it wears. */
+/**
+ * Make sure the document has the words sheet's rules, and answer its record. A document the provision reached already has them and nothing is seated; any other gets the layer named first in the head and the rules adopted after whatever it wears.
+ *
+ * **The document is asked, not remembered** ([*the engine asks the document for its sheets*](../../../.claude/decisions/cicero/the-engine-asks-the-document-for-its-sheets.md)), as `ensureContinuationDressing` does: a host that re-seats a kept `Document` empties its adopted sheets, so a later call adopts the words sheet again, and names the layer again, where the document no longer carries them.
+ */
 export declare function ensureDressing(doc: Document): Dressing;
 /**
  * Make sure the document wears the continuation dressing, and answer its sheet: a piece that resumes a box shows none of the box's beginnings, `::before`, `::marker`, `::first-letter` and `::first-line`, and a piece the cut passes through shows no `::after`. The sheet is made once per document and adopted after whatever the document wears; a later call adopts it again only where the document no longer wears it.

package/dist/src/dressing.js

@@ -36,25 +36,31 @@ function providesRules(doc) {
     const provision = doc.head.querySelector('style[data-beltype~="cicero-provision"]');
     return !!provision && (provision.textContent ?? '').includes(WORDS_RULES);
 }
-/** Make sure the document has the words sheet's rules, once; later calls answer the same record. A document the provision reached already has them and nothing is seated; any other gets the layer named first in the head and the rules adopted after whatever it wears. */
+/**
+ * Make sure the document has the words sheet's rules, and answer its record. A document the provision reached already has them and nothing is seated; any other gets the layer named first in the head and the rules adopted after whatever it wears.
+ *
+ * **The document is asked, not remembered** ([*the engine asks the document for its sheets*](../../../.claude/decisions/cicero/the-engine-asks-the-document-for-its-sheets.md)), as `ensureContinuationDressing` does: a host that re-seats a kept `Document` empties its adopted sheets, so a later call adopts the words sheet again, and names the layer again, where the document no longer carries them.
+ */
 export function ensureDressing(doc) {
-    const known = DRESSINGS.get(doc);
-    if (known)
-        return known;
-    const dressing = { words: null, values: null, delivered: new Set(), registered: false };
-    DRESSINGS.set(doc, dressing);
-    if (providesRules(doc))
+    let dressing = DRESSINGS.get(doc);
+    if (!dressing) {
+        dressing = { words: null, values: null, delivered: new Set(), registered: false };
+        DRESSINGS.set(doc, dressing);
+        if (providesRules(doc))
+            return dressing;
+        dressing.words = new (doc.defaultView.CSSStyleSheet)();
+        dressing.words.replaceSync(WORDS_RULES);
+    }
+    if (!dressing.words)
         return dressing;
-    const Sheet = doc.defaultView.CSSStyleSheet;
     if (!doc.getElementById(LAYERS_ID)) {
         const layers = doc.createElement('style');
         layers.id = LAYERS_ID;
         layers.textContent = `@layer ${LAYER};`;
         doc.head.prepend(layers);
     }
-    dressing.words = new Sheet();
-    dressing.words.replaceSync(WORDS_RULES);
-    doc.adoptedStyleSheets = [...doc.adoptedStyleSheets, dressing.words];
+    if (!doc.adoptedStyleSheets.includes(dressing.words))
+        doc.adoptedStyleSheets = [...doc.adoptedStyleSheets, dressing.words];
     return dressing;
 }
 /** The continuation dressing each document wears. */
@@ -134,13 +140,14 @@ export function deliverValues(doc, words) {
         dressing.delivered.add(word);
         grew = true;
     }
-    if (!grew)
+    if (!grew && !dressing.values)
         return;
-    if (!dressing.values) {
-        dressing.values = new (doc.defaultView.CSSStyleSheet)();
+    // The document is asked, not remembered: a re-seated document wears no values sheet even when no word is new.
+    dressing.values ??= new (doc.defaultView.CSSStyleSheet)();
+    if (!doc.adoptedStyleSheets.includes(dressing.values))
         doc.adoptedStyleSheets = [...doc.adoptedStyleSheets, dressing.values];
-    }
-    dressing.values.replaceSync([...dressing.delivered].map((word) => `${selectorOf(word)} { ${PROPERTY_OF.get(word.slice(0, word.indexOf(':')))}: ${word.slice(word.indexOf(':') + 1)}; }`).join('\n'));
+    if (grew)
+        dressing.values.replaceSync([...dressing.delivered].map((word) => `${selectorOf(word)} { ${PROPERTY_OF.get(word.slice(0, word.indexOf(':')))}: ${word.slice(word.indexOf(':') + 1)}; }`).join('\n'));
 }
 /** Is this adopted sheet one of the engine's three sheets keyed on words — the words sheet a host without the provision gets, the values sheet, and the continuation dressing? A host reading the sheets the document wears (`seam/client.js`' conditions key) leaves them out, as it leaves out the root's own sheets and the reads' delivery sheet. */
 export function isWordsSheet(doc, sheet) {

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, sheetsCountInPseudos } from './capture.js';
 import { snapshotOfStyle } from './forcing-memo.js';
 import { cloneFlowPiece, declineRepeats, mayRepeat, mutateToContinuation, truncateFrom } from './fragments.js';
 import { cutAfter, divides, elAtIn, flattenResume, indexBlocks, inFlowIndex, inRemainders, normalizePath, pathOf, placeAt, remaindersOf } from './positions.js';
-import { documentOpsOf, counterStateAt, 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] } };
             }
@@ -610,6 +648,7 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
      */
     const documentOps = 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) })),
         keep: memo?.keep
@@ -622,16 +661,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 +761,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.
@@ -732,14 +781,25 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
     let compositionKey = null;
     // Entry N determines page N+1's conditions (*geometry changes only at page boundaries*, C8): name from the cursor's own address, parity from the page number, :first for page one. A width change re-creates the measure context and recomposes through the cache's width key — *cut-invariance* (C7) suspended locally, exactly as designed; the v3 constraint (widths change only at named-switch boundaries) keeps that suspension off mid-paragraph continuations.
     const conditionsFor = (pageIndex, { blank = false } = {}) => conditionsAt(pageIndex, cursor.cut, cursor.pos, { blank, carried: cursor.carried });
+    /** A kept page's `@page` counter rules, by its conditions: one geometry read per kind of page, not one per page per page. */
+    const pageCounters = new Map();
+    const pageCounterOf = (i, c) => {
+        const key = JSON.stringify([c.name, i === 0, c.parity, c.blank]);
+        let ops = pageCounters.get(key);
+        if (!ops)
+            pageCounters.set(key, ops = table.pageFor({ name: c.name, first: i === 0, parity: c.parity, blank: c.blank }).pageCounter);
+        return ops;
+    };
     /** 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);
         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 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));
         return Object.freeze({ ...geo, name, pageNumber, parity, blank, counters, dpr: win.devicePixelRatio });
     };
     /**
@@ -778,7 +838,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 +1073,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 });
@@ -1324,7 +1386,8 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
             const cutY = v.y;
             const places = v.items.map(({ item, state, verdict }) => ({
                 item,
-                at: state === 'above' ? { box: item, word: null, px: { remaining: 0, paint: null }, flows: [] } : state === 'below' || state === 'held' ? { box: item, word: null, px: null, flows: [] } : verdict ? verdictPlace(verdict) : placesOf(item, cutY)
+                // An item that is `done` has shown all its content and continues as a shell of what its box has left; the Stonehand said so knowing where a divided cell's content stands (`cellLift`), which the geometry of the feed does not.
+                at: state === 'above' ? { box: item, word: null, px: { remaining: 0, paint: null }, flows: [] } : state === 'done' ? { box: item, word: null, px: { remaining: item.rect.bottom - cutY, paint: null }, flows: [] } : state === 'below' || state === 'held' ? { box: item, word: null, px: null, flows: [] } : verdict ? verdictPlace(verdict) : placesOf(item, cutY)
             }));
             const last = places.pop();
             return { ...last.at, itemBox: last.item, flows: [...places.map(({ item, at }) => ({ ...at, itemBox: item, remainingPx: item.rect.top < cutY && item.rect.bottom > cutY ? item.rect.bottom - cutY : null })), ...last.at.flows] };
@@ -1416,6 +1479,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).
@@ -1548,6 +1618,14 @@ async function paginateOnce(doc, { composed = false, compositionCache = new Comp
                             visit(f);
                     })(rowPlace);
                 }
+                else if (v.kind !== 'E') {
+                    // A table cell the main path's cut divides gets the same extension: Chromium's print aligns a divided cell's content within its first fragment, which reaches the foot, and the Stonehand judged the cut so (`cellLift`).
+                    const foot = pageStart + usableH;
+                    for (let p = v.kind === 'A' ? v.box.parent : v.box; p; p = p.parent) {
+                        if (win.getComputedStyle(p.el).display === 'table-cell' && p.rect.top < v.y - 0.25 && p.rect.bottom > v.y + 0.25)
+                            extents.push({ path: pathOf(sourceOf(p.el), blocks[cutB], cutB), px: foot - p.rect.top });
+                    }
+                }
                 const tf = performance.now();
                 const flat = flattenResume({ pos, box: sourceOf(v.box.el), cut, flows });
                 addr.flatten += performance.now() - tf;