@beltype/cicero 0.1.10 → 0.1.12

package/dist/seam/client.d.ts

@@ -35,7 +35,11 @@ declare function patchBox(index: number, path: number[], el: Element): Address |
 export type ChromePatch = {
     chrome: true;
 };
-/** Resolves when the rim has nothing pending and no run is under way (a run stopped at a page is at rest). The door a venue test and a host that wants to know it is looking at the settled document call. */
+/**
+ * Resolves when the document will not be cut again unless something is done to it: no call of `run()` is unanswered, no run is under way (a run stopped at a page is at rest), the rim has nothing it is answering or judging, `document.fonts` has nothing loading and every picture of the document's boxes has arrived (CHANGELOG, Unreleased). The door a venue test, a host that wants to know it is looking at the settled document and a printer that reads the presented pages call.
+ *
+ * @remarks `run()` resolving is not this. A face a page's margin boxes ask for is requested when the presentation is laid out, which is after the last run began, so it arrives after the run's answer, is heard as a late fact (`loadingdone`) and cuts the document again under whoever read the pages in between: measured 2026-11-08 on the essay's `margin-boxes/content-001`, a data-URL face first requested by the presented margin boxes, heard 33 ms into the first run and cutting again 3 ms later, and Caster refusing 'the pages were replaced while they were being printed' one print in three. So the wait is a loop: lay out, so every face the pages ask for is asked for; await the faces and the pictures; await a frame, so what they caused is heard; and look again, leaving only when a whole pass found nothing under way. A released client is settled.
+ */
 declare function settled(): Promise<void>;
 /** One run, from the call that started it to the moment it is complete or let go. */
 export type Session = {

package/dist/seam/client.js

@@ -24,7 +24,7 @@ import { dress, isDressingSheet } from '../src/root.js';
 import { isDeliverySheet } from '../src/reads.js';
 import { ForcingMemo } from '../src/forcing-memo.js';
 import { isInlineBox, isFixedBox, holdsFixedBox } from '../src/word-space.js';
-import { FRAGMENT, selectorOf } from '../src/data-beltype.js';
+import { FRAGMENT, decodeFragment, selectorOf } from '../src/data-beltype.js';
 import { present, presenterCount } from '../src/presenters.js';
 import { rewriteDocumentSheets } from './rewrite-document.js';
 import { isLayerName } from './rewrite.js';
@@ -273,10 +273,28 @@ async function quiet() {
     while (working || calls.size || (live && !live.gate))
         await Promise.race([working, ...calls, live?.finished].filter(Boolean)).catch(() => { });
 }
-/** Resolves when the rim has nothing pending and no run is under way (a run stopped at a page is at rest). The door a venue test and a host that wants to know it is looking at the settled document call. */
+/**
+ * Resolves when the document will not be cut again unless something is done to it: no call of `run()` is unanswered, no run is under way (a run stopped at a page is at rest), the rim has nothing it is answering or judging, `document.fonts` has nothing loading and every picture of the document's boxes has arrived (CHANGELOG, Unreleased). The door a venue test, a host that wants to know it is looking at the settled document and a printer that reads the presented pages call.
+ *
+ * @remarks `run()` resolving is not this. A face a page's margin boxes ask for is requested when the presentation is laid out, which is after the last run began, so it arrives after the run's answer, is heard as a late fact (`loadingdone`) and cuts the document again under whoever read the pages in between: measured 2026-11-08 on the essay's `margin-boxes/content-001`, a data-URL face first requested by the presented margin boxes, heard 33 ms into the first run and cutting again 3 ms later, and Caster refusing 'the pages were replaced while they were being printed' one print in three. So the wait is a loop: lay out, so every face the pages ask for is asked for; await the faces and the pictures; await a frame, so what they caused is heard; and look again, leaving only when a whole pass found nothing under way. A released client is settled.
+ */
 async function settled() {
-    while (working || (live && !live.gate))
-        await (working ?? live.finished);
+    for (;;) {
+        await quiet();
+        if (released)
+            return;
+        void document.documentElement.offsetHeight; // the layout that requests the faces the presented pages ask for
+        await document.fonts.ready;
+        await picturesArrived();
+        await frame();
+        if (released || !(working || calls.size || (live && !live.gate) || rim?.judging() || document.fonts.status === 'loading'))
+            return;
+    }
+}
+/** Resolves when every `<img>` of the document's top-level boxes that was still loading has loaded or failed. */
+async function picturesArrived() {
+    const pending = (presented?.boxes ?? []).flatMap((box) => [...box.querySelectorAll('img')]).filter((img) => !img.complete);
+    await Promise.all(pending.map((img) => new Promise((resolve) => { img.addEventListener('load', () => resolve(), { once: true }); img.addEventListener('error', () => resolve(), { once: true }); })));
 }
 /** The run that stopped at a page, if there is one (*the pages are cut as far as they are asked*, 2026-10-12): the driver is waiting inside its page loop with its place, its measure context and its Ledger kept, and the pages it has cut are on screen. `run()` with no `resumeAt` on the same mode goes on from here; anything else lets it go. */
 let live = null;
@@ -428,7 +446,7 @@ function show(session, { account, index, total, from, to, resume }) {
     seatDoors(blocks);
     if (!session.hashed) {
         // An address that names a place in the document (`…#chapter`) is a place on a page that may not be built; the browser's own scroll to the fragment ran before there were pages. A place not cut to yet waits for the cut that reaches it.
-        const named = window.location.hash ? document.getElementById(decodeURIComponent(window.location.hash.slice(1))) : null;
+        const named = window.location.hash ? document.getElementById(decodeFragment(window.location.hash)) : null;
         if (!named || !root.contains(named))
             session.hashed = true;
         else if (root.pageOf(named) !== 'not-yet') {

package/dist/seam/index.js

@@ -65,7 +65,7 @@ export const ciceroEngine = {
         return `      if (window.__beltypeCicero) {
         try {
           const cicero = window.__beltypeCicero;
-          const named = location.hash.length > 1 ? document.getElementById(decodeURIComponent(location.hash.slice(1))) : null;
+          const named = location.hash.length > 1 ? document.getElementById((() => { const h = location.hash.slice(1); try { return decodeURIComponent(h); } catch { return h; } })()) : null;
           let answer = await cicero.run({ until: named || 2 });
           if (!answer.complete) {
             const sheet = document.querySelector('beltype-root')?.shadowRoot?.querySelector('beltype-page');

package/dist/seam/rewrite.js

@@ -26,7 +26,7 @@
  * @packageDocumentation
  */
 import { parse, walk } from './csstree.js';
-import { STRING_SET_PROP, RUNNING_PROP, encodeString, encodeElement, encodePageName, BLANK_SUFFIX, encodeRead, parseReadFunction, READ_PREFIX, encodeStringProp } from '../src/gcpm-encoding.js';
+import { STRING_SET_PROP, RUNNING_PROP, HYPHENATE_LIMIT_LINES_PROP, encodeString, encodeElement, encodePageName, BLANK_SUFFIX, encodeRead, parseReadFunction, READ_PREFIX, encodeStringProp } from '../src/gcpm-encoding.js';
 import { MARGIN_BOXES } from '../src/margin-boxes.js';
 import { FRAGMENT_GUARD, HAS_PROPERTY_PREFIX, HAS_REGISTRY_SELECTOR, encodeHasArgument, encodeHasUnion } from '../src/data-beltype.js';
 /** Splice a list of non-overlapping `{ start, end, text }` edits into a source string, right to left so earlier offsets stay valid. */
@@ -465,6 +465,12 @@ function rewriteText(original, pages = true) {
                 }
                 return;
             }
+            if (property === 'hyphenate-limit-lines') { // Chromium drops it at parse, and the Compositor reads the author's limit from the custom property instead
+                const colon = source.indexOf(':', node.loc.start.offset);
+                if (colon > node.loc.start.offset)
+                    edits.push({ start: node.loc.start.offset, end: colon, text: HYPHENATE_LIMIT_LINES_PROP });
+                return;
+            }
             if (property === 'position') {
                 const m = /^running\(\s*([^\s)]+)\s*\)$/i.exec(textOf(source, node.value));
                 if (m) {

package/dist/seam/rim.d.ts

@@ -41,7 +41,7 @@ export declare function bringsNewFace(event: Event): boolean;
  * @param p.idle - resolves when no run is under way and nothing the rim told is still being answered: a size is judged then, against the table the run leaves.
  * @param p.unbuilt - whether some page of the presentation is not built yet: a picture's box that is not drawn as itself may stand on it, and is judged again when the observer next reports. Absent, every page is built.
  * @param p.busy - whether a run is under way or a signal is being answered now: asked again just before a size is judged, since a named signal may have come while the ear waited for the frame.
- * @returns `add` subscribes to a box, releasing what the box it replaced (a patched edit) and the box itself already held, so one load is one signal; `pieces` observes the pieces a page was just built with, each beside its source box, and lets go of the ones a presentation took out; `stop` releases everything.
+ * @returns `add` subscribes to a box, releasing what the box it replaced (a patched edit) and the box itself already held, so one load is one signal; `pieces` observes the pieces a page was just built with, each beside its source box, and lets go of the ones a presentation took out; `judging` says whether a size or a picture was heard and not yet judged; `stop` releases everything.
  */
 export declare function watchLateTruth({ document: doc, fonts, originals, onSignal, presented, pageHolding, measured, idle, busy, unbuilt }: {
     document: Document;
@@ -60,6 +60,7 @@ export declare function watchLateTruth({ document: doc, fonts, originals, onSign
     unbuilt?: () => boolean;
 }): {
     stop: () => void;
+    judging: () => boolean;
     add: (box: Element, replaced?: Element) => void;
     pieces: (built: Array<[Element, Element]>, removed: Iterable<Element>) => void;
 };

package/dist/seam/rim.js

@@ -75,7 +75,7 @@ export function bringsNewFace(event) {
  * @param p.idle - resolves when no run is under way and nothing the rim told is still being answered: a size is judged then, against the table the run leaves.
  * @param p.unbuilt - whether some page of the presentation is not built yet: a picture's box that is not drawn as itself may stand on it, and is judged again when the observer next reports. Absent, every page is built.
  * @param p.busy - whether a run is under way or a signal is being answered now: asked again just before a size is judged, since a named signal may have come while the ear waited for the frame.
- * @returns `add` subscribes to a box, releasing what the box it replaced (a patched edit) and the box itself already held, so one load is one signal; `pieces` observes the pieces a page was just built with, each beside its source box, and lets go of the ones a presentation took out; `stop` releases everything.
+ * @returns `add` subscribes to a box, releasing what the box it replaced (a patched edit) and the box itself already held, so one load is one signal; `pieces` observes the pieces a page was just built with, each beside its source box, and lets go of the ones a presentation took out; `judging` says whether a size or a picture was heard and not yet judged; `stop` releases everything.
  */
 export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, onSignal, presented = () => false, pageHolding = () => null, measured = () => undefined, idle = async () => { }, busy = () => false, unbuilt = () => false }) {
     const win = doc.defaultView;
@@ -269,6 +269,8 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
     releases.push(() => doc.removeEventListener('beltype:change', foreign));
     return {
         add,
+        /** Is a size or a picture heard and not yet judged? The client's `settled` waits for it. */
+        judging: () => judging,
         pieces(built, removed) {
             for (const el of removed) {
                 if (!pieces.delete(el))

package/dist/src/capture.js

@@ -932,29 +932,16 @@ function compareSpecificity(a, b) {
             return a[i] - b[i];
     return 0;
 }
-/** Margin-box declarations out of a CSSPageRule — via child CSSMarginRule objects where the engine exposes them, else a cssText walk. Returns { 'bottom-center': rawContentValue, ... }. */
+/** Margin-box declarations out of a CSSPageRule — via the child CSSMarginRule objects (the pinned Chromium has them; `margin-box-padding.browser.ts` asserts it). Returns { 'bottom-center': rawContentValue, ... }. */
 function marginBoxesOf(rule) {
     const out = {};
-    if (rule.cssRules) {
-        for (const child of rule.cssRules) {
-            const name = (child.name ?? child.selectorText ?? '').replace(/^@/, '');
-            if (MARGIN_BOXES.includes(name)) {
-                const content = child.style?.getPropertyValue('content');
-                if (content)
-                    out[name] = content.trim();
-            }
+    for (const child of (rule.cssRules ?? [])) {
+        const name = (child.name ?? child.selectorText ?? '').replace(/^@/, '');
+        if (MARGIN_BOXES.includes(name)) {
+            const content = child.style?.getPropertyValue('content');
+            if (content)
+                out[name] = content.trim();
         }
-        if (Object.keys(out).length)
-            return out;
-    }
-    const re = /@([a-z-]+)\s*\{([^}]*)\}/g;
-    let m;
-    while ((m = re.exec(rule.cssText))) {
-        if (!MARGIN_BOXES.includes(m[1]))
-            continue;
-        const c = /content\s*:\s*([^;}]+)/.exec(m[2]);
-        if (c)
-            out[m[1]] = c[1].trim();
     }
     return out;
 }

package/dist/src/compose-dom.d.ts

@@ -52,6 +52,10 @@ export type CompositionRecord = {
  * It used to ask only the children's display, so a `<pre>`, an SVG's `<text>` and an inline `<code>` were paragraphs. The children's display is asked through `word-space.js`' `isInlineBox`, the procession's one predicate (*the outer display decides*, 2026-09-29): it used to be a second copy of the `inline` prefix test, so a paragraph holding an inline formula, whose `<math>` computes `math`, was refused here while the procession, once fixed, divided it. Every refusal here is silent: a refused block keeps the browser's lines, which are the only lines it has.
  */
 export declare function isComposable(el: Element): boolean;
+/**
+ * A sixth clause: a block in a multi-column container, or itself one, keeps the browser's lines. The Compositor has one measure per block and reads it from the block's own box, not from a column's, so a `columns: 3` box 210px wide was set at the container's measure, the longest line 356px against a column of 70. Refused like a block beside a float, with a console line (`refusedInColumns`); the real fix is a per-column measure and the fragmentation of a multi-column box, which is not this engine's yet.
+ */
+export declare function inColumns(el: Element): boolean;
 /**
  * Words and author-break runs of an element, with DOM points. A word is a maximal non-whitespace run of text not crossing a <br>; nested inlines merge (parts). Returns { words: [{ text, parts: [{node, start, end}] }], runs: [{ start, end }] } where runs index into words, end exclusive.
  *
@@ -74,6 +78,10 @@ export declare function collectWords(el: Element): {
 export declare function hyphenCharOf(style: {
     hyphenateCharacter?: string;
 }): string;
+/**
+ * css-text-4 §6.3.5's `hyphenate-limit-lines`, read from the custom property the host rewrote it into (Chromium drops the property itself): `no-limit` is `null`, an integer is the limit, and an absent or unreadable value is the engine's own {@link HYPHENATE_LIMIT_LINES}.
+ */
+export declare function limitLinesOf(style: CSSStyleDeclaration): number | null;
 /** Two border-box rects overlapping in both axes, sub-pixel noise excluded. The geometry half of the beside-a-float refusal below, exported so it is checkable without a browser; what it cannot say is which boxes were handed to it, which is the case runner's job. */
 export declare function overlaps(a: {
     top: number;

package/dist/src/compose-dom.js

@@ -10,11 +10,12 @@
  * @packageDocumentation
  */
 import { compose, HYPHENATE_LIMIT_LINES } from './compositor.js';
+import { HYPHENATE_LIMIT_LINES_PROP } from './gcpm-encoding.js';
 import { addWord, AWAY, BREAK, FILL, hasWord } from './data-beltype.js';
 import { createMeasureContext } from './measure.js';
 import { indexBlocks, pageIntervals, presentationWidths } from './positions.js';
 import { hyphenationOffsets, languageFor, resolveLimits } from './hyphenate.js';
-import { BREAKING_SPACE, measuringCopyOf, HTML_NS, isAtom, isFixedBox, isInlineBox, isInlineLevel, noteEngineText, rangeOf, sourceOf, splitTextAt, UNSPACED_SCRIPT } from './word-space.js';
+import { BREAKING_SPACE, measuringCopyOf, HTML_NS, isAtom, isFixedBox, isInlineBox, isInlineLevel, isOutsideMarker, noteEngineText, rangeOf, sourceOf, splitTextAt, UNSPACED_SCRIPT } from './word-space.js';
 import { attributesOf, blockKey, CompositionCache, lookup, paragraphKey, remember, shapeOf } from './composition-key.js';
 /** The computed displays of a block container, one of which a paragraph's own box must have (*the paragraph is what the browser breaks*, clause one). */
 const PARAGRAPH_DISPLAY = new Set(['block', 'flow-root', 'list-item', 'table-cell', 'table-caption']);
@@ -41,16 +42,30 @@ export function isComposable(el) {
     for (const child of el.children) {
         if (child.tagName === 'BR')
             continue;
-        if (!isInlineBox(child))
+        if (!isInlineBox(child) && !isOutsideMarker(child))
             return false;
     }
     for (let a = el.parentElement; a; a = a.parentElement)
         if (isAtom(a))
             return false;
+    if (inColumns(el))
+        return false;
     if (holdsGeneratedText(el, win))
         return false;
     return collectWords(el).words.some((w) => !w.atom);
 }
+/**
+ * A sixth clause: a block in a multi-column container, or itself one, keeps the browser's lines. The Compositor has one measure per block and reads it from the block's own box, not from a column's, so a `columns: 3` box 210px wide was set at the container's measure, the longest line 356px against a column of 70. Refused like a block beside a float, with a console line (`refusedInColumns`); the real fix is a per-column measure and the fragmentation of a multi-column box, which is not this engine's yet.
+ */
+export function inColumns(el) {
+    const win = el.ownerDocument.defaultView;
+    for (let a = el; a; a = a.parentElement) {
+        const cs = win.getComputedStyle(a);
+        if (cs.columnCount !== 'auto' || cs.columnWidth !== 'auto')
+            return true;
+    }
+    return false;
+}
 /**
  * Does this pseudo-element put a box in its element's lines? Its `content` must generate one — `none` and `normal` do not — and its outer display must be inline: a `display: block` `::after` is a block of its own after the lines, not text in them.
  *
@@ -104,6 +119,9 @@ export function collectWords(el) {
                     i = j;
                 }
             }
+            else if (child.nodeType === 1 && isOutsideMarker(child)) {
+                // a hanging number: out of the text being set
+            }
             else if (child.nodeType === 1 && child.tagName === 'BR') {
                 current = null;
                 if (words.length && runStarts[runStarts.length - 1] !== words.length)
@@ -176,6 +194,16 @@ export function hyphenCharOf(style) {
         return raw;
     return raw.slice(1, -1).replace(/\\(.)/g, '$1');
 }
+/**
+ * css-text-4 §6.3.5's `hyphenate-limit-lines`, read from the custom property the host rewrote it into (Chromium drops the property itself): `no-limit` is `null`, an integer is the limit, and an absent or unreadable value is the engine's own {@link HYPHENATE_LIMIT_LINES}.
+ */
+export function limitLinesOf(style) {
+    const raw = style.getPropertyValue(HYPHENATE_LIMIT_LINES_PROP).trim();
+    if (raw === 'no-limit')
+        return null;
+    const n = /^\d+$/.test(raw) ? parseInt(raw, 10) : NaN;
+    return Number.isFinite(n) && n >= 1 ? n : HYPHENATE_LIMIT_LINES;
+}
 /**
  * css-text-4 §6.3.4's `hyphenate-limit-chars` as three values, `null` for each `auto`.
  *
@@ -367,16 +395,27 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
         }
         // A float's own descendants are laid out in the float's own formatting context at the float's own width, which is exactly what their rect reports — nothing is refused there. What is refused is a block the float reaches into: a sibling it stands beside, or an ancestor whose line boxes it is nested in.
         const intrudedByFloat = (clone, rect) => floats.some((f) => !f.el.contains(clone) && overlaps(rect, f.rect));
+        /** The block's content box: a float wholly in the padding or the border (a hanging number) shortens none of its line boxes, so it is the content box the float's rect is compared with. */
+        const contentBoxOf = (cs, rect) => {
+            const left = rect.left + parseFloat(cs.borderLeftWidth) + parseFloat(cs.paddingLeft);
+            const top = rect.top + parseFloat(cs.borderTopWidth) + parseFloat(cs.paddingTop);
+            return { left, top, right: rect.right - parseFloat(cs.borderRightWidth) - parseFloat(cs.paddingRight), bottom: rect.bottom - parseFloat(cs.borderBottomWidth) - parseFloat(cs.paddingBottom) };
+        };
         const refusedBesideFloat = [];
         /** A second refusal, of the same kind and for the same reason (*a line inside a word is a break point*, 2026-09-23). The Compositor's break opportunities are spaces, hyphenation points and css-text-4 §6.4's emergency break; a block whose text the browser may break anywhere else — `word-break: break-all`, `line-break: anywhere`, or a script written without spaces (`word-space.js`' `UNSPACED_SCRIPT`) — reaches it as words it cannot divide. Measured on `packages/essay/cases/63-the-line-inside-a-word`: a thirty-line `break-all` paragraph was one word to the DP, set on one nowrap line, and twenty-one of its thirty lines were on no page. So such a block keeps the browser's lines, and the console says so; the real fix is the Compositor learning UAX #14's opportunities, which is a later round. */
         const refusedUnspaced = [];
+        /** A third refusal: a block in a multi-column container (`inColumns`). */
+        const refusedInColumns = [];
         const jobs = [];
         for (const [clone, source] of cloneToSource) {
-            if (!isComposable(clone))
+            if (!isComposable(clone)) {
+                if (inColumns(clone) && PARAGRAPH_DISPLAY.has(win.getComputedStyle(clone).display))
+                    refusedInColumns.push(source);
                 continue;
+            }
             const cs = win.getComputedStyle(clone);
             const rect = clone.getBoundingClientRect();
-            if (floats.length && intrudedByFloat(clone, rect)) {
+            if (floats.length && intrudedByFloat(clone, contentBoxOf(cs, rect))) {
                 refusedBesideFloat.push(source);
                 continue;
             }
@@ -393,12 +432,13 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
             const indent = parseFloat(sourceStyle.textIndent) || 0;
             const hyphenChar = hyphenCharOf(sourceStyle);
             const limits = limitCharsOf(sourceStyle);
+            const limitLines = limitLinesOf(sourceStyle);
             const breakAnywhere = ['anywhere', 'break-word'].includes(sourceStyle.overflowWrap);
             const paragraph = paragraphKey({
                 path: pathToSource.get(source),
                 markup: shapeOf(source.outerHTML),
                 width: key,
-                inputs: [align, indent, hyphensMode, langAttr ?? null, hyphenChar, limits.total, limits.before, limits.after, breakAnywhere, sourceStyle.wordBreak, sourceStyle.lineBreak, ...WIDTH_INPUTS.map((name) => sourceStyle[name]), ancestryOf(source)]
+                inputs: [align, indent, hyphensMode, langAttr ?? null, hyphenChar, limits.total, limits.before, limits.after, limitLines, breakAnywhere, sourceStyle.wordBreak, sourceStyle.lineBreak, ...WIDTH_INPUTS.map((name) => sourceStyle[name]), ancestryOf(source)]
             });
             const hit = lookup(cache, paragraph);
             if (hit) {
@@ -420,6 +460,7 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
                 // The three css-text-4 properties the line already had and this module was not reading (2026-09-07). All three are inherited, so the block's own computed style is the whole answer.
                 hyphenChar,
                 limits,
+                limitLines,
                 breakAnywhere
             });
         }
@@ -432,8 +473,18 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
                 c.style.textIndent = '0';
                 return c;
             });
+            // A nested paragraph is measured inside shallow copies of its ancestors up to its top-level block, or it loses what it inherits from them and what a descendant selector reads: a pull quote's `blockquote { font: italic 22px serif }` measured at the measure container's 16px set lines 22% too wide for the box (`composed-pull-quote-overrun`). ponytail: shallow copies carry attributes only, so a sibling selector (`p + p`, `:first-child`) still reads the lone copy; clone the earlier siblings too if one is ever measured wrong.
+            const measureRoots = jobs.map((j, i) => {
+                let top = nowrapClones[i];
+                for (let cur = j.source; !tops.has(cur) && cur.parentElement; cur = cur.parentElement) {
+                    const wrap = cur.parentElement.cloneNode(false);
+                    wrap.appendChild(top);
+                    top = wrap;
+                }
+                return top;
+            });
             const probes = jobs.map((job, i) => seatHyphenProbe(nowrapClones[i], job.hyphenChar));
-            ctx.measure(nowrapClones);
+            ctx.measure(measureRoots);
             // One pass reading, one pass removing: the removal is the last write, so the layout it forces is the last one the composition pays for. `collectWords` runs after it, or a probe's character would be a word.
             const hyphenWidths = probes.map(probeWidth);
             for (const probe of probes)
@@ -463,7 +514,7 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
                         indent: r === 0 ? job.indent : 0,
                         align: job.align,
                         breakAnywhere: job.breakAnywhere,
-                        limitLines: HYPHENATE_LIMIT_LINES
+                        limitLines: job.limitLines
                     });
                     record.runs.push({ start: runs[r].start, ...result });
                     record.lineCount += result.lineCount;
@@ -472,7 +523,7 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
                 resolved.set(job.source, record);
             });
         }
-        return { floaty: floats.length > 0, refusedBesideFloat, refusedUnspaced };
+        return { floaty: floats.length > 0, refusedBesideFloat, refusedUnspaced, refusedInColumns };
     };
     let todo = blocks.map((_, i) => i).filter((i) => !(trustMemo && memos?.[i]));
     let laid = lay(todo);
@@ -510,13 +561,18 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
             tally.blocks.set(memoKeys[i], { records, floaty: laid.floaty, refused: laid.refusedUnspaced.filter((src) => el.contains(src)).length });
         }
     }
-    const { refusedBesideFloat, refusedUnspaced } = laid;
+    const { refusedBesideFloat, refusedUnspaced, refusedInColumns } = laid;
     // Never in silence — the render-conditions rule, applied to a decision the engine declines to take rather than to one it takes under a relaxation.
     if (refusedBesideFloat.length) {
         win.console?.warn(`BelType/Cicero: ${refusedBesideFloat.length} block(s) sit beside a float and are NOT composed by this engine — ` +
             'their lines are the browser\'s, because a float shortens line boxes and the Compositor has one measure per block, not one per line. ' +
             'The pages are honest; the line breaking in those blocks is not this engine\'s.');
     }
+    if (refusedInColumns.length) {
+        win.console?.warn(`BelType/Cicero: ${refusedInColumns.length} block(s) sit in a multi-column container and are NOT composed by this engine — ` +
+            'their lines are the browser\'s, because the Compositor has one measure per block, not one per column. ' +
+            'The pages are honest; the line breaking in those blocks is not this engine\'s.');
+    }
     const refusedCount = refusedUnspaced.length + refusedFromMemo;
     if (refusedCount) {
         win.console?.warn(`BelType/Cicero: ${refusedCount} block(s) may break lines inside a word — word-break: break-all, line-break: anywhere, or a script written without spaces — and are NOT composed by this engine; ` +

package/dist/src/data-beltype.d.ts

@@ -60,6 +60,7 @@ export declare const FILL = "fill";
 export declare const WRAPPED = "wrapped";
 export declare const ADJOIN = "adjoin";
 export declare const AWAY = "away";
+export declare const ONE_COLUMN = "one-column";
 /** PDF's own name for pagination furniture: a copy the engine repeats that a reader does not read (the registry entry says which). */
 export declare const ARTIFACT = "artifact";
 /** The words that mark an element as the engine's own — what the "class starts with `__beltype-`" test used to say, as a named set: a divided box (it carried `__beltype-cont` or `-cut`, and a first fragment `-first`), a fixed box's copy, and the three elements the engine creates. `fragment` is not here: a composed block's clone carried no class and was never an engine mark. */
@@ -160,6 +161,13 @@ export declare const CUT_OFF: string;
  * - A resumed piece gives up the margin that adjoins the break, and the indent (the box is not beginning); and, unless the box wraps each fragment whole (`wrapped`, css-break-3 §5.4's `clone`), its border, its padding and its corners' rounding at that edge: a slice is the box cut through, so the cut edge is square (Chromium's print, measured 2026-11-07).
  * - A resumed piece's counter operations already happened where the box began (`counter-reset`, `counter-increment` and `counter-set` are `none` on it): the page's start delivers the counters as they stood (`chase.js`'s `setCounters`), and a clone that fired them again would count the box twice.
  * - A cut-off piece gives up the margin before the break, and unless `wrapped` its border, padding and rounding there.
+ * - `one-column`: a multi-column box too tall for any page is laid out as one column, since the engine does not divide columns yet (`src/scope.ts`).
  * - `adjoin`: the box a bare-path cut resumes at, and the first-child chain through which its margin collapses, give up the margin that adjoins the break (css-break-3 §5.2) and nothing else — they are not divided.
  */
 export declare const WORDS_RULES: string;
+/**
+ * The id a URL fragment names, percent-decoded; the raw text when it is not valid percent-encoding (`#%E0%A4%A`), where `decodeURIComponent` throws.
+ *
+ * @param hash - A `location.hash`, with or without its `#`.
+ */
+export declare function decodeFragment(hash: string): string;

package/dist/src/data-beltype.js

@@ -39,6 +39,7 @@ export const REGISTRY = Object.freeze([
     { name: 'adjoin', kind: 'flag', status: 'in use', writer: 'engine', from: 'cut', facing: 'engine', meaning: 'the first-child chain after a cut BETWEEN boxes: its block-start margin adjoins the cut and is truncated, and the box is not divided' },
     { name: 'away', kind: 'flag', status: 'in use', writer: 'engine', from: 'cut', facing: 'engine', meaning: 'a box put away on this page (`display: none`): kept as an element so structural selectors read as in the source' },
     { name: 'host', kind: 'flag', status: 'in use', writer: 'host', from: 'host', facing: 'engine', meaning: 'the host\'s word on an element of its own machinery that stands among the document\'s boxes (a hidden `<iframe>`, a probe); the intake passes over it, so it gets no address and moves none (ruled 2026-11-08)' },
+    { name: 'one-column', kind: 'flag', status: 'in use', writer: 'engine', from: 'original', facing: 'engine', meaning: 'a multi-column box too tall for any page, laid out as one column on its copies because the engine does not yet divide columns (the console names the element)' },
     { name: 'artifact', kind: 'flag', status: 'in use', writer: 'engine', from: 'cut', facing: 'host', meaning: 'a copy the engine repeats that is not the one a reader reads: a running element\'s copy in a margin box, a fixed box\'s copy on every page after the first, and a table\'s repeated header or footer group; PDF\'s own word for pagination furniture, and nothing else. Every artifact is also aria-hidden' }
 ].map((e) => Object.freeze(e)));
 /** The flags in use. */
@@ -63,6 +64,7 @@ export const FILL = 'fill';
 export const WRAPPED = 'wrapped';
 export const ADJOIN = 'adjoin';
 export const AWAY = 'away';
+export const ONE_COLUMN = 'one-column';
 /** PDF's own name for pagination furniture: a copy the engine repeats that a reader does not read (the registry entry says which). */
 export const ARTIFACT = 'artifact';
 /** The words that mark an element as the engine's own — what the "class starts with `__beltype-`" test used to say, as a named set: a divided box (it carried `__beltype-cont` or `-cut`, and a first fragment `-first`), a fixed box's copy, and the three elements the engine creates. `fragment` is not here: a composed block's clone carried no class and was never an engine mark. */
@@ -300,6 +302,7 @@ const RESUMED_BOX = `${RESUMED}:not(${w(SHELL)})`;
  * - A resumed piece gives up the margin that adjoins the break, and the indent (the box is not beginning); and, unless the box wraps each fragment whole (`wrapped`, css-break-3 §5.4's `clone`), its border, its padding and its corners' rounding at that edge: a slice is the box cut through, so the cut edge is square (Chromium's print, measured 2026-11-07).
  * - A resumed piece's counter operations already happened where the box began (`counter-reset`, `counter-increment` and `counter-set` are `none` on it): the page's start delivers the counters as they stood (`chase.js`'s `setCounters`), and a clone that fired them again would count the box twice.
  * - A cut-off piece gives up the margin before the break, and unless `wrapped` its border, padding and rounding there.
+ * - `one-column`: a multi-column box too tall for any page is laid out as one column, since the engine does not divide columns yet (`src/scope.ts`).
  * - `adjoin`: the box a bare-path cut resumes at, and the first-child chain through which its margin collapses, give up the margin that adjoins the break (css-break-3 §5.2) and nothing else — they are not divided.
  */
 export const WORDS_RULES = `
@@ -310,5 +313,20 @@ export const WORDS_RULES = `
   ${CUT_OFF} { margin-bottom: 0 !important; }
   ${CUT_OFF}:not(${w(WRAPPED)}) { border-bottom-width: 0 !important; padding-bottom: 0 !important; border-bottom-left-radius: 0 !important; border-bottom-right-radius: 0 !important; }
   ${w(ADJOIN)} { margin-top: 0 !important; }
+  ${w(ONE_COLUMN)} { column-count: auto !important; column-width: auto !important; }
 }
 `;
+/**
+ * The id a URL fragment names, percent-decoded; the raw text when it is not valid percent-encoding (`#%E0%A4%A`), where `decodeURIComponent` throws.
+ *
+ * @param hash - A `location.hash`, with or without its `#`.
+ */
+export function decodeFragment(hash) {
+    const raw = hash.startsWith('#') ? hash.slice(1) : hash;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+}

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

@@ -13,7 +13,7 @@
  *
  * **A position is the flat word index** (`positions.js`), and an operation applies when its position is strictly before the one asked about — and not inside a remainder a carried flow has still to show, which stands before the page's first word in document order and is on that page or after it (beltype#43; `positions.js`' `remaindersOf`). That is §6.1's *"the deepest element in the normal flow that spans the page break"* said in this engine's own space: an element whose first word is the page's first word begins on the new page and does not span the break, so its own operation is not yet in force, while an element that spans the break started before that word and is included. The ancestors above the top-level blocks sit at position **−1** — they open before the document's first word and span every break there is — which is what makes the first page's answer fall out of the same comparison rather than needing a case of its own.
  *
- * **What is not read, each a real gap and each showing as a counter reading low.** css-lists-3's `reversed()` counters (an author's `counter-reset: reversed(name)`), a top-level `position: fixed` box, which is not among the flow blocks the position index is built over; and a scope that ended before the position asked about with no operation logged between its end and the position, since the replay closes a scope only when an operation at or above its depth arrives: a `counter(list-item)` read on a page past a list whose last item holds a list reads the inner list's count (3 where Chromium prints 2, measured 2026-11-07), and an author's nested reset is read the same way. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A list's and a list item's implicit `list-item` operations are read since 2026-11-07 (`implicitListOps`), so a `counter(list-item)` read on a page a list continued onto or past it counts the items before it. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
+ * **What is not read, each a real gap and each showing as a counter reading low.** css-lists-3's `reversed()` counters (an author's `counter-reset: reversed(name)`), and a top-level `position: fixed` box, which is not among the flow blocks the position index is built over. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A list's and a list item's implicit `list-item` operations are read since 2026-11-07 (`implicitListOps`), so a `counter(list-item)` read on a page a list continued onto or past it counts the items before it. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). A scope that ended before the page with no operation logged between its end and the page's first word is closed since 2026-11-09, by the depth of the page's opening place (`counterStateAt`'s `depth`): until then a `counter(list-item)` read on a page past a list whose last item holds a list read the inner list's count, 3 where Chromium prints 2, and an author's nested reset the same. **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
  *
  * @packageDocumentation
  */
@@ -126,6 +126,16 @@ export declare function documentOpsOf(blocks: ArrayLike<Element>, index: {
     }>;
     keep?: Keep | null;
 }): Op[];
+/**
+ * A log with the document's running elements laid in, each at the position the flow stood at where it was written: {@link documentOpsOf}'s `running`, for a log walked without them.
+ *
+ * @remarks
+ * A running element has no word of its own, so it joins the log before every operation past its position: the log stays in position order, which the replay's early stop needs. Its depth is infinite, so it ends no counter scope.
+ */
+export declare function withRunning(ops: Op[], running: ReadonlyArray<{
+    name: string;
+    pos: number;
+}>): Op[];
 /**
  * The document's counters at a position — every operation strictly before it, replayed under CSS 2.1's *Nested counters and scope*.
  *
@@ -133,12 +143,13 @@ export declare function documentOpsOf(blocks: ArrayLike<Element>, index: {
  *
  * @param pos - the flat word position asked about — for a page, its first word.
  * @param away - the remainders the page's opening cut carries in (`positions.js`' `remaindersOf`): an operation before `pos` inside one of them is on this page or a later one, not on a page before it, and is not yet in force (beltype#43). The replay still runs in document order.
+ * @param depth - the depth in the log's terms of the place `pos` names (`driver.ts`' `depthOfCut`): every instance created deeper is ended there, as an operation at that depth would end it, so a scope that ended before the page with nothing logged between is closed (cicero-counter-scope-stays-open-at-page, 2026-11-09). Absent, the replay keeps what the last operation before `pos` left open.
  * @returns per counter name, the values of every instance in scope, outermost first. Plain data, so it crosses a `page.evaluate` boundary in the account's `closes` like every other condition.
  */
 export declare function counterStateAt(ops: ReturnType<typeof documentOpsOf>, pos: number, away?: ReadonlyArray<{
     from: number;
     to: number;
-}>): Record<string, number[]>;
+}>, depth?: number): Record<string, number[]>;
 /** What the page context's own rules do to the page counter on one page: the `page` value of the winning `counter-reset`, `counter-increment` and `counter-set` of the `@page` rules that apply to it, `null` where the winning declaration names no `page` (`capture.ts`'s `pageFor`). */
 export type PageCounterOps = {
     reset: number | null;

package/dist/src/document-state.js

@@ -13,7 +13,7 @@
  *
  * **A position is the flat word index** (`positions.js`), and an operation applies when its position is strictly before the one asked about — and not inside a remainder a carried flow has still to show, which stands before the page's first word in document order and is on that page or after it (beltype#43; `positions.js`' `remaindersOf`). That is §6.1's *"the deepest element in the normal flow that spans the page break"* said in this engine's own space: an element whose first word is the page's first word begins on the new page and does not span the break, so its own operation is not yet in force, while an element that spans the break started before that word and is included. The ancestors above the top-level blocks sit at position **−1** — they open before the document's first word and span every break there is — which is what makes the first page's answer fall out of the same comparison rather than needing a case of its own.
  *
- * **What is not read, each a real gap and each showing as a counter reading low.** css-lists-3's `reversed()` counters (an author's `counter-reset: reversed(name)`), a top-level `position: fixed` box, which is not among the flow blocks the position index is built over; and a scope that ended before the position asked about with no operation logged between its end and the position, since the replay closes a scope only when an operation at or above its depth arrives: a `counter(list-item)` read on a page past a list whose last item holds a list reads the inner list's count (3 where Chromium prints 2, measured 2026-11-07), and an author's nested reset is read the same way. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A list's and a list item's implicit `list-item` operations are read since 2026-11-07 (`implicitListOps`), so a `counter(list-item)` read on a page a list continued onto or past it counts the items before it. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
+ * **What is not read, each a real gap and each showing as a counter reading low.** css-lists-3's `reversed()` counters (an author's `counter-reset: reversed(name)`), and a top-level `position: fixed` box, which is not among the flow blocks the position index is built over. `display: none` elements are skipped, which is CSS 2.1's own rule rather than an omission. A list's and a list item's implicit `list-item` operations are read since 2026-11-07 (`implicitListOps`), so a `counter(list-item)` read on a page a list continued onto or past it counts the items before it. A `::before`'s and an `::after`'s counters are read since 2026-11-07, where a sheet sets one (`pseudoStyleOf`). A scope that ended before the page with no operation logged between its end and the page's first word is closed since 2026-11-09, by the depth of the page's opening place (`counterStateAt`'s `depth`): until then a `counter(list-item)` read on a page past a list whose last item holds a list read the inner list's count, 3 where Chromium prints 2, and an author's nested reset the same. **And `content(before)`, `content(after)` and `content(first-letter)` are read as `content()`** — a stated limit rather than a discovered one: a pseudo-element's own string is generated content this walk does not see, and answering the element's text is the nearest honest answer there is.
  *
  * @packageDocumentation
  */
@@ -354,9 +354,17 @@ export function documentOpsOf(blocks, index, { styleOf, pseudoStyleOf = null, te
         for (const op of part.ops)
             ops.push({ ...op, pos: start + op.pos, depth: base + op.depth });
     }
+    return withRunning(ops, running);
+}
+/**
+ * A log with the document's running elements laid in, each at the position the flow stood at where it was written: {@link documentOpsOf}'s `running`, for a log walked without them.
+ *
+ * @remarks
+ * A running element has no word of its own, so it joins the log before every operation past its position: the log stays in position order, which the replay's early stop needs. Its depth is infinite, so it ends no counter scope.
+ */
+export function withRunning(ops, running) {
     if (!running.length)
         return ops;
-    // A running element has no word of its own, so it joins the log at the position the flow stood at, before every operation past it: the log stays in position order, which the replay's early stop needs. Its depth is infinite, so it ends no counter scope.
     const merged = [];
     let r = 0;
     for (const op of ops) {
@@ -377,10 +385,11 @@ const runningOp = (r, at) => ({ reset: [], increment: [], set: [], strings: null
  *
  * @param pos - the flat word position asked about — for a page, its first word.
  * @param away - the remainders the page's opening cut carries in (`positions.js`' `remaindersOf`): an operation before `pos` inside one of them is on this page or a later one, not on a page before it, and is not yet in force (beltype#43). The replay still runs in document order.
+ * @param depth - the depth in the log's terms of the place `pos` names (`driver.ts`' `depthOfCut`): every instance created deeper is ended there, as an operation at that depth would end it, so a scope that ended before the page with nothing logged between is closed (cicero-counter-scope-stays-open-at-page, 2026-11-09). Absent, the replay keeps what the last operation before `pos` left open.
  * @returns per counter name, the values of every instance in scope, outermost first. Plain data, so it crosses a `page.evaluate` boundary in the account's `closes` like every other condition.
  */
-export function counterStateAt(ops, pos, away = []) {
-    return replay(ops, { until: pos, away });
+export function counterStateAt(ops, pos, away = [], depth = Infinity) {
+    return replay(ops, { until: pos, away, depth });
 }
 /** No page-context rule touches the page counter. */
 export const NO_PAGE_COUNTER_OPS = Object.freeze({ reset: null, increment: null, set: null });
@@ -452,7 +461,7 @@ export function withoutPageCounters(state) {
     return out;
 }
 /** One replay, two readers. `counterStateAt` stops at a position and returns the state there; `stringAssignmentsOf` runs the log out and is handed the state at each element that assigns a named string. Written once because the scope arithmetic is the delicate part and two copies of it would agree only until one of them was fixed. */
-function replay(ops, { until = Infinity, onOp = null, away = [] } = {}) {
+function replay(ops, { until = Infinity, onOp = null, away = [], depth = Infinity } = {}) {
     /**
      * @type name → [{ depth, value }], innermost last.
      */
@@ -496,6 +505,10 @@ function replay(ops, { until = Infinity, onOp = null, away = [] } = {}) {
         if (onOp && (op.strings || op.mark))
             onOp(op, snapshot());
     }
+    // The place asked about is entered as an element at `depth` would be: what was created deeper has had its parent left behind.
+    for (const stack of scopes.values())
+        while (stack.length && stack[stack.length - 1].depth > depth)
+            stack.pop();
     return snapshot();
 }
 /** One `<content-list>` term against the element's own facts and the counter state in force at it. */