@beltype/cicero 0.1.6 → 0.1.7

package/dist/seam/index.js

@@ -26,11 +26,13 @@ import { WORDS_RULES } from '../src/data-beltype.js';
  *
  * The value is the addendum's own 1.65 rather than an invention, so on the one surface where it can actually cascade — the HTML lane, which ships no addendum — the engine's provision and BelType's default agree. Below `body` it is inert: the addendum's own `body` rule wins by proximity.
  *
+ * It is a floor, not an override, so it is written at zero specificity: `:where(:root)` still beats the browser's `normal`, which no stylesheet sets, and loses to any author rule on the root, a plain `html { font: 10pt/13.4pt serif }` among them. As `:root` (0,1,0) it beat that rule's (0,0,1) silently, and five of the six specimens printed at 1.65 instead of their declared leading (trattato: 220 pages for 189; Codeberg issue 4, 2026-11-07).
+ *
  * It is a literal here, and not a line in the linked sheet beside it, because a conformance provision that can 404 is not a provision. A missing sheet — a table entry lost in a refactor, a server restarted mid-edit — would arrive as `I5 (DPR ruling): explicit line-height required`, a law refusing on a typographic claim when the real fault is a missing file, sending the reader to their own stylesheet. Cicero's refusals are load-bearing because they are true; one that names the wrong thing spends that.
  *
  * Recorded as a beta limitation, because the check the law performs is at the root and this satisfies it there: a document whose deeper typography still relies on `normal` is outside what *render-identical conditions* (I5) can see.
  */
-const I5_PROVISION = ':root { line-height: 1.65; }';
+const I5_PROVISION = ':where(:root) { line-height: 1.65; }';
 /**
  * What the document says about a PDF `<object>` before the engine has met it (*the embedded PDF*, 2026-10-14; `seam/facsimile.js`).
  *

package/dist/src/capture.d.ts

@@ -137,7 +137,14 @@ export type ReachContext = {
     /** Whether any top-level box is not the one that stood in its place before. */
     changed: boolean;
 };
-/** A `size` descriptor's tokens → [widthPx, heightPx]. Handles lengths, named sizes, and orientation keywords. A `size` is resolved before either page dimension is known, so its lengths get a null percentage base and anything relative refuses by name (css-page-3 §7.1). */
+/** Is this `size` an orientation keyword and nothing else? Then it turns the sheet the cascade already gave ({@link sizeToPx}). */
+export declare const isOrientationOnly: (tokens: string[]) => boolean;
+/**
+ * A `size` descriptor's tokens → [widthPx, heightPx]. Handles lengths, named sizes, and orientation keywords. A `size` is resolved before either page dimension is known, so its lengths get a null percentage base, and a percentage refuses by name (css-page-3 §7.1).
+ *
+ * @remarks
+ * An orientation keyword turns whatever sheet stands beside it: `landscape` puts the longer side across, `portrait` down, for a named size and for a pair of lengths alike. §7.1 says a keyword alone means the UA's default sheet turned that way; this engine pins geometry (I5) and has no default sheet, so `pageFor` hands the keyword the sheet the cascade's less specific rule gave (the WPT print reftests' `@page :first { size: portrait }` on their 5 in by 3 in default), and a keyword with no such sheet refuses by name (Codeberg issue 10; until 2026-11-07 it refused as the length `undefined`).
+ */
 export declare function sizeToPx(tokens: string[], resolve: Resolve): [Px, Px];
 /**
  * A declared border width takes room only where the same side's style draws a border (*a page box has a border and a padding*, 2026-09-07).
@@ -180,6 +187,15 @@ export declare function assertPageArea({ contentW, contentH }: {
     contentW: Px;
     contentH: Px;
 }, where: string): void;
+/**
+ * Every `@page` rule the document wears, wherever it stands: at a sheet's top, or inside an `@layer`, a `@supports` or an `@media` that holds, or an imported sheet. `layered` loses to `unlayered`, as the cascade has it, whatever their order.
+ *
+ * @remarks ponytail: the layers keep their document order, not their declared order; a page rule that must win over another layer is unlayered, as BelType's own is.
+ */
+export declare function pageRulesOf(doc: Document): {
+    layered: CSSPageRule[];
+    unlayered: CSSPageRule[];
+};
 /**
  * Clear every author @page margin-box's own `content` declaration in the live CSSOM — never its `size`/`margin`, never anything outside a margin-at-rule. Called once the geometry table above has already read what it needs from these rules (the second channel a named page cannot close).
  *

package/dist/src/capture.js

@@ -531,11 +531,12 @@ function createLengthResolver(doc) {
             const fast = absoluteToPx(raw);
             if (fast !== null)
                 return fast;
-            if (basePx === null)
-                throw refuse(raw, where, 'a `size` descriptor is resolved before either page dimension exists, so only absolute lengths and the named sizes can be answered there (css-page-3 §7.1 gives `size` no percentage values at all)');
+            // A `size` is resolved before either page dimension exists, so it has no percentage base; css-page-3 §7.1 gives `size` no percentage values at all. Every other length the browser resolves is measured as a margin's is: an `em` resolves against the root's font, which the probe's wrapper wears (Codeberg issue 10; until 2026-11-07 every relative unit refused here).
+            if (basePx === null && raw.includes('%'))
+                throw refuse(raw, where, 'a `size` descriptor is resolved before either page dimension exists, and css-page-3 §7.1 gives `size` no percentage values at all');
             if (raw === 'auto')
                 throw refuse(raw, where, '`auto` on a page margin means UA-determined, and the probe would read it as a plain 0 — a number this engine would then lay out against as though the author had written one');
-            const px = measured(raw, basePx, prop);
+            const px = measured(raw, basePx ?? 0, prop);
             if (px === null)
                 throw refuse(raw, where, 'the browser resolves it to nothing — an unknown unit, a malformed value, or a custom property that is never declared');
             return px;
@@ -560,11 +561,20 @@ const SIZE_NAMES = {
     legal: [215.9, 355.6], // css-page-3 legal 8.5 × 14in; Chromium 215.90 × 355.60mm
     ledger: [279.4, 431.8] // css-page-3 ledger 11 × 17in; Chromium 279.40 × 431.80mm
 };
-/** A `size` descriptor's tokens → [widthPx, heightPx]. Handles lengths, named sizes, and orientation keywords. A `size` is resolved before either page dimension is known, so its lengths get a null percentage base and anything relative refuses by name (css-page-3 §7.1). */
+/** css-page-3 §7.1's two orientation keywords. */
+const ORIENTATIONS = new Set(['portrait', 'landscape']);
+/** Is this `size` an orientation keyword and nothing else? Then it turns the sheet the cascade already gave ({@link sizeToPx}). */
+export const isOrientationOnly = (tokens) => tokens.length === 1 && ORIENTATIONS.has(tokens[0].toLowerCase());
+/**
+ * A `size` descriptor's tokens → [widthPx, heightPx]. Handles lengths, named sizes, and orientation keywords. A `size` is resolved before either page dimension is known, so its lengths get a null percentage base, and a percentage refuses by name (css-page-3 §7.1).
+ *
+ * @remarks
+ * An orientation keyword turns whatever sheet stands beside it: `landscape` puts the longer side across, `portrait` down, for a named size and for a pair of lengths alike. §7.1 says a keyword alone means the UA's default sheet turned that way; this engine pins geometry (I5) and has no default sheet, so `pageFor` hands the keyword the sheet the cascade's less specific rule gave (the WPT print reftests' `@page :first { size: portrait }` on their 5 in by 3 in default), and a keyword with no such sheet refuses by name (Codeberg issue 10; until 2026-11-07 it refused as the length `undefined`).
+ */
 export function sizeToPx(tokens, resolve) {
-    const t = tokens.map((s) => s.toLowerCase()).filter((s) => s !== 'portrait');
-    const landscape = t.includes('landscape');
-    const rest = t.filter((s) => s !== 'landscape');
+    const t = tokens.map((s) => s.toLowerCase());
+    const orientation = t.find((s) => ORIENTATIONS.has(s)) ?? null;
+    const rest = t.filter((s) => !ORIENTATIONS.has(s));
     const where = 'a `size` descriptor';
     let w;
     let h;
@@ -574,10 +584,33 @@ export function sizeToPx(tokens, resolve) {
     else if (rest.length === 1) {
         w = h = resolve(rest[0], null, where);
     }
+    else if (rest.length === 0) {
+        throw refuse(orientation ?? '', where, 'an orientation keyword alone means the UA\'s default sheet turned that way, and this engine has none: declare the sheet in a less specific @page rule, or beside the keyword');
+    }
     else {
         [w, h] = [resolve(rest[0], null, where), resolve(rest[1], null, where)];
     }
-    return landscape ? [h, w] : [w, h];
+    if (orientation === 'landscape')
+        return [Math.max(w, h), Math.min(w, h)];
+    if (orientation === 'portrait')
+        return [Math.min(w, h), Math.max(w, h)];
+    return [w, h];
+}
+/**
+ * The root's custom properties substituted into a page-context value (css-page-3 §4.1: the page context inherits from the root element, so a `var()` there reads the root's value). The probe already inherits them for a longhand it seats, but a shorthand goes through `expandBox` before any probe, and `--margin: 20px 40px` must be split before it is seated (Codeberg issue 10, `page-context-inherits-from-root-custom-property`). A property the root does not declare takes the `var()`'s fallback, or stays as written for the probe to refuse by name.
+ */
+function substituteRootVars(doc, text) {
+    if (!text.includes('var('))
+        return text;
+    const root = doc.defaultView.getComputedStyle(doc.documentElement);
+    let out = text;
+    for (let i = 0; i < 8 && out.includes('var('); i++) {
+        const next = out.replace(/var\(\s*(--[\w-]+)\s*(?:,\s*([^()]*))?\)/g, (whole, name, fallback) => root.getPropertyValue(name).trim() || fallback?.trim() || whole);
+        if (next === out)
+            break;
+        out = next;
+    }
+    return out;
 }
 /**
  * What Cicero owns: the one criterion, and it is deliberately not a CSS opinion.
@@ -600,6 +633,12 @@ const AREA_PREFIXES = ['border', 'padding'];
 function ownedByCicero(prop) {
     return OWNED_EXACTLY.has(prop) || OWNED_PREFIXES.some((p) => prop.startsWith(p));
 }
+/**
+ * What the Chase owns on a margin cell, which is less than on the page host: a cell's `margin-*`, `border-*` and `padding-*` are the box's own (css-page-3 §5.3.2 distributes the boxes' outer widths, padding and border included, and `chase.js`'s `layoutBands` measures them on the cell), where the page box's are the geometry the capture models and the content area wears. Until 2026-11-07 the host's filter was applied to the boxes too, and `@top-left { padding-bottom: 5mm }` reached no cell (Codeberg issue 3). The `width` family stays withheld: §5.3.2's answer for a box that declares one is not built, and the cell's grid seat is the Chase's.
+ */
+function ownedOnCell(prop) {
+    return OWNED_EXACTLY.has(prop) || prop.startsWith('grid-template');
+}
 /** One declaration block's `border-*` and `padding-*` triples, in the block's own order — the page box's border and padding, which the Chase writes on the content area. Order and `!important` carried for the same reason `declarationsOf` carries them: they are the cascade. */
 function areaDeclarationsOf(style) {
     const out = [];
@@ -610,11 +649,11 @@ function areaDeclarationsOf(style) {
     }
     return out;
 }
-/** One declaration block as `[property, value, priority]` triples, in the block's own order, minus what Cicero owns. Order and `!important` are carried because they are the cascade: the triples are re-emitted into one rule, where later wins and important beats normal exactly as the author wrote them. */
-function declarationsOf(style) {
+/** One declaration block as `[property, value, priority]` triples, in the block's own order, minus what Cicero owns — on the page host by default, on a margin cell where `owned` is {@link ownedOnCell}. Order and `!important` are carried because they are the cascade: the triples are re-emitted into one rule, where later wins and important beats normal exactly as the author wrote them. */
+function declarationsOf(style, owned = ownedByCicero) {
     const out = [];
     for (const prop of style ?? []) {
-        if (ownedByCicero(prop))
+        if (owned(prop))
             continue;
         out.push([prop, style.getPropertyValue(prop), style.getPropertyPriority(prop)]);
     }
@@ -655,7 +694,7 @@ function marginBoxStylesOf(rule) {
         const name = (child.name ?? child.selectorText ?? '').replace(/^@/, '');
         if (!MARGIN_BOXES.includes(name))
             continue;
-        const decls = declarationsOf(child.style).filter(([prop]) => prop !== 'content');
+        const decls = declarationsOf(child.style, ownedOnCell).filter(([prop]) => prop !== 'content');
         if (decls.length)
             out[name] = decls;
     }
@@ -796,27 +835,57 @@ function marginBoxesOf(rule) {
     return out;
 }
 /**
- * Clear every author @page margin-box's own `content` declaration in the live CSSOM — never its `size`/`margin`, never anything outside a margin-at-rule. Called once the geometry table above has already read what it needs from these rules (the second channel a named page cannot close).
+ * Every `@page` rule the document wears, wherever it stands: at a sheet's top, or inside an `@layer`, a `@supports` or an `@media` that holds, or an imported sheet. `layered` loses to `unlayered`, as the cascade has it, whatever their order.
  *
- * Margin-box chrome is delivered exclusively as a shadow-DOM literal (chase.js's own note under *content is one document*, I6: "it does not live once, so it cannot live twice"), but the author's own @page rules stay linked in the document throughout — their non-page rules keep styling the light-DOM content, so the whole stylesheet can never simply be disabled. Once the press sheet (root.js) renames every `<beltype-page>` to a synthetic geometry name, no author rule with a page-name selector (`@page title`, `@page :left`, …) can be name-matched by the browser's own native cascade any more — only the bare, unnamed base rule still matches every page unconditionally, becoming a second, uncontrolled channel that paints the very same chrome the shadow DOM already delivers correctly. `cases/17-the-borrowed-dress` found this the hard way: a named page's `content: normal` override was honored inside the shadow DOM (confirmed by direct inspection) while the printed page still showed the un-overridden base string, painted by this exact channel. Clearing `content` closes it by construction, for every page, independent of the precise cascade mechanism that let it through.
+ * @remarks ponytail: the layers keep their document order, not their declared order; a page rule that must win over another layer is unlayered, as BelType's own is.
  */
-export function neutralizeMarginBoxes(doc) {
-    for (const sheet of styleSheetsOf(doc)) {
-        let rules;
+export function pageRulesOf(doc) {
+    const win = doc.defaultView;
+    const found = { layered: [], unlayered: [] };
+    const rulesOf = (sheet) => {
         try {
-            rules = sheet.cssRules;
+            return sheet.cssRules;
         }
         catch {
-            continue;
-        } // cross-origin sheet: not ours to touch
+            return [];
+        } // cross-origin sheet: not ours to read
+    };
+    const walk = (rules, inLayer) => {
         for (const rule of rules) {
-            if (!(rule instanceof doc.defaultView.CSSPageRule) || !rule.cssRules)
-                continue;
-            for (const child of rule.cssRules) {
-                const name = (child.name ?? child.selectorText ?? '').replace(/^@/, '');
-                if (MARGIN_BOXES.includes(name))
-                    child.style?.removeProperty('content');
+            if (rule instanceof win.CSSPageRule)
+                (inLayer ? found.layered : found.unlayered).push(rule);
+            else if (rule.constructor?.name === 'CSSLayerBlockRule')
+                walk(rule.cssRules, true);
+            else if (rule.constructor?.name === 'CSSSupportsRule') {
+                if (win.CSS?.supports?.(rule.conditionText))
+                    walk(rule.cssRules, inLayer);
+            }
+            else if (rule.constructor?.name === 'CSSMediaRule') {
+                if (win.matchMedia(rule.media.mediaText).matches)
+                    walk(rule.cssRules, inLayer);
             }
+            else if (rule.constructor?.name === 'CSSImportRule' && rule.styleSheet)
+                walk(rulesOf(rule.styleSheet), inLayer || rule.layerName != null);
+        }
+    };
+    for (const sheet of styleSheetsOf(doc))
+        walk(rulesOf(sheet), false);
+    return found;
+}
+/**
+ * Clear every author @page margin-box's own `content` declaration in the live CSSOM — never its `size`/`margin`, never anything outside a margin-at-rule. Called once the geometry table above has already read what it needs from these rules (the second channel a named page cannot close).
+ *
+ * Margin-box chrome is delivered exclusively as a shadow-DOM literal (chase.js's own note under *content is one document*, I6: "it does not live once, so it cannot live twice"), but the author's own @page rules stay linked in the document throughout — their non-page rules keep styling the light-DOM content, so the whole stylesheet can never simply be disabled. Once the press sheet (root.js) renames every `<beltype-page>` to a synthetic geometry name, no author rule with a page-name selector (`@page title`, `@page :left`, …) can be name-matched by the browser's own native cascade any more — only the bare, unnamed base rule still matches every page unconditionally, becoming a second, uncontrolled channel that paints the very same chrome the shadow DOM already delivers correctly. `cases/17-the-borrowed-dress` found this the hard way: a named page's `content: normal` override was honored inside the shadow DOM (confirmed by direct inspection) while the printed page still showed the un-overridden base string, painted by this exact channel. Clearing `content` closes it by construction, for every page, independent of the precise cascade mechanism that let it through.
+ */
+export function neutralizeMarginBoxes(doc) {
+    const { layered, unlayered } = pageRulesOf(doc);
+    for (const rule of [...layered, ...unlayered]) {
+        if (!rule.cssRules)
+            continue;
+        for (const child of rule.cssRules) {
+            const name = (child.name ?? child.selectorText ?? '').replace(/^@/, '');
+            if (MARGIN_BOXES.includes(name))
+                child.style?.removeProperty('content');
         }
     }
 }
@@ -943,47 +1012,37 @@ export function registerGcpmProperties(win) {
  */
 export function readGeometryTable(doc) {
     const rules = [];
-    for (const sheet of styleSheetsOf(doc)) {
-        let list;
-        try {
-            list = sheet.cssRules;
-        }
-        catch {
-            continue; // cross-origin sheet: not ours to capture
-        }
-        for (const rule of list) {
-            if (!(rule instanceof doc.defaultView.CSSPageRule))
-                continue;
-            const sel = parseSelector(rule.selectorText);
-            // The rule's own declaration block, never its serialized text: `rule.cssText` carries the nested margin boxes inside it, so a regex over it credits a folio's `margin-top` to the page and reads a running head's `font-size` as the page's `size` (a page rule reads its own declarations; the arithmetic is on the checklist, the case is `15-the-margin-box`). `size` is a descriptor rather than a property and is exposed here anyway — measured, not assumed.
-            const declared = (prop) => rule.style?.getPropertyValue(prop).trim() || null;
-            const size = declared('size')?.split(/\s+/) ?? null;
-            // Longhands only: the CSSOM has already expanded whatever shorthand was written, and re-expanding it here would re-implement the browser's own work.
-            //
-            // Except where it has expanded nothing. A shorthand carrying a `var()` is held in pending substitution — the block answers `margin` with the author's text and every one of `margin-top`…`margin-left` with the empty string — so reading longhands alone reports no declaration at all, and the page lays out against a default. That is not a plausible failure: measured 2026-09-09, `@page { margin: var(--outer) }` with `--outer: 12mm` composed against BelType's own inlined default of 20mm and against 0 in a bare document, both silently, and the case is `33-the-shorthand-the-cssom-cannot-expand`. So the shorthand is consulted only when all four longhands are empty, which is exactly the pending-substitution state and nothing else — the browser expands every shorthand it can, so a non-empty longhand means there is nothing here to do. `expandBox` hands back the author's raw values, which the resolver then seats and measures per side exactly as it does a longhand's; nothing about lengths is decided here.
-            //
-            // Its reach is one level: `border: 5px var(--style)` leaves `border-width` empty too, and that stays unread. Naming it rather than widening the door — a shorthand of shorthands is a second expansion with a second grammar, and no document has asked for it.
-            const perSide = (prefix, suffix = '') => {
-                const sides = { top: declared(`${prefix}-top${suffix}`), right: declared(`${prefix}-right${suffix}`), bottom: declared(`${prefix}-bottom${suffix}`), left: declared(`${prefix}-left${suffix}`) };
-                if (sides.top || sides.right || sides.bottom || sides.left)
-                    return sides;
-                const shorthand = declared(`${prefix}${suffix}`);
-                return (shorthand && expandBox(shorthand)) || sides;
-            };
-            rules.push({
-                sel,
-                size,
-                style: declarationsOf(rule.style),
-                area: areaDeclarationsOf(rule.style),
-                boxStyles: marginBoxStylesOf(rule),
-                margins: perSide('margin'),
-                // A border width's used value is zero unless a style is set, so the style is read beside the width and the two are accumulated separately — a `@page { border: 5px }` declares a width and no style, and takes no room at all.
-                borderWidths: perSide('border', '-width'),
-                borderStyles: perSide('border', '-style'),
-                paddings: perSide('padding'),
-                marginBoxes: marginBoxesOf(rule)
-            });
-        }
+    const { layered, unlayered } = pageRulesOf(doc);
+    for (const rule of [...layered, ...unlayered]) {
+        const sel = parseSelector(rule.selectorText);
+        // The rule's own declaration block, never its serialized text: `rule.cssText` carries the nested margin boxes inside it, so a regex over it credits a folio's `margin-top` to the page and reads a running head's `font-size` as the page's `size` (a page rule reads its own declarations; the arithmetic is on the checklist, the case is `15-the-margin-box`). `size` is a descriptor rather than a property and is exposed here anyway — measured, not assumed.
+        const declared = (prop) => rule.style?.getPropertyValue(prop).trim() || null;
+        const size = declared('size')?.split(/\s+/) ?? null;
+        // Longhands only: the CSSOM has already expanded whatever shorthand was written, and re-expanding it here would re-implement the browser's own work.
+        //
+        // Except where it has expanded nothing. A shorthand carrying a `var()` is held in pending substitution — the block answers `margin` with the author's text and every one of `margin-top`…`margin-left` with the empty string — so reading longhands alone reports no declaration at all, and the page lays out against a default. That is not a plausible failure: measured 2026-09-09, `@page { margin: var(--outer) }` with `--outer: 12mm` composed against BelType's own inlined default of 20mm and against 0 in a bare document, both silently, and the case is `33-the-shorthand-the-cssom-cannot-expand`. So the shorthand is consulted only when all four longhands are empty, which is exactly the pending-substitution state and nothing else — the browser expands every shorthand it can, so a non-empty longhand means there is nothing here to do. `expandBox` hands back the author's raw values, which the resolver then seats and measures per side exactly as it does a longhand's; nothing about lengths is decided here.
+        //
+        // Its reach is one level: `border: 5px var(--style)` leaves `border-width` empty too, and that stays unread. Naming it rather than widening the door — a shorthand of shorthands is a second expansion with a second grammar, and no document has asked for it.
+        const perSide = (prefix, suffix = '') => {
+            const sides = { top: declared(`${prefix}-top${suffix}`), right: declared(`${prefix}-right${suffix}`), bottom: declared(`${prefix}-bottom${suffix}`), left: declared(`${prefix}-left${suffix}`) };
+            if (sides.top || sides.right || sides.bottom || sides.left)
+                return sides;
+            const shorthand = declared(`${prefix}${suffix}`);
+            return (shorthand && expandBox(substituteRootVars(doc, shorthand))) || sides;
+        };
+        rules.push({
+            sel,
+            size,
+            style: declarationsOf(rule.style),
+            area: areaDeclarationsOf(rule.style),
+            boxStyles: marginBoxStylesOf(rule),
+            margins: perSide('margin'),
+            // A border width's used value is zero unless a style is set, so the style is read beside the width and the two are accumulated separately — a `@page { border: 5px }` declares a width and no style, and takes no room at all.
+            borderWidths: perSide('border', '-width'),
+            borderStyles: perSide('border', '-style'),
+            paddings: perSide('padding'),
+            marginBoxes: marginBoxesOf(rule)
+        });
     }
     if (!rules.length)
         throw new Error('no @page rule found — the corpus and the venue always pin geometry (I5)');
@@ -1021,7 +1080,7 @@ export function readGeometryTable(doc) {
         const pageStyle = { host: [], cell: [], area: [], boxes: {} };
         for (const r of applicable) {
             if (r.size)
-                size = r.size;
+                size = isOrientationOnly(r.size) && size ? [...size.filter((t) => !ORIENTATIONS.has(t.toLowerCase())), ...r.size] : r.size; // a keyword alone turns the sheet the cascade gave (`sizeToPx`)
             for (const side of SIDES) {
                 if (r.margins[side] != null)
                     margins[side] = r.margins[side];

package/dist/src/chase.js

@@ -153,6 +153,7 @@ export class BeltypePage extends HTMLElement {
         for (const [band, row] of [['top', 1], ['bottom', 5]]) {
             const el = doc.createElement('div');
             el.className = 'band';
+            el.setAttribute('aria-hidden', 'true'); // pagination furniture is never read (*an artifact is never read*)
             el.dataset.band = band;
             el.style.gridArea = `${row} / 2 / ${row + 1} / 5`;
             this.#bands[band] = el;
@@ -161,6 +162,7 @@ export class BeltypePage extends HTMLElement {
         for (const [name, row, col] of MARGIN_CELLS) {
             const cell = doc.createElement('div');
             cell.className = 'margin-cell';
+            cell.setAttribute('aria-hidden', 'true');
             cell.dataset.box = name;
             const band = Object.keys(HORIZONTAL_BANDS).find((b) => HORIZONTAL_BANDS[b].includes(name));
             if (band) {

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

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

package/dist/src/document-state.js

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

package/dist/src/driver.d.ts

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