@beltype/cicero 0.1.11 → 0.1.13

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). */
@@ -132,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;
 /**
@@ -149,13 +152,14 @@ export declare function hideSheetText(sites: Pick<Site, 'key' | 'pseudos'>[], sc
 /**
  * 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: Pick<Site, 'key' | 'pseudos'>[], 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`.
  *
@@ -170,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`).
@@ -226,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[];
@@ -235,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;
@@ -243,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

@@ -312,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.
  *
@@ -353,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`.
@@ -392,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),
@@ -422,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`).
@@ -534,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 };
     }
@@ -553,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)), ...(pageSites ? totalSites(doc) : [])], 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 = [];
@@ -583,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;
@@ -601,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));
@@ -618,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);
@@ -644,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/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).
  */

package/dist/src/stonehand.js

@@ -11,8 +11,8 @@
  *
  * @packageDocumentation
  */
-import { isAtom, READS_ITS_CHILDREN } from './word-space.js';
-import { ARTIFACT, hasWord } from './data-beltype.js';
+import { isAtom, READS_ITS_CHILDREN, sourceHasWord } from './word-space.js';
+import { ARTIFACT, ONE_COLUMN, hasWord } from './data-beltype.js';
 /**
  * THE MAKE-UP ORDER (*breaks are classified*, I3, amended in the fifth round) — which constraint yields first, and the standing fact that a constraint which has yielded still pulls.
  *
@@ -75,13 +75,13 @@ export function isMonolith(el, style, live = el) {
     return notYetDivided(style, live) !== null;
 }
 /**
- * **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).
  */
 export function notYetDivided(style, live) {
-    if ((style.columnCount ?? 'auto') !== 'auto' || (style.columnWidth ?? 'auto') !== 'auto')
-        return 'multicol';
+    if (((style.columnCount ?? 'auto') !== 'auto' || (style.columnWidth ?? 'auto') !== 'auto') && !sourceHasWord(live, ONE_COLUMN))
+        return 'multicol'; // a source the run laid out as one column (`src/scope.ts`) is an ordinary block, though its own style still says columns
     if (/^inline-(block|flex|grid|table)$/.test(style.display ?? ''))
         return 'inline block container';
     return null;
@@ -331,8 +331,16 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
                     plan.push({ item, state: 'held', verdict: null }); // a monolith the height crosses resumes whole: the stated limit, as a float's (the item is the graphic, and nothing inside it is a place)
                 else {
                     const v = flowVerdict(w, item, h + lift, eps);
-                    if (!v)
-                        return null; // content crosses the height and the item offers no place above it: it shows nothing here
+                    if (!v) {
+                        // Content crosses the height and the item offers no place above it: it shows nothing here. In the first table row of the group that withdraws the offer (case 91). In a later row of a group a `rowspan` makes, that row moves whole with every row after it, the boundary before it being the break in its column, and the spanning cell is still divided at the height, as Chromium prints it (the essay's case 92).
+                        if (item.parent === row[0].parent)
+                            return null;
+                        const from = row.findIndex((r) => r.parent === item.parent);
+                        plan.splice(from);
+                        for (const rest of row.slice(from))
+                            plan.push({ item: rest, state: 'below', verdict: null });
+                        break;
+                    }
                     plan.push({ item, state: 'divided', verdict: v });
                 }
             }
@@ -358,7 +366,9 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
             const pair = siblings[si - 1];
             const anchor = last(siblings.slice(0, si).filter((b) => !parallelBox(b))) ?? null;
             // Before the rows of a continuation only the repeated header stands, and a copy is furniture (*an artifact is never read*): a boundary there takes nothing of the box, and would send the page back to where the box began.
-            if (anchor && !siblings.slice(0, si).every((b) => parallelBox(b) || copy(b))) {
+            // A table row a `rowspan` from above reaches is inside its group's row: the boundary before it would leave the spanning cell's remainder on no page, and the group's own cut is where that boundary is taken (`rowPlan`).
+            const spanned = box.blockChildren.some((c) => { const r = rowOf(c); return !!r && r[0].parent !== box; });
+            if (anchor && !spanned && !siblings.slice(0, si).every((b) => parallelBox(b) || copy(b))) {
                 candidates.push({
                     kind: 'A',
                     cls: 'A',
@@ -454,7 +464,8 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         // The place it names is before the box's first in-flow child, past the gap (*the cut divides its ancestors*, 2026-09-29): the page before carries the box's border, its padding and whatever stands in the gap — an empty float, the clearance under it — and the page after resumes the box divided, its first child whole. So the position is the child's outer top, which is the content edge plus the gap; it used to be the box's top plus its border, which put the padding on the next page and offered a break point §4.1 does not provide (`packages/essay/cases/71-the-box-that-begins-a-page`).
         const startGap = box.blockChildren.length ? report.gapAt({ box, edge: 'start' }) : 0;
         const firstInFlow = startGap > eps ? box.blockChildren.find((c) => !parallelBox(c)) : undefined;
-        if (firstInFlow && !copy(firstInFlow)) {
+        // A box that opens the page offers no start gap: the page would hold its block-start decoration and nothing else, and the next page would offer the same gap again wherever the box clones its decoration, so the cut is no progress (css-break-3 §4.4 drops an avoid that leaves only this, and Chromium's print never takes it: a row taller than the page under `break-inside: avoid` left a blank first page, and WPT's `table-fragmentation-001c` refused, assessment 2026-11-07, `outer-row-taller-than-page-avoid`).
+        if (firstInFlow && !copy(firstInFlow) && box.rect.top > pageStart + eps) {
             const prevSibling = si > 0 ? siblings[si - 1] : null;
             const bs = win.getComputedStyle(box.el);
             candidates.push({

package/dist/src/word-space.d.ts

@@ -49,6 +49,10 @@ export declare function isLineBreak(el: Element): boolean;
  * @param map - the run's words, by source element.
  */
 export declare function setSourceWords(map: WeakMap<Element, string[]>): void;
+/** Give a source a word for the copies this run makes from now on; the source itself is not written (C5). */
+export declare function addSourceWord(source: Element, word: string): void;
+/** Does the run's record give this source the word? */
+export declare const sourceHasWord: (source: Element, word: string) => boolean;
 /**
  * Write the words onto a copy and every element under it, in lockstep with the source tree, without registering the copy against its source — for a measuring clone that is read and thrown away (the Compositor's), where registering would change what an unmapped element is treated as.
  *
@@ -186,6 +190,13 @@ export declare const SIDE_BY_SIDE: Set<string>;
  * **The answer is read once per source element and kept** (*the page asks the index*, 2026-09-25). `stripFixedBoxes` asks it of every element of every feed clone and every presentation clone, about 300 000 style reads a run on the BGD manual for an answer that cannot change: the source is never written (*the source document is never written*, C5), and a host calls `run()` once per frame, so nothing moves a `position` within a run — the essay's client runs its judge and its view over one document whose values do not change between them. Only this predicate is kept: `isInlineBox` and `sourceStyle` are read far less often per clone, and a wider cache would be a wider claim.
  */
 export declare function isFixedBox(el: Element): boolean;
+/**
+ * Is this child a float standing wholly in its parent's padding or border, a hanging number (Codeberg issue 7)? Such a float shortens none of the parent's line boxes, so it is no part of the text being set: the composed mode skips it, in the child check and in the word walk, and leaves it where the browser put it. Any other float still makes the parent a block of floats and refuses.
+ *
+ * @remarks
+ * Asked through the registered source and kept per source, as {@link isFixedBox} is, for the same reasons: a clone detached from the document has no rect, and the source's layout does not move within a run. An unregistered, disconnected element answers false.
+ */
+export declare function isOutsideMarker(el: Element): boolean;
 /** Does this box hold a `position: fixed` box anywhere inside it? The question `root.js` asks to know whether a block may be presented as its original or must be presented as a stripped clone — asked through `isFixedBox`, so the two can never disagree about which boxes count. */
 export declare function holdsFixedBox(el: Element): boolean;
 /**

package/dist/src/word-space.js

@@ -67,6 +67,16 @@ let WORDS_OF = new WeakMap();
 export function setSourceWords(map) {
     WORDS_OF = map;
 }
+/** Give a source a word for the copies this run makes from now on; the source itself is not written (C5). */
+export function addSourceWord(source, word) {
+    const list = WORDS_OF.get(source);
+    if (!list)
+        WORDS_OF.set(source, [word]);
+    else if (!list.includes(word))
+        list.push(word);
+}
+/** Does the run's record give this source the word? */
+export const sourceHasWord = (source, word) => !!WORDS_OF.get(source)?.includes(word);
 /** Write the words a source carries onto a copy of it — added to whatever the copy inherited from the source's own attribute, never replacing it. */
 function dressCopy(clone, source) {
     const words = WORDS_OF.get(source);
@@ -430,6 +440,36 @@ export function isFixedBox(el) {
     }
     return fixed;
 }
+const OUTSIDE = new WeakMap();
+/**
+ * Is this child a float standing wholly in its parent's padding or border, a hanging number (Codeberg issue 7)? Such a float shortens none of the parent's line boxes, so it is no part of the text being set: the composed mode skips it, in the child check and in the word walk, and leaves it where the browser put it. Any other float still makes the parent a block of floats and refuses.
+ *
+ * @remarks
+ * Asked through the registered source and kept per source, as {@link isFixedBox} is, for the same reasons: a clone detached from the document has no rect, and the source's layout does not move within a run. An unregistered, disconnected element answers false.
+ */
+export function isOutsideMarker(el) {
+    const live = SOURCE_OF.get(el) ?? el;
+    const win = live.ownerDocument?.defaultView;
+    const parent = live.parentElement;
+    if (!win || !parent || live.isConnected !== true)
+        return false;
+    let outside = OUTSIDE.get(live);
+    if (outside === undefined) {
+        outside = false;
+        if (win.getComputedStyle(live).float !== 'none') {
+            const ps = win.getComputedStyle(parent);
+            const p = parent.getBoundingClientRect();
+            const f = live.getBoundingClientRect();
+            const left = p.left + parseFloat(ps.borderLeftWidth) + parseFloat(ps.paddingLeft);
+            const right = p.right - parseFloat(ps.borderRightWidth) - parseFloat(ps.paddingRight);
+            const top = p.top + parseFloat(ps.borderTopWidth) + parseFloat(ps.paddingTop);
+            const bottom = p.bottom - parseFloat(ps.borderBottomWidth) - parseFloat(ps.paddingBottom);
+            outside = !(f.left < right && f.right > left && f.top < bottom && f.bottom > top);
+        }
+        OUTSIDE.set(live, outside);
+    }
+    return outside;
+}
 /** Does this box hold a `position: fixed` box anywhere inside it? The question `root.js` asks to know whether a block may be presented as its original or must be presented as a stripped clone — asked through `isFixedBox`, so the two can never disagree about which boxes count. */
 export function holdsFixedBox(el) {
     for (const child of el.children) {

package/package.json

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