@beltype/cicero 0.1.10 → 0.1.11

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';
@@ -428,7 +428,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/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,6 +10,7 @@
  * @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';
@@ -47,10 +48,24 @@ export function isComposable(el) {
     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.
  *
@@ -176,6 +191,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 +392,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 +429,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 +457,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 +470,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 +511,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 +520,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 +558,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

@@ -163,3 +163,9 @@ export declare const CUT_OFF: string;
  * - `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

@@ -312,3 +312,17 @@ export const WORDS_RULES = `
   ${w(ADJOIN)} { margin-top: 0 !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/fragmentation.d.ts

@@ -2,11 +2,11 @@
  * The fragmentation face: the engine's members a view adapter builds on, `@beltype/cicero/fragmentation`.
  *
  * @remarks
- * Exactly the names the first view adapter imported by deep path on 2026-10-29 (68 of them, from 16 modules), re-exported unchanged, and the names a view has asked for since (the leading-decoration door, `WRAPPED`, `clonesDecoration` and `truncateLeadingDecoration`, 2026-11-07); nothing is un-exported. Which of them stay public, merge or leave is the shape round's question. The face loads in node: `chase.ts`, which defines the `<beltype-page>` element and so needs a DOM at load, is not here; a view imports it for that effect as `@beltype/cicero/internal/chase`.
+ * Exactly the names the first view adapter imported by deep path on 2026-10-29 (68 of them, from 16 modules), re-exported unchanged, and the names a view has asked for since (the leading-decoration door, `WRAPPED`, `clonesDecoration` and `truncateLeadingDecoration`, 2026-11-07); nothing is un-exported. Which of them stay public, merge or leave is the shape round's question. The face loads in node: `chase.ts`, which defines the `<beltype-page>` element and so needs a DOM at load, is not here; a view imports it for that effect as `@beltype/cicero/page`.
  *
  * @packageDocumentation
  */
-export { effectivePageName, readGeometryTable, registerGcpmProperties, topLevelReach, transliterateContent } from './capture.ts';
+export { effectivePageName, readGeometryTable, registerGcpmProperties, sheetReach, topLevelReach, transliterateContent } from './capture.ts';
 export { ADJOIN, ARTIFACT, AWAY, END, FRAGMENT, SHELL, SPLIT, START, WRAPPED, addWord, hasWord, removeWord } from './data-beltype.ts';
 export { counterStateAt, documentOpsOf, namedStringsForPage, runningAssignmentsOf, stringAssignmentsOf } from './document-state.ts';
 export { ensureContinuationDressing, ensureDressing } from './dressing.ts';
@@ -19,6 +19,6 @@ export { STRING_KEYWORDS, encodeStringProp } from './gcpm-encoding.ts';
 export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureContext } from './measure.ts';
 export { divides, elAt, extensionPx, indexBlocks, normalizePath, pageContaining, pageIntervals, pathOf, placeAt } from './positions.ts';
 export { present, presentation } from './presenters.ts';
-export { cssString, findPageSites, settleReads } from './reads.ts';
+export { cssString, findPageSites, findSites, settleReads } from './reads.ts';
 export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.ts';
 export { BREAKING_SPACE, clonesDecoration, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.ts';

package/dist/src/fragmentation.js

@@ -2,11 +2,11 @@
  * The fragmentation face: the engine's members a view adapter builds on, `@beltype/cicero/fragmentation`.
  *
  * @remarks
- * Exactly the names the first view adapter imported by deep path on 2026-10-29 (68 of them, from 16 modules), re-exported unchanged, and the names a view has asked for since (the leading-decoration door, `WRAPPED`, `clonesDecoration` and `truncateLeadingDecoration`, 2026-11-07); nothing is un-exported. Which of them stay public, merge or leave is the shape round's question. The face loads in node: `chase.ts`, which defines the `<beltype-page>` element and so needs a DOM at load, is not here; a view imports it for that effect as `@beltype/cicero/internal/chase`.
+ * Exactly the names the first view adapter imported by deep path on 2026-10-29 (68 of them, from 16 modules), re-exported unchanged, and the names a view has asked for since (the leading-decoration door, `WRAPPED`, `clonesDecoration` and `truncateLeadingDecoration`, 2026-11-07); nothing is un-exported. Which of them stay public, merge or leave is the shape round's question. The face loads in node: `chase.ts`, which defines the `<beltype-page>` element and so needs a DOM at load, is not here; a view imports it for that effect as `@beltype/cicero/page`.
  *
  * @packageDocumentation
  */
-export { effectivePageName, readGeometryTable, registerGcpmProperties, topLevelReach, transliterateContent } from './capture.js';
+export { effectivePageName, readGeometryTable, registerGcpmProperties, sheetReach, topLevelReach, transliterateContent } from './capture.js';
 export { ADJOIN, ARTIFACT, AWAY, END, FRAGMENT, SHELL, SPLIT, START, WRAPPED, addWord, hasWord, removeWord } from './data-beltype.js';
 export { counterStateAt, documentOpsOf, namedStringsForPage, runningAssignmentsOf, stringAssignmentsOf } from './document-state.js';
 export { ensureContinuationDressing, ensureDressing } from './dressing.js';
@@ -18,6 +18,6 @@ export { STRING_KEYWORDS, encodeStringProp } from './gcpm-encoding.js';
 export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureContext } from './measure.js';
 export { divides, elAt, extensionPx, indexBlocks, normalizePath, pageContaining, pageIntervals, pathOf, placeAt } from './positions.js';
 export { present, presentation } from './presenters.js';
-export { cssString, findPageSites, settleReads } from './reads.js';
+export { cssString, findPageSites, findSites, settleReads } from './reads.js';
 export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.js';
 export { BREAKING_SPACE, clonesDecoration, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.js';

package/dist/src/fragments.js

@@ -18,10 +18,10 @@
  * @packageDocumentation
  */
 import { applyRecordsUnder, hyphenCharOf } from './compose-dom.js';
-import { addWord, ADJOIN, ARTIFACT, AWAY, END, ENGINE_MARKS, hasAnyWord, hasWord, removeWord, SHELL, SPLIT, START, WRAPPED } from './data-beltype.js';
+import { addWord, ADJOIN, ARTIFACT, AWAY, BREAK, END, ENGINE_MARKS, hasAnyWord, hasWord, removeWord, SHELL, SPLIT, START, WRAPPED } from './data-beltype.js';
 import { pairsOf } from './document-state.js';
 import { divides, elAtIn, flowsOf } from './positions.js';
-import { BREAKING_SPACE, clonesDecoration, cutRanges, emptyText, inDisplayOrder, leaveOut, replaceChars, isEngineText, mayBeAutoHyphenated, isFixedBox, isInlineBox, isLineBreak, copyOf, shellOf, noteText, READS_ITS_CHILDREN, sourceOf, sourceStyle } from './word-space.js';
+import { BREAKING_SPACE, clonesDecoration, cutRanges, emptyText, inDisplayOrder, leaveOut, replaceChars, isEngineText, mayBeAutoHyphenated, noteEngineText, splitTextAt, isFixedBox, isInlineBox, isLineBreak, copyOf, shellOf, noteText, READS_ITS_CHILDREN, sourceOf, sourceStyle } from './word-space.js';
 /** The word space, clone side: words are maximal non-whitespace runs of the subtree's joined text — a run crossing a text-node or inline-element seam is one word, exactly as the Gauge reads, and exactly as the position index counts over sources (src/positions.js — the two tokenizations must never drift; counting per node instead shifts every offset by the seam-spanning words before it, which the test-document's inline markup caught). **A non-inline boundary ends the run** (word-space.js), which is where this stopped agreeing with the page for two months. This walk survives on the clone side only: consumption must find the resume word's actual text nodes in the mutated copy, which no source-side index can answer. */
 export function joinedWords(root, isInline = isInlineBox) {
     const words = [];
@@ -545,6 +545,7 @@ function consumeTrailingWords(clone, n, char = 0, hollow = false) {
     for (const [node, ranges] of perNode)
         cutRanges(node, ranges);
     // The hyphen is written at the cut (*the hyphen is written at the cut*, 2026-10-06). A soft hyphen the browser broke the line at is drawn there; one at the end of a fragment's last line is not, because nothing breaks after it. So the last kept character, where it is a soft hyphen, becomes the hyphenation character the browser drew — the box's own `hyphenate-character`, else U+2010 (css-text-4 §6.3.2) — and the empty string, which the property allows, removes it. A replacement: the word keeps its length, and the Compositor's own break, whose hyphen is already written and whose soft hyphen stands after it, cuts before the soft hyphen and never meets this.
+    let autoHyphen = null;
     if (char > 0 && words[n].text[char - 1] === '\u00AD') {
         const soft = charRanges(words[n], char - 1, char).find((r) => !r.engine);
         if (soft) {
@@ -558,7 +559,7 @@ function consumeTrailingWords(clone, n, char = 0, hollow = false) {
         const kept = last.find((r) => !r.engine);
         const style = kept && sourceStyle(kept.node.parentElement);
         if (kept && style && !last.some((r) => r.engine) && mayBeAutoHyphenated(words[n].text[char - 1], words[n].text[char], style.hyphens))
-            replaceChars(kept.node, kept.end, kept.end, hyphenCharOf(style));
+            autoHyphen = { node: kept.node, end: kept.end, char: hyphenCharOf(style) };
     }
     leaveOutAfter(clone, keepNode);
     // Structural pass: an element with no remaining words, standing entirely after the boundary, is spent — its edges adjoin the cut (§5.2) and it leaves the fragment.
@@ -582,6 +583,19 @@ function consumeTrailingWords(clone, n, char = 0, hollow = false) {
     })(clone);
     for (const el of spent)
         putAway(el, hollow);
+    // Written last, after the leave-out and the structural pass that would take an element and a text with no source for spent: the hyphen the browser drew stands where the Compositor's stands, a text node of its own, the engine's, before a break mark (*the hyphen is written at the cut*; the printer finds the hyphen by that shape and the letters before it in the source's own run).
+    if (autoHyphen && autoHyphen.char) {
+        const { node, end } = autoHyphen;
+        const parent = node.parentNode;
+        const doc = node.parentElement.ownerDocument;
+        const before = end < node.data.length ? splitTextAt(node, end) : node.nextSibling;
+        const written = doc.createTextNode(autoHyphen.char);
+        noteEngineText(written);
+        const br = doc.createElement('br');
+        addWord(br, BREAK);
+        parent.insertBefore(written, before);
+        parent.insertBefore(br, before);
+    }
     for (let el = inner; el && el !== clone; el = el.parentElement)
         truncateTrailingDecoration(el);
     return inner;
@@ -843,14 +857,14 @@ export function listOrdinals(ol) {
     return out;
 }
 /**
- * Every `<ol>` a cut divides is numbered from the first item its piece keeps: the piece's copy carries a `start` attribute of that item's ordinal, so the browser's own marker counts on from the source's numbering. Without it a continued list numbered from 1 again on every page, and the first piece of a `reversed` list counted down from the items it kept (measured 2026-11-07 against Chromium's print, `test/browser/list-continuation.browser.ts`). Read from the source, so it holds whichever cut ran first.
+ * Every `<ol>` (or numbered `<ul>` or `<menu>`) a cut divides is numbered from the first item its piece keeps: the piece's copy carries a `start` attribute of that item's ordinal, so the browser's own marker counts on from the source's numbering. Without it a continued list numbered from 1 again on every page, and the first piece of a `reversed` list counted down from the items it kept (measured 2026-11-07 against Chromium's print, `test/browser/list-continuation.browser.ts`). Read from the source, so it holds whichever cut ran first.
  */
 function numberDividedLists(root, cut, source, cloneOf) {
     if (!divides(cut) || !source || !cloneOf)
         return;
     const target = elAtIn(source, cut.path);
     for (let a = target?.parentElement ?? null; a; a = a === source ? null : a.parentElement) {
-        if (!/^OL$/i.test(a.tagName))
+        if (!/^(?:OL|UL|MENU)$/i.test(a.tagName))
             continue;
         const copy = cloneOf.get(a);
         if (!copy)
@@ -859,7 +873,11 @@ function numberDividedLists(root, cut, source, cloneOf) {
             const c = cloneOf.get(li);
             if (!c || !root.contains(c) || hasWord(c, AWAY))
                 continue;
-            copy.setAttribute('start', String(n));
+            // HTML's `start` belongs to `<ol>` alone, and Chromium's marker ignores a `counter-reset` of `list-item` (both measured 2026-11-08), so a `ul` or `menu` continues by the first kept item's own `value`.
+            if (/^OL$/i.test(a.tagName))
+                copy.setAttribute('start', String(n));
+            else
+                c.setAttribute('value', String(n));
             break;
         }
     }

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

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

package/dist/src/gcpm-encoding.js

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

package/dist/src/reads.d.ts

@@ -110,6 +110,8 @@ export type PageSite = {
  * @returns null where no rule reads a page fact.
  */
 export declare function findPageSites(doc: Document, originals?: Element[] | null, keep?: Keep | null): PageSite[] | null;
+/** The flow sites that read the page total, as the rule that reads it names them: what {@link hideReservations} paints invisible while the total is unknown, since a flow site reads `0` until then (`chase.ts`'s `setCounters`). A `counter(page)` and a named string are true from the first page and are not among them. */
+export declare function totalSites(doc: Document): Pick<Site, 'key' | 'pseudos'>[];
 /** What every page of a run publishes, as the measure wears it: the page's number and the document's total, and its named strings' properties (`chase.js`'s `setCounters` and `setStrings`, the same values). */
 export declare function pageFactsOf(account: Array<{
     closes: {
@@ -143,13 +145,13 @@ export declare const isDeliverySheet: (doc: Document, sheet: CSSStyleSheet) => b
  * @param sites - the page reads that are still at the reservation.
  * @param scope - the selector of the element the presented pages stand in.
  */
-export declare function hideSheetText(sites: Site[], scope?: string): string;
+export declare function hideSheetText(sites: Pick<Site, 'key' | 'pseudos'>[], scope?: string): string;
 /**
  * Paint the reservations invisible: the page numbers the cuts so far do not know yet (*the pages are cut as far as they are asked*, Egildo's ruling 1 of 2026-10-12, on the note's recommendation). A document shown before it is complete must not show `0` where a page number will stand.
  *
  * @param scope - as {@link hideSheetText}.
  */
-export declare function hideReservations(doc: Document, sites: Site[], scope?: string | undefined): void;
+export declare function hideReservations(doc: Document, sites: Pick<Site, 'key' | 'pseudos'>[], scope?: string | undefined): 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;
 /** 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. */

package/dist/src/reads.js

@@ -237,6 +237,12 @@ export function findPageSites(doc, originals = null, keep = null) {
     }
     return sites.length ? sites : null;
 }
+/** The flow sites that read the page total, as the rule that reads it names them: what {@link hideReservations} paints invisible while the total is unknown, since a flow site reads `0` until then (`chase.ts`'s `setCounters`). A `counter(page)` and a named string are true from the first page and are not among them. */
+export function totalSites(doc) {
+    return contentRules(doc)
+        .filter((r) => /counters?\(\s*pages\s*[,)]/.test(r.content))
+        .map((r) => ({ key: hostSelector(r.selector), pseudos: r.pseudos }));
+}
 /** What every page of a run publishes, as the measure wears it: the page's number and the document's total, and its named strings' properties (`chase.js`'s `setCounters` and `setStrings`, the same values). */
 export function pageFactsOf(account) {
     return account.map((entry) => {
@@ -557,7 +563,7 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
     else
         withdraw(doc);
     if (hide)
-        hideReservations(doc, paged.filter((s) => delivered.get(s.key ?? '')?.get(s.prop) === cssString(RESERVATION)), hide === true ? undefined : hide);
+        hideReservations(doc, [...paged.filter((s) => delivered.get(s.key ?? '')?.get(s.prop) === cssString(RESERVATION)), ...(pageSites ? totalSites(doc) : [])], hide === true ? undefined : hide);
     performance.measure('cicero:reads', { start: t, end: (t = performance.now()), detail: { references: sites.length, pageSites: pageSites?.length ?? 0 } });
     let runs = 0;
     let moved = [];

package/dist/src/root.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beltype/cicero",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "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",