@beltype/cicero 0.1.7 → 0.1.9

package/dist/src/capture.d.ts

@@ -10,7 +10,7 @@
  * @packageDocumentation
  */
 import type { Decl } from './margin-boxes.ts';
-import type { counterStateAt } from './document-state.ts';
+import { type counterStateAt, type PageCounterOps } from './document-state.ts';
 import type { Px } from './gauge.ts';
 export type Side = 'top' | 'right' | 'bottom' | 'left';
 /** One value per side of a box. */
@@ -40,6 +40,8 @@ export type PageGeometry = {
     /** Raw `content` values per margin box, transliterated per page by {@link transliterateContent}. */
     marginBoxes: Record<string, string>;
     pageStyle: PageStyle;
+    /** What the page context's rules do to the page counter, which `document-state.ts`'s `pageNumberAt` applies and the host never wears. */
+    pageCounter: PageCounterOps;
 };
 /** What a page is asked for by: the four conditions css-page-3 §4 selects `@page` rules on. */
 export type PageCondition = {
@@ -102,6 +104,8 @@ export declare function styleSheetsOf(doc: Document): CSSStyleSheet[];
  * A box outside a fragment's interval is kept hollow, an element with no children, and every structural selector matches it as it matched the deep clone it replaced — except a `:has()` whose argument reaches inside it. Since 2026-10-10 the host rewrites every `:has()` it can (`seam/rewrite.js`) into a union whose second arm reads a word the engine writes on the copy (`data-beltype.js`, `has-words.js`), so a hollow copy matches as its original does and the answer here is NO for a document whose `:has()` arguments are all rewritten. What is left is the `:has()` whose argument reads state a word computed once cannot follow — `:hover`, `:checked`, `:focus-within`, `:target` and their kin — and a sheet no host rewrote at all: for those the fragments are built deep, as before. Grouping rules, nested rules and imported sheets are walked, since a selector inside `@media` or `@layer` still matches; a sheet the engine cannot read answers yes, because it might. The reading is textual and counts: a rule whose selector holds more `:has(` than unions has one that nothing answers for.
  */
 export declare function sheetsUseHas(doc: Document): boolean;
+/** Whether a rule sets a counter on a `::before` or an `::after`: only then does the counter walk ask every element's pseudo-elements for their counters (`document-state.ts`'s `documentOpsOf`), which costs two style reads an element. A sheet the engine cannot read answers yes. */
+export declare function sheetsCountInPseudos(doc: Document): boolean;
 /** The arguments the host rewrote, read back from the registry rules (`:not(*) { --beltype-has-<h>: "<A>" }`, one per rewritten sheet): hash → the argument's canonical text. The capture reads the CSSOM and nothing else, so the arguments come from the rule the rewriter appended and no selector is ever parsed back. */
 export declare function hasArgumentsOf(doc: Document): Map<string, string>;
 /**

package/dist/src/capture.js

@@ -13,6 +13,7 @@ import { MARGIN_BOXES } from './margin-boxes.js';
 import { expandBox } from './box-shorthand.js';
 import { CUSTOM_PROPS, decodeContentFn, decodePageName, encodeStringProp } from './gcpm-encoding.js';
 import { HAS_PROPERTY_PREFIX, bareHasCount, decodeHasArgument, isHasRegistryRule } from './data-beltype.js';
+import { pairsOf } from './document-state.js';
 const PX_PER = { px: 1, pt: 96 / 72, in: 96, cm: 96 / 2.54, mm: 96 / 25.4, q: 96 / 101.6 };
 /**
  * Every sheet the document wears — `document.styleSheets` first, then `document.adoptedStyleSheets`.
@@ -32,6 +33,10 @@ export function styleSheetsOf(doc) {
 export function sheetsUseHas(doc) {
     return someRule(doc, (rule) => !!rule.selectorText && bareHasCount(rule.selectorText) > 0);
 }
+/** Whether a rule sets a counter on a `::before` or an `::after`: only then does the counter walk ask every element's pseudo-elements for their counters (`document-state.ts`'s `documentOpsOf`), which costs two style reads an element. A sheet the engine cannot read answers yes. */
+export function sheetsCountInPseudos(doc) {
+    return someRule(doc, (rule) => !!rule.selectorText && /::?(?:before|after)\b/i.test(rule.selectorText) && /\bcounter-(?:reset|increment|set)\s*:/.test(rule.style?.cssText ?? ''));
+}
 /** The arguments the host rewrote, read back from the registry rules (`:not(*) { --beltype-has-<h>: "<A>" }`, one per rewritten sheet): hash → the argument's canonical text. The capture reads the CSSOM and nothing else, so the arguments come from the rule the rewriter appended and no selector is ever parsed back. */
 export function hasArgumentsOf(doc) {
     const found = new Map();
@@ -659,6 +664,36 @@ function declarationsOf(style, owned = ownedByCicero) {
     }
     return out;
 }
+/** The three counter properties, each with the value an unnumbered name takes. */
+const PAGE_COUNTER_PROPS = { 'counter-reset': 0, 'counter-increment': 1, 'counter-set': 0 };
+/**
+ * A page rule's declarations with the page counter taken out of its `counter-reset`, `counter-increment` and `counter-set`: the page number is `pageNumberAt`'s, written on the host as `page N`, and an increment the host wore beside it was added to N (`@page { counter-increment: page 2 }` printed 3, 4, 5 where Chromium prints 2, 4, 6) while the host's inline reset hid every `@page` reset. Another counter's pair stays where it was.
+ */
+function withoutPageCounter(decls) {
+    return decls.flatMap((d) => {
+        const fallback = PAGE_COUNTER_PROPS[d[0]];
+        if (fallback === undefined)
+            return [d];
+        const pairs = pairsOf(d[1], fallback);
+        if (!pairs.some(([name]) => name === 'page'))
+            return [d];
+        const rest = pairs.filter(([name]) => name !== 'page');
+        return rest.length ? [[d[0], rest.map(([name, value]) => `${name} ${value}`).join(' '), d[2]]] : [];
+    });
+}
+/** The page counter's value in each of a condition's three winning counter declarations, `null` where the winner names no `page`: the cascade over the applicable rules, in ascending specificity, `!important` beating normal. */
+function pageCounterOf(rules) {
+    const winners = {};
+    for (const r of rules)
+        for (const d of r.style)
+            if (d[0] in PAGE_COUNTER_PROPS && (d[2] === 'important' || winners[d[0]]?.[2] !== 'important'))
+                winners[d[0]] = d;
+    const pageOf = (prop) => {
+        const pair = pairsOf(winners[prop]?.[1], PAGE_COUNTER_PROPS[prop]).findLast(([name]) => name === 'page');
+        return pair ? pair[1] : null;
+    };
+    return { reset: pageOf('counter-reset'), increment: pageOf('counter-increment'), set: pageOf('counter-set') };
+}
 /**
  * The faces page furniture asks for, as `FontFaceSet.load()` arguments (the platform's font preloading) — read from the `@page` rules' own declarations, where the families are already in hand.
  *
@@ -1051,7 +1086,7 @@ export function readGeometryTable(doc) {
     try {
         for (const r of rules) {
             r.split = { host: [], cell: [] };
-            for (const decl of r.style)
+            for (const decl of withoutPageCounter(r.style))
                 (inheritance.reaches(decl) ? r.split.cell : r.split.host).push(decl);
         }
     }
@@ -1114,7 +1149,7 @@ export function readGeometryTable(doc) {
         const b = Object.fromEntries(SIDES.map((side) => [side, borderIsDrawn(borderStyles[side]) ? resolve(borderWidths[side] ?? 'medium', basePx(side), `${label} border-${side}-width`, 'borderTopWidth') : 0]));
         const area = pageArea({ pageW, pageH, margins: m, borders: b, paddings: p });
         assertPageArea(area, label);
-        return { pageW, pageH, margins: m, borders: b, paddings: p, ...area, marginBoxes, pageStyle };
+        return { pageW, pageH, margins: m, borders: b, paddings: p, ...area, marginBoxes, pageStyle, pageCounter: pageCounterOf(applicable) };
     }
     /**
      * The intake sweep (*page lengths are measured*, decision 3). Every reachable condition is resolved once, here — where the document is live and the fonts are awaited — so an unresolvable length refuses at intake rather than throwing from inside the per-page loop, pages deep, after the measure context has been built. The set is finite and small: each declared page name plus the unnamed page, × `:first`, × parity. Afterwards the memo answers every per-page call, so `pageFor` stays synchronous and keeps its signature.

package/dist/src/chase.js

@@ -312,9 +312,11 @@ export class BeltypePage extends HTMLElement {
             const keys = names.map((n, i) => `${this.#dressText} ${n} ${generated[i]} ${(this.#reads[n] ?? []).map((r) => `${r}=${this.#published.get(r) ?? ''}`).join(',')} ${cellKey(cells[i])}`);
             let pairs = keys.map((k) => INTRINSICS.get(k));
             if (pairs.some((p) => !p)) {
+                // A rect is drawn under every transform above the page, and a host that zooms with `transform: scale(s)` would hand §5.3.2 widths in its pixels, not the page's, and the cache would keep them for every scale after (assessment 2026-11-07). The band spans exactly `#bandWidth` of the page's own pixels, so its rect says the scale.
+                const scale = el.getBoundingClientRect().width / this.#bandWidth || 1;
                 const read = (track) => {
                     el.style.gridTemplateColumns = `${track} ${track} ${track}`;
-                    return cells.map((c) => c.getBoundingClientRect().width);
+                    return cells.map((c) => c.getBoundingClientRect().width / scale);
                 };
                 const max = read('max-content');
                 const min = read('min-content');

package/dist/src/data-beltype.d.ts

@@ -153,9 +153,9 @@ export declare const CUT_OFF: string;
  * The rules, as text. Each is a sentence about a word.
  *
  * - `away`: a box put away on this page is not displayed, and it stays an element so every structural selector reads as it does in the source (*every branch gets a place*, 2026-09-21).
- * - A resumed piece gives up the margin that adjoins the break, and the indent (the box is not beginning); and, unless the box wraps each fragment whole (`wrapped`, css-break-3 §5.4's `clone`), its border and padding at that edge.
+ * - A resumed piece gives up the margin that adjoins the break, and the indent (the box is not beginning); and, unless the box wraps each fragment whole (`wrapped`, css-break-3 §5.4's `clone`), its border, its padding and its corners' rounding at that edge: a slice is the box cut through, so the cut edge is square (Chromium's print, measured 2026-11-07).
  * - A resumed piece's counter operations already happened where the box began (`counter-reset`, `counter-increment` and `counter-set` are `none` on it): the page's start delivers the counters as they stood (`chase.js`'s `setCounters`), and a clone that fired them again would count the box twice.
- * - A cut-off piece gives up the margin before the break, and unless `wrapped` its border and padding there.
+ * - A cut-off piece gives up the margin before the break, and unless `wrapped` its border, padding and rounding there.
  * - `adjoin`: the box a bare-path cut resumes at, and the first-child chain through which its margin collapses, give up the margin that adjoins the break (css-break-3 §5.2) and nothing else — they are not divided.
  */
 export declare const WORDS_RULES: string;

package/dist/src/data-beltype.js

@@ -292,18 +292,18 @@ const RESUMED_BOX = `${RESUMED}:not(${w(SHELL)})`;
  * The rules, as text. Each is a sentence about a word.
  *
  * - `away`: a box put away on this page is not displayed, and it stays an element so every structural selector reads as it does in the source (*every branch gets a place*, 2026-09-21).
- * - A resumed piece gives up the margin that adjoins the break, and the indent (the box is not beginning); and, unless the box wraps each fragment whole (`wrapped`, css-break-3 §5.4's `clone`), its border and padding at that edge.
+ * - A resumed piece gives up the margin that adjoins the break, and the indent (the box is not beginning); and, unless the box wraps each fragment whole (`wrapped`, css-break-3 §5.4's `clone`), its border, its padding and its corners' rounding at that edge: a slice is the box cut through, so the cut edge is square (Chromium's print, measured 2026-11-07).
  * - A resumed piece's counter operations already happened where the box began (`counter-reset`, `counter-increment` and `counter-set` are `none` on it): the page's start delivers the counters as they stood (`chase.js`'s `setCounters`), and a clone that fired them again would count the box twice.
- * - A cut-off piece gives up the margin before the break, and unless `wrapped` its border and padding there.
+ * - A cut-off piece gives up the margin before the break, and unless `wrapped` its border, padding and rounding there.
  * - `adjoin`: the box a bare-path cut resumes at, and the first-child chain through which its margin collapses, give up the margin that adjoins the break (css-break-3 §5.2) and nothing else — they are not divided.
  */
 export const WORDS_RULES = `
 @layer ${LAYER} {
   ${w(AWAY)} { display: none !important; }
   ${RESUMED_BOX} { margin-top: 0 !important; text-indent: 0 !important; counter-reset: none !important; counter-increment: none !important; counter-set: none !important; }
-  ${RESUMED_BOX}:not(${w(WRAPPED)}) { border-top-width: 0 !important; padding-top: 0 !important; }
+  ${RESUMED_BOX}:not(${w(WRAPPED)}) { border-top-width: 0 !important; padding-top: 0 !important; border-top-left-radius: 0 !important; border-top-right-radius: 0 !important; }
   ${CUT_OFF} { margin-bottom: 0 !important; }
-  ${CUT_OFF}:not(${w(WRAPPED)}) { border-bottom-width: 0 !important; padding-bottom: 0 !important; }
+  ${CUT_OFF}:not(${w(WRAPPED)}) { border-bottom-width: 0 !important; padding-bottom: 0 !important; border-bottom-left-radius: 0 !important; border-bottom-right-radius: 0 !important; }
   ${w(ADJOIN)} { margin-top: 0 !important; }
 }
 `;

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

@@ -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 a `counter(list-item)` an author's own content reads, a margin box's among them, reads low on a page a list continues onto; the list's markers are right since 2026-11-07, because each divided `<ol>`'s copy carries a `start` of HTML's own numbering (`fragments.js`'s `numberDividedLists`); 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
  */
@@ -62,6 +62,8 @@ export type Op = {
         at: number;
     };
 };
+/** `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. */
+export declare function pairsOf(value: unknown, fallback: number): [string, number][];
 /**
  * A `<content-list>` into terms — GCPM §1.1.1's own grammar and no more of CSS than it needs.
  *
@@ -78,11 +80,13 @@ export declare const collapse: (text: unknown) => string;
 /** 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 declare function blockOpsOf(block: any, index: {
     wordsBefore: (el: any) => number;
+    wordCountIn?: (el: any) => number;
 }, reads: {
     styleOf: (el: any) => any;
     textOf: (el: any) => string;
     attrOf: (el: any, name: string) => string | null;
     marks: Set<object> | null;
+    pseudoStyleOf?: ((el: any, pseudo: '::before' | '::after') => any) | null;
 }): Op[];
 /**
  * The counter operations of a document, in document order, each with the flat word position it sits at and its depth in the tree.
@@ -90,6 +94,7 @@ export declare function blockOpsOf(block: any, index: {
  * @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.
@@ -100,11 +105,13 @@ export declare function blockOpsOf(block: any, index: {
 export declare function documentOpsOf(blocks: ArrayLike<Element>, index: {
     bases: number[];
     wordsBefore: (el: any) => number;
+    wordCountIn?: (el: any) => number;
     entryFor?: (el: any) => {
         block: number;
     } | null;
-}, { styleOf, textOf, attrOf, ancestors, marks, running, keep }: {
+}, { styleOf, pseudoStyleOf, textOf, attrOf, ancestors, marks, running, keep }: {
     styleOf: (el: any) => object;
+    pseudoStyleOf?: ((el: any, pseudo: '::before' | '::after') => object) | null;
     textOf?: (el: any) => string;
     attrOf?: (el: any, name: string) => string | null;
     ancestors?: Element[];
@@ -128,8 +135,16 @@ export declare function counterStateAt(ops: ReturnType<typeof documentOpsOf>, po
     from: number;
     to: number;
 }>): Record<string, number[]>;
+/** What the page context's own rules do to the page counter on one page: the `page` value of the winning `counter-reset`, `counter-increment` and `counter-set` of the `@page` rules that apply to it, `null` where the winning declaration names no `page` (`capture.ts`'s `pageFor`). */
+export type PageCounterOps = {
+    reset: number | null;
+    increment: number | null;
+    set: number | null;
+};
+/** No page-context rule touches the page counter. */
+export declare const NO_PAGE_COUNTER_OPS: PageCounterOps;
 /**
- * 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.
+ * 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).
@@ -138,16 +153,21 @@ export declare function counterStateAt(ops: ReturnType<typeof documentOpsOf>, po
  *
  * **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.
+ * **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 declare function pageNumberAt(ops: ReadonlyArray<Op>, pageIndex: number, pos: number, { pages, blank, away }: {
+export declare function pageNumberAt(ops: ReadonlyArray<Op>, pageIndex: number, pos: number, { pages, blank, counter, away }: {
     pages: (i: number) => {
         start: number;
         blank: boolean;
+        counter?: PageCounterOps;
     };
     blank?: boolean;
+    counter?: PageCounterOps;
     away?: ReadonlyArray<{
         from: number;
         to: number;

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 a `counter(list-item)` an author's own content reads, a margin box's among them, reads low on a page a list continues onto; the list's markers are right since 2026-11-07, because each divided `<ol>`'s copy carries a `start` of HTML's own numbering (`fragments.js`'s `numberDividedLists`); 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,8 +306,10 @@ 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, or, where an element reset the page counter, that element's value counted on from the page it begins on.
+ * 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).
@@ -299,33 +318,53 @@ export function counterStateAt(ops, pos, away = []) {
  *
  * **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.
+ * **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, away = [] }) {
+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);
-    let reset = null;
+    const resets = [];
     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 };
+                resets.push({ 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++;
+    /** 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 reset.value + since;
+    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) {

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.js

@@ -19,7 +19,7 @@ import { holdsAnonymousBlocks, takeReport } from './gauge.js';
 import { adjudicate, adjudicateFlow, firstBelowTheEdge, isAbsolutelyPositioned, isOutOfFlow, isMonolith, neverCutInside, reachesBelowTheEdge, processionBottoms, fitsPage } from './stonehand.js';
 import { composeDocument, applyRecordsUnder } from './compose-dom.js';
 import { CompositionCache } from './composition-key.js';
-import { readGeometryTable, effectivePageName, pageRulesOf, styleSheetsOf, registerGcpmProperties, sheetsUseHas, sheetReach } 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';
@@ -648,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
@@ -780,14 +781,23 @@ 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 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 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 });
@@ -1376,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] };
@@ -1607,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;

package/dist/src/fragmentation.d.ts

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

package/dist/src/fragmentation.js

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

package/dist/src/fragments.d.ts

@@ -141,6 +141,12 @@ export declare function mutateToContinuation(clone: Element, { cut, remainderPx,
     hollow?: boolean;
     forced?: boolean;
 }): Element;
+/**
+ * The ordinal value of each item an `<ol>` owns, as HTML numbers them (§4.4.8) and css-lists-3 states it as the `list-item` counter: the list resets the counter one step before its `start`, which under `reversed` defaults to the number of items; each item adds its step, 1 or −1 under `reversed` unless a `counter-increment` names `list-item`, and a `counter-set` of `list-item`, or else a `value` attribute, sets it.
+ *
+ * @remarks A `counter-reset` of `list-item` on an item, which opens a list of its own inside the list, is not modelled.
+ */
+export declare function listOrdinals(ol: Element): Map<Element, number>;
 /**
  * A clone of a top-level block for one interval, hollow outside it (*the clone is hollow outside the interval*, 2026-09-27) — the one construction behind the measure feed and every presented fragment, and the one place the clone-to-source map is filled.
  *

package/dist/src/fragments.js

@@ -19,6 +19,7 @@
  */
 import { applyRecordsUnder, hyphenCharOf } from './compose-dom.js';
 import { addWord, ADJOIN, ARTIFACT, AWAY, END, ENGINE_MARKS, hasAnyWord, hasWord, removeWord, SHELL, SPLIT, START, WRAPPED } from './data-beltype.js';
+import { pairsOf } from './document-state.js';
 import { divides, elAtIn, flowsOf } from './positions.js';
 import { BREAKING_SPACE, clonesDecoration, cutRanges, emptyText, leaveOut, replaceChars, isEngineText, isFixedBox, isInlineBox, isLineBreak, copyOf, shellOf, noteText, READS_ITS_CHILDREN, sourceOf, sourceStyle } from './word-space.js';
 /** The word space, clone side: words are maximal non-whitespace runs of the subtree's joined text — a run crossing a text-node or inline-element seam is one word, exactly as the Gauge reads, and exactly as the position index counts over sources (src/positions.js — the two tokenizations must never drift; counting per node instead shifts every offset by the seam-spanning words before it, which the test-document's inline markup caught). **A non-inline boundary ends the run** (word-space.js), which is where this stopped agreeing with the page for two months. This walk survives on the clone side only: consumption must find the resume word's actual text nodes in the mutated copy, which no source-side index can answer. */
@@ -790,8 +791,72 @@ export function mutateToContinuation(clone, { cut = null, remainderPx = null, so
         applyCarriedRemainder(clone, source, remainderPx);
     for (const m of mine)
         mutateToContinuation(m.itemClone, { cut: m.cut, remainderPx: m.e.remainingPx ?? null, source: m.itemSource, cloneOf, flows: m.nested, rootPath: m.e.item, hollow });
+    numberDividedLists(root, cut, source, cloneOf);
     return root;
 }
+/** The list items an `<ol>` owns, in tree order: HTML's list owner is the nearest `ol`, `ul` or `menu` ancestor. An item that is not displayed as a list item has no ordinal, where a style can be read. */
+function ownedItems(ol) {
+    const out = [];
+    (function walk(el) {
+        for (const c of el.children) {
+            if (/^(?:OL|UL|MENU)$/i.test(c.tagName))
+                continue;
+            if (/^LI$/i.test(c.tagName)) {
+                const display = sourceStyle(c)?.display;
+                if (display == null || display.includes('list-item'))
+                    out.push(c);
+            }
+            walk(c);
+        }
+    })(ol);
+    return out;
+}
+/**
+ * The ordinal value of each item an `<ol>` owns, as HTML numbers them (§4.4.8) and css-lists-3 states it as the `list-item` counter: the list resets the counter one step before its `start`, which under `reversed` defaults to the number of items; each item adds its step, 1 or −1 under `reversed` unless a `counter-increment` names `list-item`, and a `counter-set` of `list-item`, or else a `value` attribute, sets it.
+ *
+ * @remarks A `counter-reset` of `list-item` on an item, which opens a list of its own inside the list, is not modelled.
+ */
+export function listOrdinals(ol) {
+    const items = ownedItems(ol);
+    const reversed = ol.hasAttribute('reversed');
+    const dflt = reversed ? -1 : 1;
+    const start = parseInt(ol.getAttribute('start') ?? '', 10);
+    let n = (Number.isFinite(start) ? start : reversed ? items.length : 1) - dflt;
+    const out = new Map();
+    for (const li of items) {
+        const style = sourceStyle(li);
+        const named = (value, fallback) => pairsOf(value, fallback).find(([name]) => name === 'list-item')?.[1];
+        n += named(style?.counterIncrement, 1) ?? dflt;
+        const value = parseInt(li.getAttribute('value') ?? '', 10);
+        const set = named(style?.counterSet, 0) ?? (Number.isFinite(value) ? value : null);
+        if (set != null)
+            n = set;
+        out.set(li, n);
+    }
+    return out;
+}
+/**
+ * Every `<ol>` a cut divides is numbered from the first item its piece keeps: the piece's copy carries a `start` attribute of that item's ordinal, so the browser's own marker counts on from the source's numbering. Without it a continued list numbered from 1 again on every page, and the first piece of a `reversed` list counted down from the items it kept (measured 2026-11-07 against Chromium's print, `test/browser/list-continuation.browser.ts`). Read from the source, so it holds whichever cut ran first.
+ */
+function numberDividedLists(root, cut, source, cloneOf) {
+    if (!divides(cut) || !source || !cloneOf)
+        return;
+    const target = elAtIn(source, cut.path);
+    for (let a = target?.parentElement ?? null; a; a = a === source ? null : a.parentElement) {
+        if (!/^OL$/i.test(a.tagName))
+            continue;
+        const copy = cloneOf.get(a);
+        if (!copy)
+            continue;
+        for (const [li, n] of listOrdinals(a)) {
+            const c = cloneOf.get(li);
+            if (!c || !root.contains(c) || hasWord(c, AWAY))
+                continue;
+            copy.setAttribute('start', String(n));
+            break;
+        }
+    }
+}
 /** The shell branch of the start cut: the box the path names continues at exactly the extent it has left, blank or painted. */
 function shellAt(clone, target, px, keep = new Set(), hollow = false) {
     const painted = px.paint != null;
@@ -1004,6 +1069,7 @@ export function mutateToFirstFragment(clone, { cut = null, extPx = 0, source = n
     /** And the cut line stays justified. css-text-3 §7.2 says a line before a forced or fragmentation break is not the last line of its block, so `text-align: justify` binds it — but in a clone cut AT the break it is the last line and the browser would set it ragged. The alignment is restated rather than inherited, and it is read from the source through the word space's map, because a detached clone has no computed style to ask. The Compositor makes the same move for the same reason (`compose-dom.js`), which is what makes this the engine's one answer written twice for two different line providers rather than two answers. */
     if (sourceStyle(inner)?.textAlign === 'justify')
         inner.style.textAlignLast = 'justify';
+    numberDividedLists(clone, cut, source, cloneOf);
     return clone;
 }
 /**

package/dist/src/reads.d.ts

@@ -7,7 +7,7 @@
  *
  * **A missing target shows nothing**: no declaration is delivered for it, the fallback `""` stands, the pseudo-element still has its box (the leader the author drew still draws), and the console names the link once per paginate.
  *
- * **The loop is a consumer's too, over a chain of its own** (*the engine knows no view*, `.claude/decisions/project/the-engine-knows-no-view.md`, ruling 3). `settleReads`'s `run` and `blocksOf` are the door: a view that holds its own pages settles through this loop, with a `run` that refills the dirty entries of its chain, and never through a copy of it. What the loop assumes of its host, read in its body and its helpers: the sites are found in `doc`'s sheets and matched among `originals` (the whole document where none are given), and a site or a target counts only where it stands inside `blocksOf()`'s blocks, since the position index places it; so `originals` are the boxes that hold the blocks, never a presented copy of them. A target is `doc.getElementById`'s answer, the first element in tree order, which holds where the source boxes precede every copy that keeps the id, as `<beltype-root>` keeps its originals before its copies, or where the copies carry no id. The blocks are any elements in document order: nothing asks that they share a parent or be `body`'s children, since the position index, the counter walk and `pathOf` each walk one block on its own. The counter walk's ancestors are `html` and `body`, the two the driver's own walk reads, so another ancestor of the blocks must carry no counter operation. A changed site is measured on a clone of its block in the measure container, at its page's content width, the ruler the run measures with. The run's result carries an `account` whose entries have the driver's shape (`pos`, `cut`, `carried`, `blank`, `trace.forced`, and `closes` with `pageNumber`, `contentW`, `contentH` and `strings`), every address in `blocksOf()`'s numbering, and the `index` it was handed; and, where its pages publish values of their own, `laidFacts`, the page values each page was laid out under (a flow site reads them), which the loop compares the truth with in place of the table it handed the run (a run that returns none was laid out under the table it was handed, as the driver's is; see CHANGELOG 2026-10-28); a layout sent round again is handed `resume.at`, the addresses of the moved boxes, which such a `run` maps to the entries they dirty. The values reach every element in `doc`'s own tree through one adopted sheet, and the page facts are the page hosts' (`chase.js`). One assumption was the root's alone and is a parameter: the sheet that hides a reservation scopes its rules to `beltype-root`, and `hide` names another scope.
+ * **The loop is a consumer's too, over a chain of its own** (*the engine knows no view*, `.claude/decisions/project/the-engine-knows-no-view.md`, ruling 3). `settleReads`'s `run` and `blocksOf` are the door: a view that holds its own pages settles through this loop, with a `run` that refills the dirty entries of its chain, and never through a copy of it. What the loop assumes of its host, read in its body and its helpers: the sites are found in `doc`'s sheets and matched among `originals` (the whole document where none are given), and a site or a target counts only where it stands inside `blocksOf()`'s blocks, since the position index places it; so `originals` are the boxes that hold the blocks, never a presented copy of them. A target is the first element in tree order carrying the id among `originals` (`doc.getElementById`'s answer where none are given), which holds where the source boxes precede every copy that keeps the id, as `<beltype-root>` keeps its originals before its copies, or where the copies carry no id; a host's own element that carries an author's id is outside the originals and is never a target, and a `target-text()` target outside `blocksOf()`'s blocks shows nothing, as a counter or page target there does. The blocks are any elements in document order: nothing asks that they share a parent or be `body`'s children, since the position index, the counter walk and `pathOf` each walk one block on its own. The counter walk's ancestors are `html` and `body`, the two the driver's own walk reads, so another ancestor of the blocks must carry no counter operation. A changed site is measured on a clone of its block in the measure container, at its page's content width, the ruler the run measures with. The run's result carries an `account` whose entries have the driver's shape (`pos`, `cut`, `carried`, `blank`, `trace.forced`, and `closes` with `pageNumber`, `contentW`, `contentH` and `strings`), every address in `blocksOf()`'s numbering, and the `index` it was handed; and, where its pages publish values of their own, `laidFacts`, the page values each page was laid out under (a flow site reads them), which the loop compares the truth with in place of the table it handed the run (a run that returns none was laid out under the table it was handed, as the driver's is; see CHANGELOG 2026-10-28); a layout sent round again is handed `resume.at`, the addresses of the moved boxes, which such a `run` maps to the entries they dirty. The values reach every element in `doc`'s own tree through one adopted sheet, and the page facts are the page hosts' (`chase.js`). One assumption was the root's alone and is a parameter: the sheet that hides a reservation scopes its rules to `beltype-root`, and `hide` names another scope.
  *
  * @packageDocumentation
  */
@@ -224,7 +224,7 @@ export declare function linesOfSites<S extends {
  *
  * **A layout sent round again resumes from the one before it** (*delivery resumes from the moved page*, 2026-10-21). A delivered value that moves a line is an edit at its site's page, so `run` is handed `resume`, the layout just checked and the addresses of the boxes whose lines moved, and the driver restarts one page before the first of them, re-cuts, and stops where it converges past the last, exactly as it resumes from a host's edit. The result's `resumed` and `why` stay the call's: two resumes compose into one from the prior the host handed (`resume.js`' `composeResumed`), a whole layout anywhere in the loop makes `resumed` null, and each resumed layout leaves a `cicero:reads-run` measure naming the pages it cut again.
  *
- * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22).
+ * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22). A `run` that answers `complete: false` laid out only part of the document (a view's chain that stopped short): the loop ends there, without checking or delivering page values, so the reservations stay hidden and the values it returns are the ones that layout was cut under; the driver's own run is always complete.
  */
 export declare function settleReads<R extends {
     account: any[];
@@ -232,6 +232,7 @@ export declare function settleReads<R extends {
     resumed?: Resumed | null;
     why?: string | null;
     laidFacts?: PagePublish[] | null;
+    complete?: boolean;
 }>(doc: Document, { run, blocksOf, originals, warm, warmFacts, hide, keep }: {
     run: (laid: Laid) => Promise<R>;
     blocksOf: () => Element[];

package/dist/src/reads.js

@@ -7,12 +7,12 @@
  *
  * **A missing target shows nothing**: no declaration is delivered for it, the fallback `""` stands, the pseudo-element still has its box (the leader the author drew still draws), and the console names the link once per paginate.
  *
- * **The loop is a consumer's too, over a chain of its own** (*the engine knows no view*, `.claude/decisions/project/the-engine-knows-no-view.md`, ruling 3). `settleReads`'s `run` and `blocksOf` are the door: a view that holds its own pages settles through this loop, with a `run` that refills the dirty entries of its chain, and never through a copy of it. What the loop assumes of its host, read in its body and its helpers: the sites are found in `doc`'s sheets and matched among `originals` (the whole document where none are given), and a site or a target counts only where it stands inside `blocksOf()`'s blocks, since the position index places it; so `originals` are the boxes that hold the blocks, never a presented copy of them. A target is `doc.getElementById`'s answer, the first element in tree order, which holds where the source boxes precede every copy that keeps the id, as `<beltype-root>` keeps its originals before its copies, or where the copies carry no id. The blocks are any elements in document order: nothing asks that they share a parent or be `body`'s children, since the position index, the counter walk and `pathOf` each walk one block on its own. The counter walk's ancestors are `html` and `body`, the two the driver's own walk reads, so another ancestor of the blocks must carry no counter operation. A changed site is measured on a clone of its block in the measure container, at its page's content width, the ruler the run measures with. The run's result carries an `account` whose entries have the driver's shape (`pos`, `cut`, `carried`, `blank`, `trace.forced`, and `closes` with `pageNumber`, `contentW`, `contentH` and `strings`), every address in `blocksOf()`'s numbering, and the `index` it was handed; and, where its pages publish values of their own, `laidFacts`, the page values each page was laid out under (a flow site reads them), which the loop compares the truth with in place of the table it handed the run (a run that returns none was laid out under the table it was handed, as the driver's is; see CHANGELOG 2026-10-28); a layout sent round again is handed `resume.at`, the addresses of the moved boxes, which such a `run` maps to the entries they dirty. The values reach every element in `doc`'s own tree through one adopted sheet, and the page facts are the page hosts' (`chase.js`). One assumption was the root's alone and is a parameter: the sheet that hides a reservation scopes its rules to `beltype-root`, and `hide` names another scope.
+ * **The loop is a consumer's too, over a chain of its own** (*the engine knows no view*, `.claude/decisions/project/the-engine-knows-no-view.md`, ruling 3). `settleReads`'s `run` and `blocksOf` are the door: a view that holds its own pages settles through this loop, with a `run` that refills the dirty entries of its chain, and never through a copy of it. What the loop assumes of its host, read in its body and its helpers: the sites are found in `doc`'s sheets and matched among `originals` (the whole document where none are given), and a site or a target counts only where it stands inside `blocksOf()`'s blocks, since the position index places it; so `originals` are the boxes that hold the blocks, never a presented copy of them. A target is the first element in tree order carrying the id among `originals` (`doc.getElementById`'s answer where none are given), which holds where the source boxes precede every copy that keeps the id, as `<beltype-root>` keeps its originals before its copies, or where the copies carry no id; a host's own element that carries an author's id is outside the originals and is never a target, and a `target-text()` target outside `blocksOf()`'s blocks shows nothing, as a counter or page target there does. The blocks are any elements in document order: nothing asks that they share a parent or be `body`'s children, since the position index, the counter walk and `pathOf` each walk one block on its own. The counter walk's ancestors are `html` and `body`, the two the driver's own walk reads, so another ancestor of the blocks must carry no counter operation. A changed site is measured on a clone of its block in the measure container, at its page's content width, the ruler the run measures with. The run's result carries an `account` whose entries have the driver's shape (`pos`, `cut`, `carried`, `blank`, `trace.forced`, and `closes` with `pageNumber`, `contentW`, `contentH` and `strings`), every address in `blocksOf()`'s numbering, and the `index` it was handed; and, where its pages publish values of their own, `laidFacts`, the page values each page was laid out under (a flow site reads them), which the loop compares the truth with in place of the table it handed the run (a run that returns none was laid out under the table it was handed, as the driver's is; see CHANGELOG 2026-10-28); a layout sent round again is handed `resume.at`, the addresses of the moved boxes, which such a `run` maps to the entries they dirty. The values reach every element in `doc`'s own tree through one adopted sheet, and the page facts are the page hosts' (`chase.js`). One assumption was the root's alone and is a parameter: the sheet that hides a reservation scopes its rules to `beltype-root`, and `hide` names another scope.
  *
  * @packageDocumentation
  */
 import { READ_PREFIX, STRING_KEYWORDS, STRING_PROP_PREFIX, decodeRead, encodeStringProp, splitTopLevel } from './gcpm-encoding.js';
-import { styleSheetsOf } from './capture.js';
+import { sheetsCountInPseudos, styleSheetsOf } from './capture.js';
 import { format as formatCounter } from './counter-styles.js';
 import { collapse, counterStatesAfter, counterValue, counterValues, documentOpsOf } from './document-state.js';
 import { indexBlocks, pageContaining, pageIntervals, pathOf } from './positions.js';
@@ -285,7 +285,7 @@ export function findSites(doc, originals = null, keep = null) {
                     read,
                     link,
                     key: read.attr != null ? (link == null ? null : attrSelector(read.attr, link)) : '',
-                    target: fragment == null ? null : doc.getElementById(fragment),
+                    target: fragment == null ? null : targetOf(doc, fragment, originals),
                     pseudos
                 });
             }
@@ -293,6 +293,19 @@ export function findSites(doc, originals = null, keep = null) {
     }
     return sites.length ? sites : null;
 }
+/** The element a fragment names: `doc.getElementById`'s answer, or, where the host hands its originals, the first element carrying the id among them, so a host's own element that shares an author's id is never a target. */
+function targetOf(doc, fragment, originals) {
+    const first = doc.getElementById(fragment);
+    if (!originals || !first || originals.some((box) => box.contains(first)))
+        return first;
+    const selector = `[id="${fragment.replace(/["\\]/g, '\\$&').replace(/\n/g, '\\a ')}"]`;
+    for (const box of originals) {
+        const el = box.id === fragment ? box : box.querySelector(selector);
+        if (el)
+            return el;
+    }
+    return null;
+}
 /** The engine's one delivery sheet per document, replaced at every delivery and withdrawn when a paginate finds nothing to deliver. */
 const SHEETS = new WeakMap();
 /** Deliver a table of values: one constructed sheet, adopted once, its text replaced. */
@@ -377,6 +390,7 @@ export function staticValues(sites, { doc, blocks, index = null, keep = null })
         const win = doc.defaultView;
         const ops = documentOpsOf(blocks, index ?? indexBlocks(blocks), {
             styleOf: (el) => win.getComputedStyle(el),
+            pseudoStyleOf: sheetsCountInPseudos(doc) ? (el, pseudo) => win.getComputedStyle(el, pseudo) : null,
             ancestors: [doc.documentElement, doc.body].filter(Boolean),
             marks: new Set(counted.map((s) => s.target)),
             keep
@@ -514,7 +528,7 @@ function boxAddress(site, index, blocks) {
  *
  * **A layout sent round again resumes from the one before it** (*delivery resumes from the moved page*, 2026-10-21). A delivered value that moves a line is an edit at its site's page, so `run` is handed `resume`, the layout just checked and the addresses of the boxes whose lines moved, and the driver restarts one page before the first of them, re-cuts, and stops where it converges past the last, exactly as it resumes from a host's edit. The result's `resumed` and `why` stay the call's: two resumes compose into one from the prior the host handed (`resume.js`' `composeResumed`), a whole layout anywhere in the loop makes `resumed` null, and each resumed layout leaves a `cicero:reads-run` measure naming the pages it cut again.
  *
- * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22).
+ * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22). A `run` that answers `complete: false` laid out only part of the document (a view's chain that stopped short): the loop ends there, without checking or delivering page values, so the reservations stay hidden and the values it returns are the ones that layout was cut under; the driver's own run is always complete.
  */
 export async function settleReads(doc, { run, blocksOf, originals = null, warm = null, warmFacts = null, hide = false, keep = null }) {
     let t = performance.now(); // the site search is the reads' own cost and is inside their measure (*a resumed run keeps its reads*, 2026-10-22)
@@ -529,6 +543,10 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
     const name = (s) => ('read' in s ? `<${s.el.tagName.toLowerCase()}${s.link == null ? '' : ` ${s.read.attr ?? 'url'}="${s.link}"`}>` : `<${s.el.tagName.toLowerCase()}${s.el.id ? ` id="${s.el.id}"` : ''}>`);
     const named = (list) => [...new Set(list.map(name))].join(', ');
     const blocks = blocksOf();
+    // A text target counts only inside the blocks, as every other target does through the position index and the counter walk: an element outside them (a host's own) is no target, and the reference shows nothing.
+    for (const s of sites)
+        if (s.target && s.read.fn === 'text' && !blocks.some((b) => b.contains(s.target)))
+            s.target = null;
     // One walk of the words, shared with the run (*the run resumes from an entry*, build two: 60 ms of every manual run was this walk, done twice). The counter log is not shared, and the reason is worth a line: it is read here before the run registers the GCPM properties, and an unregistered `string-set` inherits, so a log taken now would assign every heading's string to its descendants too.
     const index = indexBlocks(blocks, undefined, undefined, keep);
     const fixed = staticValues(sites, { doc, blocks, index, keep });
@@ -573,6 +591,10 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
         }
         runs++;
         t = performance.now();
+        if (result.complete === false) { // a partial chain is not the document: its pages place only the targets cut so far, so the reservations stay hidden and the table it was laid out under stays the warm one
+            facts = laidFacts;
+            break;
+        }
         showReservations(doc); // the run is complete: what was reserved is delivered true on the next lines, or was true already
         const truth = pageValues(paged, result);
         unplaced = truth.unplaced;

package/dist/src/stonehand.js

@@ -283,6 +283,13 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         }
         return px;
     };
+    /** The rise a cut grants inside a table cell it divides: the cell's own nearest, the box included and the root not (a row item's rise is its row's, `rowPlan`). */
+    const liftIn = (box) => {
+        for (let p = box; p && p !== root; p = p.parent)
+            if (styleOfBox(p).display === 'table-cell')
+                return cellLift(w, p);
+        return 0;
+    };
     /** A box's bottom as a place in the procession: a row ends where its tallest item does, not where the item that happens to stand last in the source does. */
     const bottomOf = (box) => {
         const row = rowOf(box);
@@ -313,17 +320,19 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
             else if (item.rect.top >= h - eps)
                 plan.push({ item, state: 'below', verdict: null });
             else {
-                const [begins, reachesBelow] = contentSpanOf(w, item, h, eps);
+                // A cell the height divides sets its content from its own top on this page (`cellLift`), so its content is judged that much lower.
+                const lift = cellLift(w, item);
+                const [begins, reachesBelow] = contentSpanOf(w, item, h + lift, eps);
                 if (begins === null)
                     plan.push({ item, state: 'divided', verdict: null }); // holds nothing to show: a stretched box, divided by the geometry alone
-                else if (begins >= h - eps)
+                else if (begins >= h + lift - eps)
                     plan.push({ item, state: 'below', verdict: null }); // its content begins at or below the height: the break falls in the gap above it (§4.1's Class C, whatever made the gap — padding, an alignment), and the item resumes whole
                 else if (!reachesBelow)
                     plan.push({ item, state: 'done', verdict: null }); // all it has to show stands above the height; only its box reaches below, stretched by the row
                 else if (monolithic(item))
                     plan.push({ item, state: 'held', verdict: null }); // a monolith the height crosses resumes whole: the stated limit, as a float's (the item is the graphic, and nothing inside it is a place)
                 else {
-                    const v = flowVerdict(w, item, h, eps);
+                    const v = flowVerdict(w, item, h + lift, eps);
                     if (!v)
                         return null; // content crosses the height and the item offers no place above it: it shows nothing here
                     plan.push({ item, state: 'divided', verdict: v });
@@ -357,7 +366,7 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
                 candidates.push({
                     kind: 'A',
                     cls: 'A',
-                    y: bottomOf(anchor),
+                    y: bottomOf(anchor) - liftIn(box.parent),
                     docIndex,
                     box,
                     cost: clonedBlockEnd(box.parent), // the box itself goes whole to the next page; what this boundary breaks is its container and up
@@ -430,7 +439,7 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
             stats.gapMs += performance.now() - tg;
         if (gap) {
             const y = Math.min(gap.bottom, limit);
-            if (y - gap.base > eps) {
+            if (y - (gap.base - liftIn(box)) > eps) {
                 candidates.push({
                     kind: 'C',
                     cls: 'C',
@@ -485,11 +494,12 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         const orphans = parseInt(st.orphans, 10) || 1;
         const widows = parseInt(st.widows, 10) || 1;
         const window_ = classBWindow(T, orphans, widows);
+        const lift = liftIn(box);
         for (let k = 0; k < T - 1; k++) {
             out.push({
                 kind: 'B',
                 cls: 'B',
-                y: lines[k].bottom,
+                y: lines[k].bottom - lift,
                 docIndex,
                 box,
                 cost: clonedBlockEnd(box),
@@ -550,6 +560,18 @@ function subtreeOf(boxes, root) {
     }
     return out;
 }
+/**
+ * How far a table cell's content rises when a cut divides the cell: the distance from its content box's top to its first line or monolith. A cell's `vertical-align` places its content in the cell's whole height; Chromium's print aligns a divided cell's first fragment within that fragment instead (`FinalizeTableCellLayout`: *the fragment will start at the block-start edge* on a resumption, and the free space is the fragment's own), so content the alignment set below the cut stands above it once the cell is divided. The presentation matches it by pinning the divided cell's height to the page's foot. Zero for anything else, and for a cell aligned at its top.
+ *
+ * @remarks Under collapsed borders the content box is read with the cell's whole border width where half of it is used, so the rise is under by half a border, never over.
+ */
+function cellLift(w, cell) {
+    const st = w.styleOfBox(cell);
+    if (st.display !== 'table-cell')
+        return 0;
+    const [begins] = contentSpanOf(w, cell, -Infinity, 0);
+    return begins === null ? 0 : Math.max(0, begins - (cell.rect.top + (parseFloat(st.borderTopWidth) || 0) + (parseFloat(st.paddingTop) || 0)));
+}
 /** Where a flow's content stands against a height: where it begins (the top of its first line or monolith, null where it holds none) and whether any of it stands below the height — asked of the leaves that reach below it alone, so a flow of a thousand paragraphs above the foot costs the leaves it needs and not its line stacks (a leaf whose box ends above the height has every line above it too). */
 function contentSpanOf(w, root, h, eps) {
     let begins = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beltype/cicero",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Cicero, a paged-media engine for the live browser: it cuts a document into pages under CSS Paged Media and presents them as real frames. Beta.",
   "type": "module",
   "license": "MIT",