@beltype/cicero 0.1.5 → 0.1.7

package/dist/seam/client.d.ts

@@ -110,6 +110,15 @@ export declare function run(opts?: {
         laid: number;
     } | null;
 }>;
+/**
+ * Let go of everything this client registered in the page, so a document that replaces it (`document.open()` keeps the `Window`, its `FontFaceSet` and its listeners) is not answered by this one's.
+ *
+ * It removes the `loadingdone` listener, stops the rim, drops the batch of late truth waiting to be answered and deletes the handle from the window, all before the first `await`. A run stopped at a page is let go and its pages stay on screen. A run under way with a pace (`until`) rejects with the let-go error at its next page, and a first run that has shown nothing puts the document back as it found it; one without a pace finishes and presents. When nothing is under way, the promise resolves, after the root's idle build, observer and window listeners and the facsimile's observer have been let go. A `run()` made afterwards is rejected by name. Calling it again is a no-op.
+ *
+ * @remarks **Host obligations.** The custom-element registry belongs to the window and is not released: the next document's `<beltype-root>`, `<beltype-page>` and PDF element are built from the classes this module defined, which keep no state about the document they were defined for. The handle is gone, and the next client module runs only under a URL the window has not imported (measured 2026-11-03: the same URL after `document.open()` does not run again, a keyed one does, and a second `customElements.define` of a name throws, which the three definitions guard against). The host keys the URL.
+ * @see SPEC.md Article XII.7
+ */
+export declare function release(): Promise<void>;
 /** THE HANDLE — `window.__beltypeCicero`, the host's one door onto the engine in the page. The calls are set at load; the doors onto the presentation are seated by every presentation ({@link seatDoors}), so they are absent before the first; `last` and `ledger` are the last run's. */
 export type Handle = {
     run: typeof run;
@@ -135,5 +144,6 @@ export type Handle = {
     addressOf?: (el: Element, word?: number) => Address | null;
     box?: (i: number) => Element | null;
     patch?: typeof patchBox;
+    release: typeof release;
 };
 export {};

package/dist/seam/client.js

@@ -65,8 +65,11 @@ let fontEpoch = 0;
 /** The document's face set, kept: it is the same object for the life of the document, and a test that watches how often the engine asks the document for it (progressive.test.js) counts the intake's and the driver's asks and no others. */
 const fonts = document.fonts;
 knowLoadedFaces(fonts);
-fonts.addEventListener('loadingdone', (event) => { if (bringsNewFace(event))
-    fontEpoch++; });
+const countFaces = (event) => { if (bringsNewFace(event))
+    fontEpoch++; };
+fonts.addEventListener('loadingdone', countFaces);
+/** Set by {@link release}: this module instance is finished with its document, and answers no more. A flag of this instance, never of the classes it defined, which the next document's module scripts inherit from the window. */
+let released = false;
 /**
  * The run's conditions, as one string (*a break decision is valid only under render-identical conditions* (I5), applied to the memo — Decision one of *the run resumes from an entry*): the measuring realm's media environment — the viewport, the device pixel ratio, the colour scheme — the text of the stylesheets the document wears, as the rewrite and the presentation left them (the document's own: a sheet inside an `<svg>` or inside a copy the engine made is a box's, and what it changes is that box's extent, which the rim hears — *the conditions are the sheets of the document*, 2026-10-22), and the font epoch the run began under, and how many presenters are registered (*a copy may be presented*: a presenter is a condition of every copy, and a registration after a run is seen here as the change it is). The delivered read values are the driver's to compare, not this string's. Taken after a presentation and again before the next run, so the two readings see the same engine litter (the press `<style>` is left out) and a difference between them is the host's own.
  * @param epoch - {@link fontEpoch} as the run began, which is not the count at the moment of asking: a face that arrived during the run must show at the next one.
@@ -152,15 +155,16 @@ function patchBox(index, path, el) {
         boxes[index] = el;
     }
     rim?.add(boxes[index], top); // the replacement may hold a picture still loading, or an element not yet defined
-    const address = window.__beltypeCicero.addressOf(el);
+    const address = handle.addressOf(el);
     if (address)
         edited.push(address);
     return address;
 }
 /** THE RIM, from the intake until the frame lets the run go (`rim.js`, *late truth is an edit*): the subscription to the facts that arrive after a measure. `null` before the intake. */
 let rim = null;
+function stopRim() { rim?.stop(); rim = null; }
 /**
- * The rim's default action (*late truth is an edit*, Decision four, 2026-10-13): what a signal the host did not cancel does. Signals are coalesced over one animation frame into one batch; a batch that holds a font is one whole run (a face is a condition of every box), and any other — an image, an element, a store's write, a box's size — is one `run({ resumeAt })` per box, the earliest in the document first and one at a time, since convergence is believed past one edited box. A signal that arrives while a run is under way waits for it; a run stopped at a page is let go and the answer stays within the pages it had cut, as an edit's does. The runs go through the host's own door, `window.__beltypeCicero.run`, so a host that wraps it sees the rim's runs as it sees its own.
+ * The rim's default action (*late truth is an edit*, Decision four, 2026-10-13): what a signal the host did not cancel does. Signals are coalesced over one animation frame into one batch; a batch that holds a font is one whole run (a face is a condition of every box), and any other — an image, an element, a store's write, a box's size — is one `run({ resumeAt })` per box, the earliest in the document first and one at a time, since convergence is believed past one edited box. A signal that arrives while a run is under way waits for it; a run stopped at a page is let go and the answer stays within the pages it had cut, as an edit's does. The runs go through the host's own door, the `run` property of the handle object this module put on the window, read at each call, so a host that replaces that property (the essay's init scripts and tests do) sees the rim's runs as it sees its own. A host that replaces the whole object `window.__beltypeCicero` does not: the rim keeps calling this module's own handle (so a client that was released, or one a newer client replaced, never reaches into the next document's), and nothing in the repositories searched does that.
  *
  * A box heard through a piece a page draws it with (*a fragment announces its own size*, 2026-10-22) carries the page it was heard on, and its resume is at the address that page begins at, the earliest such page; every other box carries `null` and is resumed at its own address.
  */
@@ -200,13 +204,13 @@ async function lateTruth() {
     while (batch) {
         const { font, boxes } = batch;
         batch = null;
-        const h = window.__beltypeCicero;
+        const h = handle;
         try {
             /** One step, after any run under way has ended; `null` where the run before left nothing to answer. */
             const ready = async () => {
                 while (live && !live.gate)
                     await live.finished;
-                return previous?.composed ?? null;
+                return released ? null : previous?.composed ?? null;
             };
             if (font) {
                 const composed = await ready();
@@ -269,6 +273,8 @@ function reached(session) {
 /** The driver's `pace`: called after every page of the first layout. It stops the run where the host asked it to stop — by returning a promise the next call releases — and otherwise lets it go on without a pause. */
 function pacer(session, progress) {
     session.progress = progress;
+    if (session.cancelled)
+        return Promise.reject(LET_GO); // a run released while it measures stops at its next page
     if (!reached(session))
         return undefined;
     return new Promise((resolve, reject) => {
@@ -324,8 +330,7 @@ async function takeIntake(relaxDpr) {
             for (const [el, parent, next] of moved.toReversed())
                 parent?.insertBefore(el, next);
             root.remove();
-            rim?.stop();
-            rim = null;
+            stopRim();
             presented = null;
         }
     };
@@ -354,7 +359,7 @@ async function cutTo(el) {
     if (!session)
         return;
     if (session.gate)
-        await window.__beltypeCicero.run({ composed: session.composed, until: el });
+        await handle.run({ composed: session.composed, until: el });
     else
         await session.finished;
 }
@@ -407,7 +412,7 @@ function show(session, { account, index, total, from, to, resume }) {
 /** The host's doors onto the presentation, seated on the handle after every presentation (*the engine answers the page*, 2026-09-04; beltype#19, beltype#20). A verb, never the index: the tokenization stays in the realm it is checked in, and a verb survives the parked horizon of the engine leaving this realm where an exposed index holding live DOM references would not. */
 function seatDoors(blocks) {
     const { root } = presented;
-    const h = window.__beltypeCicero;
+    const h = handle;
     h.pageOf = (el, charOffset = 0) => root.pageOf(el, charOffset);
     // The windowing's doors (*only the pages near the reader are built*, 2026-10-12): the pages near the reader are built with the presentation and the rest as the reader nears them or the browser is idle, so a host about to read a page asks for it first. `reveal` builds the page that begins a source element and scrolls its drawn copy into view; `buildPage` builds one page; `buildAll` builds every page and is awaited by whoever reads them all (the printer, a gate); `built` says how many pages have their content.
     h.reveal = (el, options) => root.reveal(el, options);
@@ -452,6 +457,8 @@ function seatDoors(blocks) {
  * @returns what the console line reports; the presented pages stay live in the DOM. `pages` is how many are cut; `complete` whether that is the document's end. `resumed` names the pages cut again, from 1: `from` through `to`, with `shift` the pages the run added (or, negative, removed) and `kept` the prior pages after `to` left standing. `why` is a plain sentence, set exactly when `resumed` is `null`: the first run on a frame, no `resumeAt`, another mode, conditions that moved (and which part), a block count that moved, or a reference whose page number sent the run round again. `composition` is the composed mode's count (`null` in the default): `misses` the paragraphs composed, `hits` the ones found already composed, `blocks` their sum, and `laid` the top-level blocks cloned and measured to read their widths (the rest were answered by the cache whole).
  */
 export function run(opts) {
+    if (released)
+        return Promise.reject(new Error('BelType/Cicero: this client was released; the next document loads its own'));
     const call = runOnce(opts);
     calls.add(call);
     const answered = () => calls.delete(call);
@@ -543,12 +550,14 @@ async function runOnce({ composed = false, resumeAt = null, until = null, layer
         ...(target != null ? { pace: (progress) => pacer(session, progress) } : {})
     });
     live = session;
+    if (released)
+        session.cancelled = true; // called before the release, so the first page it cuts is its last
     return settle(session, t0);
 }
 async function carryOn(session, until, t0) {
     session.target = until;
     if (reached(session))
-        return window.__beltypeCicero.last; // already cut as far as it is asked
+        return handle.last; // already cut as far as it is asked
     dress(false);
     presented.root.hold();
     const settled = settle(session, t0);
@@ -569,6 +578,8 @@ async function settle(session, t0) {
     catch (error) {
         if (live === session)
             live = null;
+        if (error === LET_GO && released && !session.partial && session.fresh)
+            presented?.undo(); // a first run released before it showed a page
         if (error !== LET_GO) {
             forcingMemo.clear(); // a run that threw filled it with reads no one vouched for
             if (!session.partial && session.fresh)
@@ -596,11 +607,11 @@ async function settle(session, t0) {
         edited.splice(0, session.taken);
         session.taken = 0;
         compositionCache.conditions = conditions;
-        window.__beltypeCicero.last = { ...answerOf(session, t0, progress, resumed), complete: false };
-        window.__beltypeCicero.ledger = progress.account;
+        handle.last = { ...answerOf(session, t0, progress, resumed), complete: false };
+        handle.ledger = progress.account;
         console.info(`BelType/Cicero: ${k} pages cut so far, in ${Math.round(performance.now() - t0)} ms — the run is stopped at a page and goes on when asked`);
         await reloadKnownFaces(); // the presentation re-created a layered frame's faces, and the next slice measures in them
-        return window.__beltypeCicero.last;
+        return handle.last;
     }
     // Complete: the run reached the document's end.
     const result0 = outcome.result;
@@ -633,9 +644,9 @@ async function settle(session, t0) {
     session.taken = 0;
     compositionCache.conditions = conditions; // the reading after the presentation, which is the one the next call sees (the first call's was taken before there was any litter to leave out)
     // A host embedding this document (the editing tools' preview iframe, same-origin) reads its own render condition here rather than the devtools console nobody opens — set before returning, on the same handle the bootstrap already holds.
-    window.__beltypeCicero.last = result;
+    handle.last = result;
     // The run's Ledger itself, beside the summary and not inside it: `last` is read across frames and serialised by hosts, and the account holds live `box` pointers that no host should be handed by accident. A venue test reads it in-page to compare two runs entry by entry (*the run resumes from an entry*).
-    window.__beltypeCicero.ledger = account;
+    handle.ledger = account;
     if (live === session)
         live = null;
     // The presentation re-created a layered frame's faces, and a host reads the pages next: their loads are STARTED here and not awaited, so they are `loading` (and `document.fonts.ready` waits for them) by the time the call answers. Awaiting them put a task between the presentation and the answer, and a host that puts the caret back when the run answers (the studio experiment) lost a keystroke typed in that gap: the browser had no caret to type at, and fired no beforeinput.
@@ -654,5 +665,36 @@ function answerOf(session, t0, progress, resumed) {
         composition: session.composed ? { blocks: compositionCache.hits + compositionCache.misses, hits: compositionCache.hits, misses: compositionCache.misses, laid: compositionCache.laid } : null
     };
 }
-window.__beltypeCicero = { run, present,
+// The shell's bootstrap reaches the engine through this handle. Setting it is the module's only load-time effect — rendering waits to be asked, because the bootstrap knows when the document has stopped changing and this module does not. `pageOf` is seated by `run()` rather than here: before a presentation there is no page to answer, and a stub that answered `null` for that reason would be indistinguishable from the refusals that mean something.
+// `compositionCache` is the harness's door and the product's none: a venue test clears it to ask for a cold composition in a frame that has composed before, which is the only way a resumed run can be compared with a fresh one that did not borrow its records.
+// `forcingMemo` and `forgetJudgedSheets` are the same kind of door, for the same comparison: a venue test empties them to ask what a run costs, and what it cuts, when it borrows nothing from the runs before it (*the forced-break index is kept across runs*).
+// `present` is the host's say over what a copy of an element is (*a copy may be presented*, `src/presenters.js`): `present(selector, make)`, registered before the first run. One registered after a run changes the conditions key, so the next call is a whole run on a presented frame — nothing a presenter touched is reused — and a run stopped at a page goes on under the presenters it began with, its pages already built keeping the elements they were built with.
+// `measured` is the same kind of door again (*a box announces its own size*): a venue test asks what height the last run measured for a top-level box, the number the `size` kind compares a presented box's observed size with.
+// `table` is the geometry the intake captured from the author's `@page` rules, margin boxes and their `content` included, or null before an intake: the root clears every margin box's `content` from the CSSOM when it presents, so a second host in the same document, whose pages are not the root's, cannot read a table of its own from the sheets and takes this one (see CHANGELOG 2026-10-28).
+/**
+ * Let go of everything this client registered in the page, so a document that replaces it (`document.open()` keeps the `Window`, its `FontFaceSet` and its listeners) is not answered by this one's.
+ *
+ * It removes the `loadingdone` listener, stops the rim, drops the batch of late truth waiting to be answered and deletes the handle from the window, all before the first `await`. A run stopped at a page is let go and its pages stay on screen. A run under way with a pace (`until`) rejects with the let-go error at its next page, and a first run that has shown nothing puts the document back as it found it; one without a pace finishes and presents. When nothing is under way, the promise resolves, after the root's idle build, observer and window listeners and the facsimile's observer have been let go. A `run()` made afterwards is rejected by name. Calling it again is a no-op.
+ *
+ * @remarks **Host obligations.** The custom-element registry belongs to the window and is not released: the next document's `<beltype-root>`, `<beltype-page>` and PDF element are built from the classes this module defined, which keep no state about the document they were defined for. The handle is gone, and the next client module runs only under a URL the window has not imported (measured 2026-11-03: the same URL after `document.open()` does not run again, a keyed one does, and a second `customElements.define` of a name throws, which the three definitions guard against). The host keys the URL.
+ * @see SPEC.md Article XII.7
+ */
+export async function release() {
+    if (released)
+        return;
+    released = true;
+    fonts.removeEventListener('loadingdone', countFaces);
+    stopRim();
+    batch = null;
+    if (window.__beltypeCicero === handle)
+        delete window.__beltypeCicero;
+    await Promise.allSettled([...calls]); // a call made before the release has no session yet: it gets one, cancelled, in `runOnce`
+    if (live)
+        await letGo();
+    stopRim(); // the intake of a call that was under way made one after the first stop
+    presented?.root.dispose(); // last, so a presentation that finished above does not arm what it just let go
+    facsimile?.dispose();
+}
+const handle = { run, present, release,
     settled, compositionCache, forcingMemo, forgetJudgedSheets: () => { judgedSheets = new WeakMap(); }, measured: (el) => previous?.result.heights?.get(el), get table() { return presented?.table ?? null; } };
+window.__beltypeCicero = handle;

package/dist/seam/facsimile.d.ts

@@ -38,6 +38,8 @@ export declare function locate(source: Element): {
  * @remarks The element has no child until {@link draw} gives it its canvas (*a facsimile's copy holds its box off screen*, CHANGELOG 2026-10-28). An `<object>` with a child and no `data` decides at its first layout to render the child, which is a reattach of its layout tree, and on a page the browser skips (`content-visibility: auto`, *a page is contained*) a read from script lays the subtree out for the length of the read, drops the reattach when it puts the subtree back, and leaves the copy with no box at all. Measured 2026-10-28: the same copy with no child keeps its box on every read.
  */
 export declare function make(source: Element): HTMLObjectElement;
+/** Let go of the observer, which the next element to connect makes again: the element's class is the window's and outlives the client that defined it. */
+export declare function dispose(): void;
 /**
  * Define the element, read the size of every page the document embeds and register the presenter — before the first run (the intake calls this first, and awaits it), because a presenter is a condition of every copy and a registration after a run is a whole run.
  *

package/dist/seam/facsimile.js

@@ -165,6 +165,8 @@ const watcher = () => seen ??= new IntersectionObserver((entries) => {
             draw(entry.target);
         }
 }, { rootMargin: '300px' });
+/** Let go of the observer, which the next element to connect makes again: the element's class is the window's and outlives the client that defined it. */
+export function dispose() { seen?.disconnect(); seen = null; }
 /** The drawn page, at the box's width. The canvas takes the page's own ratio and the CSS says how it sits (`object-fit: contain`, in the box the author sized). */
 async function draw(el) {
     if (!el.isConnected || el.closest('#__beltype-measure'))

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) {