@beltype/cicero 0.1.10 → 0.1.12

package/dist/src/gauge.js

@@ -193,6 +193,28 @@ export function takeReport(container, { contentHeight }) {
             for (const item of row)
                 rowOfBox.set(item, row);
     }
+    /**
+     * A cell spanning rows (`rowspan`) stands beside the cells of every row it spans, so the cells of those rows are one row of parallel flows, in document order: a cut through the second spanned row divides the spanning cell and that row's cells, each at its own verdict, and leaves the rows above it spent and the rows below it whole, as Chromium prints it (CSS 2.1 §17.5.3; css-break-3 §2.1; the essay's case 92, *the cell that spans the cut*). A span stays inside its row group, as §17.2 says.
+     */
+    for (const box of boxes) {
+        const trs = box.blockChildren.filter((c) => !c.anonymous && win.getComputedStyle(c.el).display === 'table-row');
+        for (let i = 0; i < trs.length; i++) {
+            let end = i;
+            for (let j = i; j <= end; j++) {
+                for (const cell of trs[j].blockChildren) {
+                    const span = cell.el.rowSpan ?? 1;
+                    end = Math.min(trs.length - 1, Math.max(end, span === 0 ? trs.length - 1 : j + span - 1));
+                }
+            }
+            if (end === i)
+                continue;
+            const row = trs.slice(i, end + 1).flatMap((tr) => tr.blockChildren.filter((c) => !['absolute', 'fixed'].includes(win.getComputedStyle(c.el).position)));
+            if (row.length > 1)
+                for (const item of row)
+                    rowOfBox.set(item, row);
+            i = end;
+        }
+    }
     const topLevel = boxes.filter((b) => !b.parent);
     const contentTop = topLevel.length ? topLevel[0].rect.top : 0;
     let flowBottom = contentTop;

package/dist/src/gcpm-encoding.d.ts

@@ -23,6 +23,8 @@ export type ContentFn = {
 export declare const STRING_SET_PROP = "--beltype-string-set";
 /** `position: running(head)` survives as this custom property, holding the identifier alone. */
 export declare const RUNNING_PROP = "--beltype-running";
+/** `hyphenate-limit-lines` survives as this custom property, its value text carried verbatim (Chromium drops the property, so the Compositor reads the author's limit from here). It inherits, as the original does, and so is not among {@link CUSTOM_PROPS}. */
+export declare const HYPHENATE_LIMIT_LINES_PROP = "--beltype-hyphenate-limit-lines";
 /** Both, for a host that registers them. `syntax: '*'` because the values are the author's own text and this engine is not their grammar; `inherits: false` because neither original inherits. */
 export declare const CUSTOM_PROPS: string[];
 /**

package/dist/src/gcpm-encoding.js

@@ -13,6 +13,8 @@
 export const STRING_SET_PROP = '--beltype-string-set';
 /** `position: running(head)` survives as this custom property, holding the identifier alone. */
 export const RUNNING_PROP = '--beltype-running';
+/** `hyphenate-limit-lines` survives as this custom property, its value text carried verbatim (Chromium drops the property, so the Compositor reads the author's limit from here). It inherits, as the original does, and so is not among {@link CUSTOM_PROPS}. */
+export const HYPHENATE_LIMIT_LINES_PROP = '--beltype-hyphenate-limit-lines';
 /** Both, for a host that registers them. `syntax: '*'` because the values are the author's own text and this engine is not their grammar; `inherits: false` because neither original inherits. */
 export const CUSTOM_PROPS = [STRING_SET_PROP, RUNNING_PROP];
 /**

package/dist/src/measure.d.ts

@@ -14,7 +14,9 @@ export type MeasureContext = ReturnType<typeof createMeasureContext>;
  *
  * A vertical or sideways root is refused by name too (Codeberg issue 12): every read in this engine is horizontal, the lines by vertical overlap, the cut by a y, the page area by its height, so under `writing-mode: sideways-lr` on the root the text of a positioned paragraph fell below the clip and was never resumed, and the printer's tiling invariant refused what the engine should have. Vertical writing is outside the beta, and a refusal that says so at intake is cheaper than one three tools later.
  *
- * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, a document root whose line-height is not explicit (*render-identical conditions*, I5), or a document root whose writing mode is not `horizontal-tb`.
+ * A right-to-left root or body (`direction: rtl`) is refused by name as well, as out of scope (SPEC II.1, item 6); a vertical box below the root is refused by `readScope` (`src/scope.ts`).
+ *
+ * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, a document root whose line-height is not explicit (*render-identical conditions*, I5), a document root whose writing mode is not `horizontal-tb`, or a root or body that computes `direction: rtl`.
  */
 export declare function assertRenderConditions(doc: Document, { relaxDpr }?: {
     relaxDpr?: boolean;

package/dist/src/measure.js

@@ -17,7 +17,9 @@ const NEUTRALIZE_ID = '__beltype-neutralize';
  *
  * A vertical or sideways root is refused by name too (Codeberg issue 12): every read in this engine is horizontal, the lines by vertical overlap, the cut by a y, the page area by its height, so under `writing-mode: sideways-lr` on the root the text of a positioned paragraph fell below the clip and was never resumed, and the printer's tiling invariant refused what the engine should have. Vertical writing is outside the beta, and a refusal that says so at intake is cheaper than one three tools later.
  *
- * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, a document root whose line-height is not explicit (*render-identical conditions*, I5), or a document root whose writing mode is not `horizontal-tb`.
+ * A right-to-left root or body (`direction: rtl`) is refused by name as well, as out of scope (SPEC II.1, item 6); a vertical box below the root is refused by `readScope` (`src/scope.ts`).
+ *
+ * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, a document root whose line-height is not explicit (*render-identical conditions*, I5), a document root whose writing mode is not `horizontal-tb`, or a root or body that computes `direction: rtl`.
  */
 export function assertRenderConditions(doc, { relaxDpr = false } = {}) {
     const win = doc.defaultView;
@@ -29,6 +31,10 @@ export function assertRenderConditions(doc, { relaxDpr = false } = {}) {
     if (!/^-?[\d.]+px$/.test(lh)) {
         throw new Error(`I5 (DPR ruling): explicit line-height required, document root computes '${lh}'`);
     }
+    const rtl = [root, doc.body ? win.getComputedStyle(doc.body) : null].find((st) => st?.direction === 'rtl');
+    if (rtl) {
+        throw new Error(`right-to-left text is outside this engine's scope: the document computes direction 'rtl' on its ${rtl === root ? 'root' : 'body'}, and every read here is left to right (the line's start edge, the hanging of a margin, the page's left and right). Write the document ltr, or print it with another engine.`);
+    }
     if (root.writingMode && root.writingMode !== 'horizontal-tb') {
         throw new Error(`a vertical or sideways root is outside this engine's beta: the document root computes writing-mode '${root.writingMode}', and every read here is horizontal (the line by vertical overlap, the cut by a y). Write the document horizontal-tb, or print it with another engine.`);
     }
@@ -114,12 +120,32 @@ export async function awaitCloneImages(container) {
             unsettled = true;
             break;
         }
-    if (!unsettled)
+    const objects = objectsFetching(container);
+    if (!unsettled && !objects.length)
         return false;
-    await awaitImages(container);
+    await Promise.all([unsettled ? awaitImages(container) : null, ...objects]);
     void container.offsetHeight;
     return true;
 }
+/**
+ * The clones' `<object>` elements that fetch their `data`, each as a promise of its `load` or `error`. A copy of an `<object>` fetches its data again and is 0 by 0 until the fetch answers, and only then does it show its resource or its fallback content (measured 2026-11-09: a copy of an object whose data fails measured 0 px in the turn it was mounted, 150 px at its `error` and 700 px, its fallback's height, one task later). Measured early, an object whose fallback is taller than the page was cut as nothing and presented clipped on one page (`cicero-object-fallback-throws`, assessment 2026-11-07). An object has no `complete`, so every fetching copy is awaited, and one that never answers is given up after two seconds rather than holding the run.
+ */
+function objectsFetching(container) {
+    const win = container.ownerDocument.defaultView;
+    const out = [];
+    for (const o of container.querySelectorAll('object[data]')) {
+        if (o.getAttribute('is') || win.getComputedStyle(o).display === 'none')
+            continue; // a presenter's element and a hidden one are measured by nobody's fetch
+        out.push(new Promise((resolve) => {
+            // The fallback is laid out a task after `error` fires (measured: 150 px, the default object size, at the event; 700 px a `setTimeout(0)` later), so the promise settles one task after the event.
+            const later = () => setTimeout(resolve, 0);
+            o.addEventListener('load', later, { once: true });
+            o.addEventListener('error', later, { once: true });
+            setTimeout(resolve, 2000); // ponytail: a fixed ceiling for a fetch that never answers; the rim hears nothing of an object, so a later answer is not re-cut
+        }));
+    }
+    return out;
+}
 /** The declarations {@link publishOn} last wrote on a container, so the next call takes them off. */
 const PUBLISHED = new WeakMap();
 /** Write a page's published values on the measure container, and take the previous page's off. */

package/dist/src/reads.d.ts

@@ -11,6 +11,7 @@
  *
  * @packageDocumentation
  */
+import { documentOpsOf } from './document-state.ts';
 import { indexBlocks } from './positions.ts';
 import type { ReadFn } from './gcpm-encoding.ts';
 import type { PagePublish } from './measure.ts';
@@ -47,6 +48,8 @@ export type Laid = {
     sites: Site[] | null;
     /** the position index the loop already built. */
     index: ReturnType<typeof indexBlocks> | null;
+    /** the counter log the loop already walked, under the marks of its counter references and without running elements, or null where it walked none. */
+    ops?: ReturnType<typeof documentOpsOf> | null;
     /** the references whose page number moved a line of their own in the layout before. */
     because?: string[];
     /** on a layout after the first: the layout before it, as the run returned it, and the addresses of the boxes whose lines the delivered values moved, which the run resumes from as from an edit (*delivery resumes from the moved page*, 2026-10-21). */
@@ -110,6 +113,8 @@ export type PageSite = {
  * @returns null where no rule reads a page fact.
  */
 export declare function findPageSites(doc: Document, originals?: Element[] | null, keep?: Keep | null): PageSite[] | null;
+/** The flow sites that read the page total, as the rule that reads it names them: what {@link hideReservations} paints invisible while the total is unknown, since a flow site reads `0` until then (`chase.ts`'s `setCounters`). A `counter(page)` and a named string are true from the first page and are not among them. */
+export declare function totalSites(doc: Document): Pick<Site, 'key' | 'pseudos'>[];
 /** What every page of a run publishes, as the measure wears it: the page's number and the document's total, and its named strings' properties (`chase.js`'s `setCounters` and `setStrings`, the same values). */
 export declare function pageFactsOf(account: Array<{
     closes: {
@@ -130,8 +135,8 @@ export declare function pageFactsOf(account: Array<{
  * @returns null where the document declares no read, which is every document but a few.
  */
 export declare function findSites(doc: Document, originals?: Element[] | null, keep?: Keep | null): Site[] | null;
-/** Deliver a table of values: one constructed sheet, adopted once, its text replaced. */
-export declare function deliver(doc: Document, values: Values): void;
+/** Deliver a table of values: one constructed sheet per scope, adopted once, its text replaced. The rules still reach every element of `doc` that matches, scope or none: the scope keeps the sheets apart, not the elements. */
+export declare function deliver(doc: Document, values: Values, scope?: object): void;
 /** Is this adopted sheet one of the engine's own — the delivery sheet (the values a run delivered, rewritten every run) or the sheet that hides a reservation until its true number is delivered? */
 export declare const isDeliverySheet: (doc: Document, sheet: CSSStyleSheet) => boolean;
 /**
@@ -143,17 +148,18 @@ export declare const isDeliverySheet: (doc: Document, sheet: CSSStyleSheet) => b
  * @param sites - the page reads that are still at the reservation.
  * @param scope - the selector of the element the presented pages stand in.
  */
-export declare function hideSheetText(sites: Site[], scope?: string): string;
+export declare function hideSheetText(sites: Pick<Site, 'key' | 'pseudos'>[], scope?: string): string;
 /**
  * Paint the reservations invisible: the page numbers the cuts so far do not know yet (*the pages are cut as far as they are asked*, Egildo's ruling 1 of 2026-10-12, on the note's recommendation). A document shown before it is complete must not show `0` where a page number will stand.
  *
- * @param scope - as {@link hideSheetText}.
+ * @param selector - as {@link hideSheetText}'s `scope`.
+ * @param scope - the host's token for this view, as {@link deliver}'s.
  */
-export declare function hideReservations(doc: Document, sites: Site[], scope?: string | undefined): void;
+export declare function hideReservations(doc: Document, sites: Pick<Site, 'key' | 'pseudos'>[], selector?: string | undefined, scope?: object): void;
 /** Take the hiding sheet off: the true numbers are delivered, or there is nothing left to hide. */
-export declare function showReservations(doc: Document): void;
+export declare function showReservations(doc: Document, scope?: object): void;
 /** Take the delivery sheet off the document, where one was adopted — a second paginate of a document that no longer declares a read leaves nothing behind. */
-export declare function withdraw(doc: Document): void;
+export declare function withdraw(doc: Document, scope?: object): void;
 /**
  * The written and cascade facts, before any run: every `target-text()`, and every `target-counter()` and `target-counters()` of a counter other than `page`.
  *
@@ -168,6 +174,7 @@ export declare function staticValues(sites: Site[], { doc, blocks, index, keep }
 }): {
     values: Values;
     unread: Site[];
+    ops: ReturnType<typeof documentOpsOf> | null;
 };
 /**
  * The layout facts, after a run: the page each page read's target lands on, as the ledger assigned it — the page whose interval holds the target's first word, over the intervals `root.pageOf` reads (`positions.js`'s `pageContaining`).
@@ -224,7 +231,7 @@ export declare function linesOfSites<S extends {
  *
  * **A layout sent round again resumes from the one before it** (*delivery resumes from the moved page*, 2026-10-21). A delivered value that moves a line is an edit at its site's page, so `run` is handed `resume`, the layout just checked and the addresses of the boxes whose lines moved, and the driver restarts one page before the first of them, re-cuts, and stops where it converges past the last, exactly as it resumes from a host's edit. The result's `resumed` and `why` stay the call's: two resumes compose into one from the prior the host handed (`resume.js`' `composeResumed`), a whole layout anywhere in the loop makes `resumed` null, and each resumed layout leaves a `cicero:reads-run` measure naming the pages it cut again.
  *
- * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22). A `run` that answers `complete: false` laid out only part of the document (a view's chain that stopped short): the loop ends there, without checking or delivering page values, so the reservations stay hidden and the values it returns are the ones that layout was cut under; the driver's own run is always complete.
+ * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `scope` an object the host holds for this view (the document where absent), which keeps this view's delivery and hiding sheets apart from another view's in the same document; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22). A `run` that answers `complete: false` laid out only part of the document (a view's chain that stopped short): the loop ends there, without checking or delivering page values, so the reservations stay hidden and the values it returns are the ones that layout was cut under; the driver's own run is always complete.
  */
 export declare function settleReads<R extends {
     account: any[];
@@ -233,7 +240,7 @@ export declare function settleReads<R extends {
     why?: string | null;
     laidFacts?: PagePublish[] | null;
     complete?: boolean;
-}>(doc: Document, { run, blocksOf, originals, warm, warmFacts, hide, keep }: {
+}>(doc: Document, { run, blocksOf, originals, warm, warmFacts, hide, keep, scope }: {
     run: (laid: Laid) => Promise<R>;
     blocksOf: () => Element[];
     originals?: Element[] | null;
@@ -241,6 +248,7 @@ export declare function settleReads<R extends {
     warmFacts?: PagePublish[] | null;
     hide?: boolean | string;
     keep?: Keep | null;
+    scope?: object;
 }): Promise<R & {
     resumed: Resumed | null;
     why: string | null;

package/dist/src/reads.js

@@ -237,6 +237,12 @@ export function findPageSites(doc, originals = null, keep = null) {
     }
     return sites.length ? sites : null;
 }
+/** The flow sites that read the page total, as the rule that reads it names them: what {@link hideReservations} paints invisible while the total is unknown, since a flow site reads `0` until then (`chase.ts`'s `setCounters`). A `counter(page)` and a named string are true from the first page and are not among them. */
+export function totalSites(doc) {
+    return contentRules(doc)
+        .filter((r) => /counters?\(\s*pages\s*[,)]/.test(r.content))
+        .map((r) => ({ key: hostSelector(r.selector), pseudos: r.pseudos }));
+}
 /** What every page of a run publishes, as the measure wears it: the page's number and the document's total, and its named strings' properties (`chase.js`'s `setCounters` and `setStrings`, the same values). */
 export function pageFactsOf(account) {
     return account.map((entry) => {
@@ -306,23 +312,32 @@ function targetOf(doc, fragment, originals) {
     }
     return null;
 }
-/** The engine's one delivery sheet per document, replaced at every delivery and withdrawn when a paginate finds nothing to deliver. */
+/** The engine's one delivery sheet per scope, replaced at every delivery and withdrawn when a paginate finds nothing to deliver. A scope is any object the host holds for one view of the document (the document itself where none is named), so two hosts in one document keep a sheet each (fix/scope-per-view, 2026-11-08). */
 const SHEETS = new WeakMap();
-/** Deliver a table of values: one constructed sheet, adopted once, its text replaced. */
-export function deliver(doc, values) {
-    let sheet = SHEETS.get(doc);
+/** The text each engine sheet last carried: a sheet whose text is unchanged is not rewritten, since `replaceSync` restyles the document whether or not anything differs (*the reads loop writes only what changed*, CHANGELOG Unreleased). */
+const SHEET_TEXT = new WeakMap();
+const write = (sheet, text) => { if (SHEET_TEXT.get(sheet) !== text) {
+    sheet.replaceSync(text);
+    SHEET_TEXT.set(sheet, text);
+} };
+/** Every sheet the engine made, whatever its scope: what {@link isDeliverySheet} asks. */
+const OWN = new WeakSet();
+/** Deliver a table of values: one constructed sheet per scope, adopted once, its text replaced. The rules still reach every element of `doc` that matches, scope or none: the scope keeps the sheets apart, not the elements. */
+export function deliver(doc, values, scope = doc) {
+    let sheet = SHEETS.get(scope);
     if (!sheet) {
         sheet = new (doc.defaultView.CSSStyleSheet)();
-        SHEETS.set(doc, sheet);
+        SHEETS.set(scope, sheet);
+        OWN.add(sheet);
     }
-    sheet.replaceSync(deliverySheetText(values));
+    write(sheet, deliverySheetText(values));
     if (!doc.adoptedStyleSheets.includes(sheet))
         doc.adoptedStyleSheets = [...doc.adoptedStyleSheets, sheet];
 }
-/** The engine's one hiding sheet per document: the rule that paints a reservation invisible while the pages are still being cut (*the pages are cut as far as they are asked*, 2026-10-12). */
+/** The engine's one hiding sheet per scope: the rule that paints a reservation invisible while the pages are still being cut (*the pages are cut as far as they are asked*, 2026-10-12). */
 const HIDERS = new WeakMap();
 /** Is this adopted sheet one of the engine's own — the delivery sheet (the values a run delivered, rewritten every run) or the sheet that hides a reservation until its true number is delivered? */
-export const isDeliverySheet = (doc, sheet) => SHEETS.get(doc) === sheet || HIDERS.get(doc) === sheet;
+export const isDeliverySheet = (doc, sheet) => OWN.has(sheet);
 /**
  * The hiding sheet's text: one rule per distinct address the reserved page reads are keyed by, naming the pseudo-elements that read them, scoped to the presented document (`beltype-root`, or the scope a host that is not the root names). Pure, so the shape is pinned without a browser.
  *
@@ -347,33 +362,35 @@ export function hideSheetText(sites, scope = 'beltype-root') {
 /**
  * Paint the reservations invisible: the page numbers the cuts so far do not know yet (*the pages are cut as far as they are asked*, Egildo's ruling 1 of 2026-10-12, on the note's recommendation). A document shown before it is complete must not show `0` where a page number will stand.
  *
- * @param scope - as {@link hideSheetText}.
+ * @param selector - as {@link hideSheetText}'s `scope`.
+ * @param scope - the host's token for this view, as {@link deliver}'s.
  */
-export function hideReservations(doc, sites, scope = undefined) {
-    const text = hideSheetText(sites, scope);
+export function hideReservations(doc, sites, selector = undefined, scope = doc) {
+    const text = hideSheetText(sites, selector);
     if (!text)
         return;
-    let sheet = HIDERS.get(doc);
+    let sheet = HIDERS.get(scope);
     if (!sheet) {
         sheet = new (doc.defaultView.CSSStyleSheet)();
-        HIDERS.set(doc, sheet);
+        HIDERS.set(scope, sheet);
+        OWN.add(sheet);
     }
-    sheet.replaceSync(text);
+    write(sheet, text);
     if (!doc.adoptedStyleSheets.includes(sheet))
         doc.adoptedStyleSheets = [...doc.adoptedStyleSheets, sheet];
 }
 /** Take the hiding sheet off: the true numbers are delivered, or there is nothing left to hide. */
-export function showReservations(doc) {
-    const sheet = HIDERS.get(doc);
+export function showReservations(doc, scope = doc) {
+    const sheet = HIDERS.get(scope);
     if (sheet && doc.adoptedStyleSheets.includes(sheet))
         doc.adoptedStyleSheets = doc.adoptedStyleSheets.filter((s) => s !== sheet);
 }
 /** Take the delivery sheet off the document, where one was adopted — a second paginate of a document that no longer declares a read leaves nothing behind. */
-export function withdraw(doc) {
-    const sheet = SHEETS.get(doc);
+export function withdraw(doc, scope = doc) {
+    const sheet = SHEETS.get(scope);
     if (sheet && doc.adoptedStyleSheets.includes(sheet))
         doc.adoptedStyleSheets = doc.adoptedStyleSheets.filter((s) => s !== sheet);
-    showReservations(doc);
+    showReservations(doc, scope);
 }
 /**
  * The written and cascade facts, before any run: every `target-text()`, and every `target-counter()` and `target-counters()` of a counter other than `page`.
@@ -386,9 +403,10 @@ export function staticValues(sites, { doc, blocks, index = null, keep = null })
     const unread = [];
     const counted = sites.filter((s) => s.target && (s.read.fn === 'counter' || s.read.fn === 'counters') && !isPageRead(s.read));
     let states = new Map();
+    let ops = null;
     if (counted.length) {
         const win = doc.defaultView;
-        const ops = documentOpsOf(blocks, index ?? indexBlocks(blocks), {
+        ops = documentOpsOf(blocks, index ?? indexBlocks(blocks), {
             styleOf: (el) => win.getComputedStyle(el),
             pseudoStyleOf: sheetsCountInPseudos(doc) ? (el, pseudo) => win.getComputedStyle(el, pseudo) : null,
             ancestors: [doc.documentElement, doc.body].filter(Boolean),
@@ -416,7 +434,7 @@ export function staticValues(sites, { doc, blocks, index = null, keep = null })
         }
         put(values, s.key, s.prop, cssString(formatCounter(counterValue(state, s.read.counter), s.read.style)));
     }
-    return { values, unread };
+    return { values, unread, ops };
 }
 /**
  * The layout facts, after a run: the page each page read's target lands on, as the ledger assigned it — the page whose interval holds the target's first word, over the intervals `root.pageOf` reads (`positions.js`'s `pageContaining`).
@@ -528,14 +546,14 @@ function boxAddress(site, index, blocks) {
  *
  * **A layout sent round again resumes from the one before it** (*delivery resumes from the moved page*, 2026-10-21). A delivered value that moves a line is an edit at its site's page, so `run` is handed `resume`, the layout just checked and the addresses of the boxes whose lines moved, and the driver restarts one page before the first of them, re-cuts, and stops where it converges past the last, exactly as it resumes from a host's edit. The result's `resumed` and `why` stay the call's: two resumes compose into one from the prior the host handed (`resume.js`' `composeResumed`), a whole layout anywhere in the loop makes `resumed` null, and each resumed layout leaves a `cicero:reads-run` measure naming the pages it cut again.
  *
- * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22). A `run` that answers `complete: false` laid out only part of the document (a view's chain that stopped short): the loop ends there, without checking or delivering page values, so the reservations stay hidden and the values it returns are the ones that layout was cut under; the driver's own run is always complete.
+ * @param how - `run` lays the document out once, whole or resumed (`because`: the references whose page number moved a line of their own in the run before, when this is not the first; `facts`: the page values a flow site reads, per page, as the run before decided them, or null for the reservation; it returns `laidFacts` beside `account` when the page values it was laid out under are not the ones it was handed); `blocksOf` names the top-level blocks; `originals` the intake's top-level boxes, where the document has been presented (see {@link findSites}); `warm` and `warmFacts` the tables the previous run's layout was cut under, for a run that resumes; `hide` that pages are shown before the run is complete (*the pages are cut as far as they are asked*), so the reservations still standing are painted invisible until the true numbers are delivered, under `<beltype-root>` for `true` and under the selector a string names for a host that is not the root; `scope` an object the host holds for this view (the document where absent), which keeps this view's delivery and hiding sheets apart from another view's in the same document; `keep` the memo's door, through which the site search, the position index and the counter walk take the parts of the boxes no edit replaced (*a resumed run keeps its reads*, 2026-10-22). A `run` that answers `complete: false` laid out only part of the document (a view's chain that stopped short): the loop ends there, without checking or delivering page values, so the reservations stay hidden and the values it returns are the ones that layout was cut under; the driver's own run is always complete.
  */
-export async function settleReads(doc, { run, blocksOf, originals = null, warm = null, warmFacts = null, hide = false, keep = null }) {
+export async function settleReads(doc, { run, blocksOf, originals = null, warm = null, warmFacts = null, hide = false, keep = null, scope = doc }) {
     let t = performance.now(); // the site search is the reads' own cost and is inside their measure (*a resumed run keeps its reads*, 2026-10-22)
     const found = findSites(doc, originals, keep);
     const pageSites = findPageSites(doc, originals, keep);
     if (!found && !pageSites) {
-        withdraw(doc);
+        withdraw(doc, scope);
         const once = await run({ attempt: 0, delivered: null, facts: null, sites: null, index: null });
         return { ...once, resumed: once.resumed ?? null, why: once.why ?? null, delivered: null, facts: null, reads: null };
     }
@@ -547,17 +565,17 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
     for (const s of sites)
         if (s.target && s.read.fn === 'text' && !blocks.some((b) => b.contains(s.target)))
             s.target = null;
-    // One walk of the words, shared with the run (*the run resumes from an entry*, build two: 60 ms of every manual run was this walk, done twice). The counter log is not shared, and the reason is worth a line: it is read here before the run registers the GCPM properties, and an unregistered `string-set` inherits, so a log taken now would assign every heading's string to its descendants too.
+    // One walk of the words, shared with the run (*the run resumes from an entry*, build two: 60 ms of every manual run was this walk, done twice), and one counter walk where a counter reference needs it: the run takes this log and lays its running elements in (`document-state.ts`' `withRunning`). It is read under the GCPM properties' registration, which `paginate` makes before the reads, since an unregistered `string-set` inherits and a log taken before it would assign every heading's string to its descendants too. Measured 2026-11-09 on a 190-section document with one `target-counter()` of a figure: the run's `cicero:document-ops` went from 79 to 82 ms to under 1 ms, the reads' measure unchanged at 163 to 177 ms.
     const index = indexBlocks(blocks, undefined, undefined, keep);
     const fixed = staticValues(sites, { doc, blocks, index, keep });
     const paged = sites.filter((s) => s.target && isPageRead(s.read));
     let delivered = reservations(sites, warm);
     if (found)
-        deliver(doc, merged(fixed.values, delivered));
+        deliver(doc, merged(fixed.values, delivered), scope);
     else
-        withdraw(doc);
+        withdraw(doc, scope);
     if (hide)
-        hideReservations(doc, paged.filter((s) => delivered.get(s.key ?? '')?.get(s.prop) === cssString(RESERVATION)), hide === true ? undefined : hide);
+        hideReservations(doc, [...paged.filter((s) => delivered.get(s.key ?? '')?.get(s.prop) === cssString(RESERVATION)), ...(pageSites ? totalSites(doc) : [])], hide === true ? undefined : hide, scope);
     performance.measure('cicero:reads', { start: t, end: (t = performance.now()), detail: { references: sites.length, pageSites: pageSites?.length ?? 0 } });
     let runs = 0;
     let moved = [];
@@ -577,7 +595,7 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
         laidUnder = merged(fixed.values, delivered);
         laidFacts = facts;
         const started = performance.now();
-        result = await run({ attempt: runs, delivered: found ? laidUnder : null, facts: laidFacts, sites: found, index, because: because.map(name), resume });
+        result = await run({ attempt: runs, delivered: found ? laidUnder : null, facts: laidFacts, sites: found, index, ops: fixed.ops, because: because.map(name), resume });
         laidFacts = result.laidFacts ?? laidFacts; // the page values the layout was cut under are the run's to say; a run that says none was cut under the ones it was handed
         if (runs === 0) {
             resumed = result.resumed ?? null;
@@ -595,7 +613,7 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
             facts = laidFacts;
             break;
         }
-        showReservations(doc); // the run is complete: what was reserved is delivered true on the next lines, or was true already
+        showReservations(doc, scope); // the run is complete: what was reserved is delivered true on the next lines, or was true already
         const truth = pageValues(paged, result);
         unplaced = truth.unplaced;
         const changed = new Set(changedPairs(delivered, truth.values));
@@ -612,7 +630,7 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
         const before = linesOfSites(doc, touched, result, blocks);
         const beforePage = linesOfSites(doc, shifted, result, blocks, (page) => factOf(laidFacts, page));
         if (found)
-            deliver(doc, merged(fixed.values, truth.values));
+            deliver(doc, merged(fixed.values, truth.values), scope);
         delivered = truth.values;
         facts = truthFacts;
         const after = linesOfSites(doc, touched, result, blocks);
@@ -638,6 +656,7 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
     if (moved.length)
         console.warn(`BelType/Cicero: after ${runs} runs the page numbers of ${named(moved)} still move their own lines — the last true values stand, on a layout measured with the values before them.`);
     const pageReads = sites.filter((s) => isPageRead(s.read)).length;
-    console.info(`BelType/Cicero: ${sites.length} reference(s) read (${pageReads} page, ${sites.length - pageReads} counter or text) and ${pageSites?.length ?? 0} site(s) reading their own page; the pages settled in ${runs} run${runs === 1 ? '' : 's'}.`);
+    if (moved.length)
+        console.info(`BelType/Cicero: ${sites.length} reference(s) read (${pageReads} page, ${sites.length - pageReads} counter or text) and ${pageSites?.length ?? 0} site(s) reading their own page; the pages settled in ${runs} run${runs === 1 ? '' : 's'}.`);
     return { ...result, resumed, why, delivered: found ? (moved.length ? laidUnder : merged(fixed.values, delivered)) : null, facts: moved.length ? laidFacts : facts, reads: { references: sites.length, pageSites: pageSites?.length ?? 0, runs, unsettled: moved.map(name) } };
 }

package/dist/src/root.js

@@ -19,7 +19,7 @@ import { pointShownBy, sourcePointOf } from './source-point.js';
 import { copyOf, holdsFixedBox, sourceOf } from './word-space.js';
 import { holdsPresented } from './presenters.js';
 import { transliterateContent, neutralizeMarginBoxes, sheetsUseHas } from './capture.js';
-import { ARTIFACT, addWord, FIXED, FRAGMENT, selectorOf, setValue, wordOf } from './data-beltype.js';
+import { ARTIFACT, decodeFragment, addWord, FIXED, FRAGMENT, selectorOf, setValue, wordOf } from './data-beltype.js';
 import { deliverValues, ensureContinuationDressing, ensureDressing, isWordsSheet } from './dressing.js';
 import { carriedPast, divides, elAtIn, extensionPx, flattenResume, flowsOf, indexBlocks, pageIntervals, pageOfPos, widthKeyOf, wordsBeforeChar } from './positions.js';
 const PRESS_STYLE_ID = '__beltype-press';
@@ -690,7 +690,7 @@ export class BeltypeRoot extends HTMLElement {
         this.#listening = true;
         const view = this.ownerDocument.defaultView;
         const targetOf = (hash) => {
-            const id = hash.length > 1 ? decodeURIComponent(hash.slice(1)) : '';
+            const id = hash.length > 1 ? decodeFragment(hash) : '';
             const found = id ? this.ownerDocument.getElementById(id) ?? this.ownerDocument.getElementsByName(id)[0] : null;
             return found && this.contains(found) ? found : null;
         };

package/dist/src/scope.d.ts

@@ -0,0 +1,23 @@
+/**
+ * What the engine does not do yet, read from the author's boxes at intake: vertical writing below the root is refused by name, and a multi-column box too tall for any page is laid out as one column.
+ *
+ * @remarks The root's own direction and writing mode are refused by `assertRenderConditions` (`src/measure.ts`). Both refusals are out of scope for the beta (SPEC II.1, item 6). The one-column fallback is an interim: the computed fact (the box needs dividing) is known and only the presentation of its columns is not, so it says so on the console (SPEC Article I, item 11). The ceiling is the first page's geometry, and a box nested in another multi-column box is measured on its own.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Walk the blocks' boxes once: refuse a vertical writing mode, answer the multi-column boxes.
+ *
+ * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a box below the root that computes a `writing-mode` other than `horizontal-tb`.
+ */
+export declare function readScope(win: Window & typeof globalThis, blocks: Iterable<Element>): Element[];
+/**
+ * Give the word `one-column` to every multi-column box that is taller than a page area at the page's width, so its copies lay out as one column and divide like any block. A box that fits a page keeps its columns.
+ *
+ * @param columns - {@link readScope}'s answer.
+ * @param page - the geometry the boxes are measured against.
+ */
+export declare function foldTallColumns(doc: Document, columns: Element[], page: {
+    contentW: number;
+    contentH: number;
+}): void;

package/dist/src/scope.js

@@ -0,0 +1,60 @@
+/**
+ * What the engine does not do yet, read from the author's boxes at intake: vertical writing below the root is refused by name, and a multi-column box too tall for any page is laid out as one column.
+ *
+ * @remarks The root's own direction and writing mode are refused by `assertRenderConditions` (`src/measure.ts`). Both refusals are out of scope for the beta (SPEC II.1, item 6). The one-column fallback is an interim: the computed fact (the box needs dividing) is known and only the presentation of its columns is not, so it says so on the console (SPEC Article I, item 11). The ceiling is the first page's geometry, and a box nested in another multi-column box is measured on its own.
+ *
+ * @packageDocumentation
+ */
+import { createMeasureContext } from './measure.js';
+import { ONE_COLUMN } from './data-beltype.js';
+import { addSourceWord, measuringCopyOf, sourceHasWord } from './word-space.js';
+const named = new WeakSet();
+const describe = (el) => `<${el.localName}${el.className && typeof el.className === 'string' ? ` class="${el.className}"` : ''}>`;
+/**
+ * Walk the blocks' boxes once: refuse a vertical writing mode, answer the multi-column boxes.
+ *
+ * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a box below the root that computes a `writing-mode` other than `horizontal-tb`.
+ */
+export function readScope(win, blocks) {
+    const columns = [];
+    for (const block of blocks) {
+        for (const el of [block, ...block.querySelectorAll('*')]) {
+            const st = win.getComputedStyle(el);
+            if (st.writingMode && st.writingMode !== 'horizontal-tb') {
+                throw new Error(`vertical writing is outside this engine's scope: ${describe(el)} computes writing-mode '${st.writingMode}', and every read here is horizontal (the line by vertical overlap, the cut by a y). Write it horizontal-tb, or print the document with another engine.`);
+            }
+            if ((st.columnCount ?? 'auto') !== 'auto' || (st.columnWidth ?? 'auto') !== 'auto')
+                columns.push(el);
+        }
+    }
+    return columns;
+}
+/**
+ * Give the word `one-column` to every multi-column box that is taller than a page area at the page's width, so its copies lay out as one column and divide like any block. A box that fits a page keeps its columns.
+ *
+ * @param columns - {@link readScope}'s answer.
+ * @param page - the geometry the boxes are measured against.
+ */
+export function foldTallColumns(doc, columns, page) {
+    if (!columns.length)
+        return;
+    const ctx = createMeasureContext(doc, page.contentW);
+    try {
+        for (const el of columns) {
+            if (sourceHasWord(el, ONE_COLUMN))
+                continue; // settled earlier in this call; the next call asks again
+            const copy = measuringCopyOf(el);
+            ctx.measure([copy]);
+            if (copy.getBoundingClientRect().height <= page.contentH)
+                continue;
+            addSourceWord(el, ONE_COLUMN);
+            if (!named.has(el)) {
+                named.add(el);
+                doc.defaultView?.console?.warn(`cicero: ${describe(el)} is a multi-column box taller than a page, and columns are not divided across pages yet — it is laid out as one column`);
+            }
+        }
+    }
+    finally {
+        ctx.dispose();
+    }
+}

package/dist/src/stonehand.d.ts

@@ -133,7 +133,7 @@ export declare function classBWindow(T: number, orphans: number, widows: number)
  */
 export declare function isMonolith(el: Element, style: CSSStyleDeclaration, live?: Element): boolean;
 /**
- * **A fourth ground, and a temporary one: what the engine does not yet divide, where dividing it loses words** (*every branch gets a place*, 2026-09-21). Two arrangements lay content side by side in ways a row of sibling boxes does not describe, and each lost words at a cut until it was held whole (`packages/essay/probes/conservation.js`): a multi-column container, whose columns are fragmentainers of their own; and an inline-level block container, which is an atom of a line, with paragraphs inside it that the procession used to see. Held as a monolith each moves whole, or is sliced by the edge with its remainder painted — css-break-3's own remedy. **The remedy has a price, measured the same day, and it is why the list is this short**: a slice through text leaves the line the edge crosses half on each page, and the print's text layer reads it on both. That is better than words on no page and worse than anything else, so a grid with sized tracks or placed items — which divides without losing a word and merely opens its next page on the spent track's blank — was tried here and taken out again. Each entry leaves this list when it has a design of its own.
+ * **A fourth ground, and a temporary one: what the engine does not yet divide, where dividing it loses words** (*every branch gets a place*, 2026-09-21). Two arrangements lay content side by side in ways a row of sibling boxes does not describe, and each lost words at a cut until it was held whole (`packages/essay/probes/conservation.js`): a multi-column container, whose columns are fragmentainers of their own; and an inline-level block container, which is an atom of a line, with paragraphs inside it that the procession used to see. Held as a monolith each moves whole, or is sliced by the edge with its remainder painted — css-break-3's own remedy. **The remedy has a price, measured the same day, and it is why the list is this short**: a slice through text leaves the line the edge crosses half on each page, and the print's text layer reads it on both. A multi-column box taller than a page no longer reaches this list: it is laid out as one column (`src/scope.ts`), and the slice is left to a box that is a monolith for another reason. That is better than words on no page and worse than anything else, so a grid with sized tracks or placed items — which divides without losing a word and merely opens its next page on the spent track's blank — was tried here and taken out again. Each entry leaves this list when it has a design of its own.
  *
  * `live` is the element a measured clone stands for, kept in the signature for the day a ground needs to ask the element rather than its computed style — a grid's declared tracks are such a question: `grid-template-rows` resolves to the used tracks, implicit ones included, and only `computedStyleMap()` tells a declared list from none (measured in Chromium).
  */