@beltype/cicero 0.1.6 → 0.1.8

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

@@ -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>;
 /**
@@ -137,7 +141,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 +191,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

@@ -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();
@@ -531,11 +536,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 +566,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 +589,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 +638,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,16 +654,46 @@ 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)]);
     }
     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.
  *
@@ -655,7 +729,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 +870,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 +1047,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)');
@@ -992,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);
         }
     }
@@ -1021,7 +1115,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];
@@ -1055,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

@@ -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/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 an `<ol>` that runs onto a second page numbers its items from 1 there (measured 2026-11-07, `<ol reversed>` and a `counter-set` of `list-item` likewise); css-lists-3's `reversed()` counters; and a top-level `position: fixed` box, which is not among the flow blocks the position index is built over. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
  *
  * @packageDocumentation
  */
@@ -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,6 +135,46 @@ 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, with an element's reset of the page counter counted on from the page it begins on, and the page context's own `counter-reset`, `counter-increment` and `counter-set` applied as Chromium's print applies them.
+ *
+ * @remarks
+ * css-page-3 names a reset of the page counter only in the page context, but an author writes `counter-reset: page 1` on a chapter or on each letter of a print run to number its pages from one, and once the engine applies it the pages after must count on from there rather than stay at the value (Codeberg issue 1). The page counter is the page's own, reset on the host as `page N` (`chase.js`'s `setCounters`), so the reset is folded into N here and never delivered as an author counter: delivered, it reset the flow and the margin cells to the same value on every later page in the reset's scope. `target-counter()` to a page reads the same N (`reads.js`'s `pageValues`), so a reference answers the value the counter has at its target (Codeberg issue 2).
+ *
+ * The last `counter-reset` or `counter-set` of `page` at or before `pos` is the one in force: **at**, not strictly before, because the element that begins on the page is the one that numbers it, where an author counter's reset waits for the next page (css-page-3 §6.1 is about author counters). Scope is not replayed, since the page counter has one instance: a reset stands until the next one, whatever the depth of either. A reset on an element that begins mid-page numbers the next page.
+ *
+ * **A blank page the engine makes to bring the element to its side begins where the element does and stands before it** (Codeberg issue 13): the reset is not in force on it, so it continues the count it stands in, and it is not counted toward the pages after it, so the element's page bears the value. A blank page inside the scope, after the element began, counts as every page does.
+ *
+ * **The page context's rules are the page box's, and each page box is its own scope.** Measured 2026-11-07 on Chromium's print (`test/browser/page-context-counters.browser.ts`): every page adds its `counter-increment` of `page`, or 1 where none is declared, to the count the pages carry; a `counter-set` sets that count, and the pages after count on from it (`@page :first { counter-set: page 7 }` prints 7, 8, 9); a `counter-reset` opens a counter of the page box's own, so the page prints the reset value plus that page's own declared increment and the pages after continue the count as though it had not been there (`@page :first { counter-reset: page 10 }` prints 10, 1, 2, and with `@page { counter-increment: page 2 }` beside it 12, 2, 4). An element's reset is applied to the count before the page's own rules, and the page it begins on takes no implicit increment. Until 2026-11-07 these declarations reached the page host as author style, where `counter-increment: page 2` added to the host's `page N` and the host's inline reset hid every `@page` reset: 3, 4, 5 for Chromium's 7, 2, 4.
+ *
+ * @param pages - each page before `pageIndex`, by index: its first word position, whether it is blank, and its page context's rules.
+ * @param blank - whether page `pageIndex` is one the engine made blank.
+ * @param counter - page `pageIndex`'s page context's rules.
+ * @param away - the remainders the page's opening cut carries in, as for {@link counterStateAt}.
+ */
+export 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;
+    }>;
+}): 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.
  *