@beltype/cicero 0.1.6 → 0.1.8

package/dist/src/fragmentation.d.ts

@@ -20,5 +20,5 @@ export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureCont
 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 { adjudicate, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.ts';
+export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.ts';
 export { BREAKING_SPACE, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.ts';

package/dist/src/fragmentation.js

@@ -19,5 +19,5 @@ export { assertRenderConditions, awaitCloneImages, awaitFonts, createMeasureCont
 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 { adjudicate, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.js';
+export { adjudicate, firstBelowTheEdge, fitsPage, isOutOfFlow, neverCutInside, processionBottoms, reachesBelowTheEdge } from './stonehand.js';
 export { BREAKING_SPACE, copyOf, isFixedBox, isInlineBox, isLineBreak, noteSource } from './word-space.js';

package/dist/src/fragments.d.ts

@@ -96,10 +96,10 @@ export declare function mayRepeat(src: Element): boolean;
  * **`keep` is the first fragment's door into the same surgery** (*the first fragment is constructed*, 2026-09-15). A shell continues a box whose own content closed on the page before, so page one wants everything after that box gone and the box itself standing — the one difference from the grab's reading, where the boundary box is what resumes. With `keep`, the boundary element stays and is dressed as a fragment that ends there, which it is.
  *
  * @param clone - the top-level block's clone, already hinted and already consumed to the cursor.
- * @param el - the boundary element, addressed in the clone's own coordinates.
+ * @param el - the boundary node, addressed in the clone's own coordinates: an element, or the first node of a run of lines, which has no element (*the anonymous box is in the procession*).
  * @param opts - `keep`: the boundary element stays in the fragment (and is dressed), rather than leaving with its successors. `hollow`: what leaves is kept hollow (`putAway`).
  */
-export declare function truncateFrom(clone: Element, el: Element, { keep, hollow }?: {
+export declare function truncateFrom(clone: Element, el: ChildNode, { keep, hollow }?: {
     keep?: boolean;
     hollow?: boolean;
 }): Element;

package/dist/src/fragments.js

@@ -317,7 +317,7 @@ function liftRepeatedHeader(group) {
  * **`keep` is the first fragment's door into the same surgery** (*the first fragment is constructed*, 2026-09-15). A shell continues a box whose own content closed on the page before, so page one wants everything after that box gone and the box itself standing — the one difference from the grab's reading, where the boundary box is what resumes. With `keep`, the boundary element stays and is dressed as a fragment that ends there, which it is.
  *
  * @param clone - the top-level block's clone, already hinted and already consumed to the cursor.
- * @param el - the boundary element, addressed in the clone's own coordinates.
+ * @param el - the boundary node, addressed in the clone's own coordinates: an element, or the first node of a run of lines, which has no element (*the anonymous box is in the procession*).
  * @param opts - `keep`: the boundary element stays in the fragment (and is dressed), rather than leaving with its successors. `hollow`: what leaves is kept hollow (`putAway`).
  */
 export function truncateFrom(clone, el, { keep = false, hollow = false } = {}) {
@@ -377,22 +377,59 @@ function charRanges(word, from, to) {
     }
     return out;
 }
+/** Whether the whitespace of a text node stands in its layout (css-text-4 §4.1): where it collapses it is nothing at a line's edge, and where it is preserved each newline draws a line. */
+const preservesSpace = (t) => !!t.parentElement && /^(pre|pre-wrap|pre-line|break-spaces)$/.test(sourceStyle(t.parentElement)?.whiteSpace ?? '');
+/** Take a stretch of a cut's whitespace out of the fragment: leave it where it collapses, so layout reads the data exactly as before, and remove it where it is preserved, or a continuation opens on the empty lines of every line cut away. Either way the record says it is not shown. */
+function dropSpace(t, from, to) {
+    if (to <= from)
+        return;
+    if (preservesSpace(t))
+        cutRanges(t, [{ start: from, end: to }]);
+    else
+        leaveOut(t, from, to);
+}
 /**
- * Say that everything before the resume point is held and not shown (*the engine names the source point*, 2026-10-13). Consuming blanks the words and leaves the whitespace between them, so a continuation's data still begins with the spaces of every word cut away; those are the source's characters and no part of the interval, and so are the whitespace before the first kept word and every text node that stands wholly before it. Records only: layout reads the data exactly as before.
+ * The indentation of the line a resume word opens: the whitespace before it back to a newline, in characters. Read before the words before it go, because only they tell the space that opens a line from the space that followed a word. A cut at a soft wrap has no newline in that gap and no indentation, the space hanging at the end of the line before; a line after a `<br>` looks the same and loses its indentation at the top of a page.
+ */
+function indentationBefore(clone, node, start) {
+    let text = '';
+    for (const t of textsIn(clone)) {
+        if (t === node) {
+            text += t.data.slice(0, start);
+            break;
+        }
+        text += t.data;
+    }
+    let i = text.length;
+    while (i > 0 && BREAKING_SPACE.test(text[i - 1]))
+        i--;
+    const newline = text.lastIndexOf('\n');
+    return newline < i ? 0 : text.length - newline - 1;
+}
+/**
+ * Say that everything before the resume point is held and not shown (*the engine names the source point*, 2026-10-13). Consuming blanks the words and leaves the whitespace between them, so a continuation's data still begins with the spaces of every word cut away; those are the source's characters and no part of the interval, and so are the whitespace before the first kept word and every text node that stands wholly before it. Where the whitespace collapses these are records only, and where it is preserved they leave the data (`dropSpace`), all but the indentation of the line the page opens on.
  *
  * @param resume - the node holding the first kept character, or null when nothing is kept.
+ * @param indent - the characters immediately before it to keep, from {@link indentationBefore}.
  */
-function leaveOutBefore(clone, resume) {
+function leaveOutBefore(clone, resume, indent) {
+    const lead = [];
     for (const t of textsIn(clone)) {
         if (t === resume)
             break;
-        leaveOut(t, 0, t.data.length);
+        lead.push({ node: t, end: t.data.length });
     }
     if (resume) {
         let at = 0;
         while (at < resume.data.length && BREAKING_SPACE.test(resume.data[at]))
             at++;
-        leaveOut(resume, 0, at);
+        lead.push({ node: resume, end: at });
+    }
+    let left = indent;
+    for (const { node, end } of lead.reverse()) {
+        const kept = preservesSpace(node) ? Math.min(left, end) : 0;
+        left -= kept;
+        dropSpace(node, 0, end - kept);
     }
 }
 /** The mirror: everything after the last kept character is held and not shown.@param keep - the node holding the last kept character. */
@@ -400,14 +437,14 @@ function leaveOutAfter(clone, keep) {
     let end = keep.data.length;
     while (end > 0 && BREAKING_SPACE.test(keep.data[end - 1]))
         end--;
-    leaveOut(keep, end, keep.data.length);
     let after = false;
-    for (const t of textsIn(clone)) {
+    for (const t of [...textsIn(clone)]) {
         if (after)
-            leaveOut(t, 0, t.data.length);
+            dropSpace(t, 0, t.data.length);
         else if (t === keep)
             after = true;
     }
+    dropSpace(keep, end, keep.data.length);
 }
 /** The text nodes under an element, in document order — by `childNodes`, as `joinedWords` reads, so the DOM-free suites' trees serve. */
 function* textsIn(el) {
@@ -426,7 +463,9 @@ function consumeLeadingWords(clone, n, char = 0, hollow = false) {
     // A resume inside word n (*a line inside a word is a break point*, 2026-09-23): its first `char` characters were shown on the page before, and go with the words before it. The page resumes at the part holding the first character left.
     const inside = char > 0 && n < words.length ? charRanges(words[n], 0, char) : [];
     const resumeWord = words[Math.min(n, words.length - 1)];
-    const resumeNode = n < words.length ? (partAt(resumeWord, char) ?? resumeWord.parts[0]).node : null;
+    const resumePart = n < words.length ? partAt(resumeWord, char) ?? resumeWord.parts[0] : null;
+    const resumeNode = resumePart?.node ?? null;
+    const indent = resumePart && char === 0 ? indentationBefore(clone, resumePart.node, resumePart.start) : 0;
     // Blank the consumed words' exact character ranges, one pass a node (`word-space.js`' `cutRanges`, which records what went).
     const perNode = new Map();
     for (const part of [...words.slice(0, n).flatMap((w) => w.parts), ...inside]) {
@@ -436,7 +475,7 @@ function consumeLeadingWords(clone, n, char = 0, hollow = false) {
     }
     for (const [node, ranges] of perNode)
         cutRanges(node, ranges);
-    leaveOutBefore(clone, resumeNode);
+    leaveOutBefore(clone, resumeNode, indent);
     // Structural pass: an element with no remaining words, standing entirely before the resume point, is spent — its edges adjoin the cut (§5.2) and it leaves the fragment.
     const spent = [];
     (function walk(el) {

package/dist/src/gauge.d.ts

@@ -45,6 +45,8 @@ export type Box = {
     anonymous?: boolean;
     /** A table's footer group written before its rows (`footerBeforeRows`), moved to the end of the table's procession, where §17.2 lays it out. */
     laidOutLast?: boolean;
+    /** A table's header group written after its rows (`headerAfterRows`), moved to the front of the table's procession, where §17.2 lays it out. */
+    laidOutFirst?: boolean;
 };
 /** One line box, recovered arithmetically from the rects clustered onto it and the line-heights they are set on (`computeLines`). */
 export type LineBox = {
@@ -95,6 +97,8 @@ export type Tracks = {
 };
 /** The sealed report {@link takeReport} hands back. */
 export type MeasureReport = ReturnType<typeof takeReport>;
+/** A `display` whose inline content CSS 2.1 §9.2.1.1 wraps in anonymous block boxes — a block container's. A flex or grid container makes a run an anonymous item and a table an anonymous cell, which are other boxes and other questions. */
+export declare const holdsAnonymousBlocks: (display: string) => boolean;
 /**
  * Read one settled layout into an immutable snapshot — obtaining it seals the mutation phase (*render-identical conditions*, I5, by type).
  *

package/dist/src/gauge.js

@@ -15,7 +15,7 @@
  * @packageDocumentation
  */
 import { BREAK, selectorOf } from './data-beltype.js';
-import { blockChildrenOf, footerBeforeRows, isAtom, isEngineText, isInlineBox, isLineBreak, mayBeAutoHyphenated, rangeOf, READS_ITS_CHILDREN, rowsAmong, SIDE_BY_SIDE, wordRuns } from './word-space.js';
+import { blockChildrenOf, footerBeforeRows, headerAfterRows, isAtom, isEngineText, isInlineBox, isLineBreak, mayBeAutoHyphenated, rangeOf, READS_ITS_CHILDREN, rowsAmong, SIDE_BY_SIDE, wordRuns } from './word-space.js';
 /** The Compositor's own `<br>`, found by the browser and never by splitting the attribute here (the walkers below run per box). */
 const BREAK_SELECTOR = `br${selectorOf(BREAK)}`;
 /**
@@ -28,7 +28,7 @@ const sharesLine = (aTop, aBottom, bTop, bBottom) => Math.min(aBottom, bBottom)
 /** A character a word is made of: anything `BREAKING_SPACE` does not divide at. */
 const WORD_CHAR = /[\S  ]/;
 /** A `display` whose inline content CSS 2.1 §9.2.1.1 wraps in anonymous block boxes — a block container's. A flex or grid container makes a run an anonymous item and a table an anonymous cell, which are other boxes and other questions. */
-const holdsAnonymousBlocks = (display) => !/flex|grid|-webkit-box/.test(display) && (!/table/.test(display) || /^table-(cell|caption)$/.test(display));
+export const holdsAnonymousBlocks = (display) => !/flex|grid|-webkit-box/.test(display) && (!/table/.test(display) || /^table-(cell|caption)$/.test(display));
 const GAP_MIN = 0.75; // px — a third rect-reading rule, learned from the differential: half-leading float arithmetic leaves sub-pixel residue between a text box's last line and its border, and reporting that residue as a gap fabricates Class C cuts that bypass keeps. Real gaps (padding, margins, constrained heights) are ≥ 1px; noise stays under half a pixel.
 /**
  * Read one settled layout into an immutable snapshot — obtaining it seals the mutation phase (*render-identical conditions*, I5, by type).
@@ -91,6 +91,18 @@ export function takeReport(container, { contentHeight }) {
             list.splice(last, 0, footer); // `last` moved down by one with the removal, so this is the place after it
             footer.laidOutLast = moved = true;
         }
+        // The header stands first, the mirror (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): §17.2 lays a `table-header-group` out *"before all other rows and row groups"*, so one written after them is moved before the first. Its words stay after the rows in the word space, which is why the Stonehand offers no place inside it or right after it, and why the driver refuses one that does not repeat: only a copy can show it on a page before its words.
+        for (const list of [box.blockChildren, box.children]) {
+            const h = list.findIndex((c) => headerAfterRows(c.el));
+            if (h < 0)
+                continue;
+            const first = list.findIndex((c) => /^table-row(-group)?$/.test(win.getComputedStyle(c.el).display));
+            if (first < 0 || first > h)
+                continue;
+            const [header] = list.splice(h, 1);
+            list.splice(first, 0, header);
+            header.laidOutFirst = moved = true;
+        }
     }
     /**
      * The anonymous boxes (*the anonymous box is in the procession*, 2026-09-29; CSS 2.1 §9.2.1.1). A block container holding a block-level box beside inline content wraps each maximal run of that content in an anonymous block box, and css-break-3 §4.1 divides the result like any procession: a Class A point between the run and the block beside it, Class B points between its lines, and no Class C point where it stands, since a line is child content. The procession used to be the element tree's block children alone, so a run had no box: its lines were read as nothing but the distance they opened, a start gap before the first block child and an end gap after the last, and a page edge crossing thirteen trailing lines shelled them blank (`packages/essay/cases/76-the-line-before-the-first-block`).

package/dist/src/hyphen-patterns/en-us.d.ts

@@ -7,6 +7,7 @@ declare const _default: {
     id: string[];
     leftmin: number;
     rightmin: number;
+    word: RegExp;
     exceptions: string[];
     patterns: string[];
 };

package/dist/src/hyphen-patterns/en-us.js

@@ -7,6 +7,8 @@ export default {
     id: ['en-us', 'en'],
     leftmin: 2,
     rightmin: 3,
+    // The word is its ASCII letters: hyphen.tex's patterns know no other, so an accented word yields nothing, as before. What stands around it, punctuation, quotation marks, brackets and a possessive's `'s`, moves no offset (Codeberg issue 6): until 2026-11-07 `computer,` had no candidates and `computer` had them. An apostrophe inside a word is not a letter here, where Italian reads an elision, since the patterns were built for TeX, which reads `don't` as two words.
+    word: /^(\P{L}*)([a-zA-Z]+)((?:['’]s)?\P{L}*)$/u,
     // hyphen.tex's own exception list: words the patterns get wrong, hyphenations given literally.
     exceptions: ['as-so-ciate', 'as-so-ciates', 'dec-li-na-tion', 'oblig-a-tory', 'phil-an-thropic', 'present', 'presents', 'project', 'projects', 'reci-procity', 're-cog-ni-zance', 'ref-or-ma-tion', 'ret-ri-bu-tion', 'ta-ble'],
     patterns: [

package/dist/src/hyphen-patterns/it.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Vendored Italian hyphenation patterns, hyph-it.tex version 4.9 of 2014-04-22 from the hyph-utf8 package (github.com/hyphenation/tex-hyphen), which follow the Recommendation UNI 6461. TeX's word boundary `.` is written `_` here, as `src/hyphenate.js` expects. Data, not code: the trie is built by src/hyphenate.js.
+ *
+ * Copyright (C) 2008-2011 Claudio Beccari, available under LPPL 1.3 or later or under the MIT licence, taken here under MIT:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * @packageDocumentation
+ */
+declare const _default: {
+    id: string[];
+    leftmin: number;
+    rightmin: number;
+    word: RegExp;
+    patterns: string[];
+};
+export default _default;

package/dist/src/hyphen-patterns/it.js

@@ -0,0 +1,52 @@
+/**
+ * Vendored Italian hyphenation patterns, hyph-it.tex version 4.9 of 2014-04-22 from the hyph-utf8 package (github.com/hyphenation/tex-hyphen), which follow the Recommendation UNI 6461. TeX's word boundary `.` is written `_` here, as `src/hyphenate.js` expects. Data, not code: the trie is built by src/hyphenate.js.
+ *
+ * Copyright (C) 2008-2011 Claudio Beccari, available under LPPL 1.3 or later or under the MIT licence, taken here under MIT:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * @packageDocumentation
+ */
+export default ({
+    id: ['it-it', 'it'],
+    leftmin: 2,
+    rightmin: 2,
+    // Accents and elisions are ordinary in Italian, and a word in running text may carry its punctuation: the core is what the patterns read, apostrophes included, because they have patterns of their own.
+    word: /^(\P{L}*)([\p{L}'’]+?)(\P{L}*)$/u,
+    patterns: [
+        "_a3p2n", "_anti1", "_anti3m2n", "_bio1", "_ca4p3s", "_circu2m1", "_contro1", "_di2s3cine", "_e2x1eu", "_fran2k3", "_free3", "_li3p2sa",
+        "_narco1", "_opto1", "_orto3p2", "_para1", "_ph2l", "_ph2r", "_poli3p2", "_pre1", "_p2s", "_re1i2scr", "_sha2re3", "_tran2s3c",
+        "_tran2s3d", "_tran2s3l", "_tran2s3n", "_tran2s3p", "_tran2s3r", "_tran2s3t", "_su2b3lu", "_su2b3r", "_wa2g3n", "_wel2t1", "2'2", "a1ia",
+        "a1ie", "a1io", "a1iu", "a1uo", "a1ya", "2at_", "e1iu", "e2w", "o1ia", "o1ie", "o1io", "o1iu",
+        "1b", "2bb", "2bc", "2bd", "2bf", "2bm", "2bn", "2bp", "2bs", "2bt", "2bv", "b2l",
+        "b2r", "2b_", "2b'", "1c", "2cb", "2cc", "2cd", "2cf", "2ck", "2cm", "2cn", "2cq",
+        "2cs", "2ct", "2cz", "2chh", "c2h", "2ch_", "2ch'_", "2ch''_", "2chb", "ch2r", "2chn", "c2l",
+        "c2r", "2c_", "2c'", "_c2", "1d", "2db", "2dd", "2dg", "2dl", "2dm", "2dn", "2dp",
+        "d2r", "2ds", "2dt", "2dv", "2dw", "2d_", "2d'", "_d2", "1f", "2fb", "2fg", "2ff",
+        "2fn", "f2l", "f2r", "2fs", "2ft", "2f_", "2f'", "1g", "2gb", "2gd", "2gf", "2gg",
+        "g2h", "g2l", "2gm", "g2n", "2gp", "g2r", "2gs", "2gt", "2gv", "2gw", "2gz", "2gh2t",
+        "2g_", "2g'", "_h2", "1h", "2hb", "2hd", "2hh", "hi3p2n", "h2l", "2hm", "2hn", "2hr",
+        "2hv", "2h_", "2h'", "_j2", "1j", "2j_", "2j'", "_k2", "1k", "2kg", "2kf", "k2h",
+        "2kk", "k2l", "2km", "k2r", "2ks", "2kt", "2k_", "2k'", "1l", "2lb", "2lc", "2ld",
+        "2l3f2", "2lg", "l2h", "l2j", "2lk", "2ll", "2lm", "2ln", "2lp", "2lq", "2lr", "2ls",
+        "2lt", "2lv", "2lw", "2lz", "2l_", "2l'_", "2l''", "1m", "2mb", "2mc", "2mf", "2ml",
+        "2mm", "2mn", "2mp", "2mq", "2mr", "2ms", "2mt", "2mv", "2mw", "2m_", "2m'", "1n",
+        "2nb", "2nc", "2nd", "2nf", "2ng", "2nk", "2nl", "2nm", "2nn", "2np", "2nq", "2nr",
+        "2ns", "n2s3fer", "2nt", "2nv", "2nz", "n2g3n", "2nheit", "2n_", "2n'", "1p", "2pd", "p2h",
+        "p2l", "2pn", "3p2ne", "2pp", "p2r", "2ps", "3p2sic", "2pt", "2pz", "2p_", "2p'", "1q",
+        "2qq", "2q_", "2q'", "1r", "2rb", "2rc", "2rd", "2rf", "r2h", "2rg", "2rk", "2rl",
+        "2rm", "2rn", "2rp", "2rq", "2rr", "2rs", "2rt", "r2t2s3", "2rv", "2rx", "2rw", "2rz",
+        "2r_", "2r'", "1s2", "2shm", "2sh_", "2sh'", "2s3s", "s4s3m", "2s3p2n", "2stb", "2stc", "2std",
+        "2stf", "2stg", "2stm", "2stn", "2stp", "2sts", "2stt", "2stv", "2sz", "4s_", "4s'_", "4s''",
+        "_t2", "1t", "2tb", "2tc", "2td", "2tf", "2tg", "t2h", "2th_", "t2l", "2tm", "2tn",
+        "2tp", "t2r", "t2s", "3t2sch", "2tt", "t2t3s", "2tv", "2tw", "t2z", "2tzk", "tz2s", "2t_",
+        "2t'_", "2t''", "1v", "2vc", "v2l", "v2r", "2vv", "2v_", "2v'_", "2v''", "1w", "w2h",
+        "wa2r", "2w1y", "2w_", "2w'", "1x", "2xb", "2xc", "2xf", "2xh", "2xm", "2xp", "2xt",
+        "2xw", "2x_", "2x'", "y1ou", "y1i", "1z", "2zb", "2zd", "2zl", "2zn", "2zp", "2zt",
+        "2zs", "2zv", "2zz", "2z_", "2z'_", "2z''", "_z2",
+    ]
+});

package/dist/src/hyphenate.d.ts

@@ -7,7 +7,7 @@
  *
  * @packageDocumentation
  */
-/** A pattern set as a language module supplies it — `hyphen-patterns/en-us.js` is the one that exists. */
+/** A pattern set as a language module supplies it, as `hyphen-patterns/en-us.js` and `hyphen-patterns/it.js` do. */
 export type LanguageData = {
     /** Every `lang` value the set answers, lower-case. */
     id: string[];
@@ -17,6 +17,8 @@ export type LanguageData = {
     patterns: string[];
     /** Hyphenations given literally, `-` at every division. */
     exceptions?: string[];
+    /** What counts as a word, as three groups: what stands before it, the word the patterns read, and what stands after it. Absent, plain ASCII letters and nothing around them. */
+    word?: RegExp;
 };
 /** A registered language: the trie built once. A trie node maps a letter to its child node and `'$'` to the digit list of the pattern ending there, which is why its values are untyped. */
 export type Language = {
@@ -25,6 +27,7 @@ export type Language = {
     exceptions: Map<string, string>;
     leftmin: number;
     rightmin: number;
+    word: RegExp;
 };
 /** css-text-4 §6.3.4's three values; a null or an absence is `auto`. */
 export type HyphenateLimits = {
@@ -53,4 +56,4 @@ export declare function resolveLimits(lang: Pick<Language, 'leftmin' | 'rightmin
  *
  * @param lang - from `languageFor`; null yields no candidates.
  */
-export declare function hyphenationOffsets(word: string, lang: Language | null, limits?: HyphenateLimits): number[];
+export declare function hyphenationOffsets(text: string, lang: Language | null, limits?: HyphenateLimits): number[];

package/dist/src/hyphenate.js

@@ -8,6 +8,7 @@
  * @packageDocumentation
  */
 import enUs from './hyphen-patterns/en-us.js';
+import it from './hyphen-patterns/it.js';
 const LANGS = new Map();
 /** Build a language's trie once. Exposed as data-in, function-out so a future language module registers the same way. */
 export function registerLanguage(data) {
@@ -36,12 +37,13 @@ export function registerLanguage(data) {
     for (const ex of data.exceptions ?? []) {
         exceptions.set(ex.replace(/-/g, ''), ex);
     }
-    const lang = { trie, exceptions, leftmin: data.leftmin, rightmin: data.rightmin };
+    const lang = { trie, exceptions, leftmin: data.leftmin, rightmin: data.rightmin, word: data.word ?? /^()([a-zA-Z]+)()$/ };
     for (const id of data.id)
         LANGS.set(id, lang);
     return lang;
 }
 registerLanguage(enUs);
+registerLanguage(it);
 /** Resolve a lang attribute value to a registered language, or null (no language, no candidates — auto-hyphenation is never guessed). */
 export function languageFor(langAttr) {
     if (!langAttr)
@@ -66,13 +68,19 @@ export function resolveLimits(lang, limits = {}) {
  *
  * @param lang - from `languageFor`; null yields no candidates.
  */
-export function hyphenationOffsets(word, lang, limits = {}) {
+export function hyphenationOffsets(text, lang, limits = {}) {
     if (!lang)
         return [];
     const { before, after, total } = resolveLimits(lang, limits);
-    if (word.length < total || word.length < before + after || !/^[a-zA-Z]+$/.test(word))
+    const found = lang.word.exec(text);
+    if (!found)
         return [];
-    const lower = word.toLowerCase();
+    const lead = found[1].length;
+    const word = found[2];
+    if (word.length < total || word.length < before + after)
+        return [];
+    // Both apostrophes are one letter to a pattern; the replacement keeps every offset.
+    const lower = word.toLowerCase().replace(/’/g, "'");
     const exception = lang.exceptions.get(lower);
     if (exception !== undefined) {
         const offsets = [];
@@ -80,7 +88,7 @@ export function hyphenationOffsets(word, lang, limits = {}) {
         for (const part of exception.split('-').slice(0, -1)) {
             pos += part.length;
             if (pos >= before && word.length - pos >= after)
-                offsets.push(pos);
+                offsets.push(lead + pos);
         }
         return offsets;
     }
@@ -106,7 +114,7 @@ export function hyphenationOffsets(word, lang, limits = {}) {
     for (let p = 2; p < marked.length - 1; p++) {
         const off = p - 1;
         if (points[p] % 2 === 1 && off >= before && word.length - off >= after)
-            offsets.push(off);
+            offsets.push(lead + off);
     }
     return offsets;
 }

package/dist/src/measure.d.ts

@@ -12,7 +12,9 @@ export type MeasureContext = ReturnType<typeof createMeasureContext>;
 /**
  * The intake under *render-identical conditions* (I5): refuse to adjudicate under conditions print will not reproduce. `relaxDpr` is the preview's escape hatch only — decisions are then valid for the screen being looked at, not for print; no gate ever sets it.
  *
- * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, or a document root whose line-height is not explicit (*render-identical conditions*, I5).
+ * A vertical or sideways root is refused by name too (Codeberg issue 12): every read in this engine is horizontal, the lines by vertical overlap, the cut by a y, the page area by its height, so under `writing-mode: sideways-lr` on the root the text of a positioned paragraph fell below the clip and was never resumed, and the printer's tiling invariant refused what the engine should have. Vertical writing is outside the beta, and a refusal that says so at intake is cheaper than one three tools later.
+ *
+ * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, a document root whose line-height is not explicit (*render-identical conditions*, I5), or a document root whose writing mode is not `horizontal-tb`.
  */
 export declare function assertRenderConditions(doc: Document, { relaxDpr }?: {
     relaxDpr?: boolean;
@@ -64,13 +66,13 @@ export type PagePublish = {
  * @param contentWidthPx - the page's true content width — the one geometry decisions are valid under (*render-identical conditions*, I5).
  */
 export declare function createMeasureContext(doc: Document, contentWidthPx: number): {
-    container: HTMLElement;
+    container: HTMLDivElement;
     /**
      * Lay out a feed of nodes and force one layout. The caller obtains geometry only through a Gauge report taken afterward — obtaining the report seals the mutation phase (*render-identical conditions*, I5, by type; see gauge.js).
      *
      * @param nodes - cloned feed content; never source elements (*the source document is never written*, C5, and never moved).
      * @param publish - what the page the feed is for publishes on its host (*the page carries its conditions*, 2026-10-21), written on the container so a flow site that reads a page fact is measured with it standing; absent, the container carries none, and such a site reads its reservation.
      */
-    measure(nodes: Node[], publish?: PagePublish | null): HTMLElement;
+    measure(nodes: Node[], publish?: PagePublish | null): HTMLDivElement;
     dispose(): void;
 };

package/dist/src/measure.js

@@ -15,17 +15,23 @@ const NEUTRALIZE_ID = '__beltype-neutralize';
 /**
  * The intake under *render-identical conditions* (I5): refuse to adjudicate under conditions print will not reproduce. `relaxDpr` is the preview's escape hatch only — decisions are then valid for the screen being looked at, not for print; no gate ever sets it.
  *
- * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, or a document root whose line-height is not explicit (*render-identical conditions*, I5).
+ * A vertical or sideways root is refused by name too (Codeberg issue 12): every read in this engine is horizontal, the lines by vertical overlap, the cut by a y, the page area by its height, so under `writing-mode: sideways-lr` on the root the text of a positioned paragraph fell below the clip and was never resumed, and the printer's tiling invariant refused what the engine should have. Vertical writing is outside the beta, and a refusal that says so at intake is cheaper than one three tools later.
+ *
+ * @throws Error — bare and deliberate (`src/` may not import BelType's error types): a device pixel ratio other than 1 without `relaxDpr`, a document root whose line-height is not explicit (*render-identical conditions*, I5), or a document root whose writing mode is not `horizontal-tb`.
  */
 export function assertRenderConditions(doc, { relaxDpr = false } = {}) {
     const win = doc.defaultView;
     if (!relaxDpr && win.devicePixelRatio !== 1) {
         throw new Error(`I5: unit device pixel ratio required for adjudication, got ${win.devicePixelRatio}`);
     }
-    const lh = win.getComputedStyle(doc.documentElement).lineHeight;
+    const root = win.getComputedStyle(doc.documentElement);
+    const lh = root.lineHeight;
     if (!/^-?[\d.]+px$/.test(lh)) {
         throw new Error(`I5 (DPR ruling): explicit line-height required, document root computes '${lh}'`);
     }
+    if (root.writingMode && root.writingMode !== 'horizontal-tb') {
+        throw new Error(`a vertical or sideways root is outside this engine's beta: the document root computes writing-mode '${root.writingMode}', and every read here is horizontal (the line by vertical overlap, the cut by a y). Write the document horizontal-tb, or print it with another engine.`);
+    }
 }
 /**
  * Await font readiness once — late-arriving truth handled before the first measure, never during adjudication.
@@ -134,16 +140,14 @@ export function createMeasureContext(doc, contentWidthPx) {
         style.textContent = `#${CONTAINER_ID}, #${CONTAINER_ID} * { break-before: auto !important; break-after: auto !important; break-inside: auto !important; orphans: 2 !important; widows: 2 !important; transform: none !important; rotate: none !important; scale: none !important; translate: none !important; perspective: none !important; }`;
         doc.head.appendChild(style);
     }
-    let container = doc.getElementById(CONTAINER_ID);
-    if (!container) {
-        container = doc.createElement('div');
-        container.id = CONTAINER_ID;
-        doc.body.appendChild(container);
-    }
+    // Each context has a container of its own, so two fills in flight never measure in each other's. They share the one id on purpose, transiently: the neutralizing sheet and `reads.ts` select by it, at the specificity the sheet needs against an author's `!important`.
+    const container = doc.createElement('div');
+    container.id = CONTAINER_ID;
+    doc.body.appendChild(container);
     // flow-root: child margins stay inside, so the container's box is the measured flow's coordinate space. Off-viewport, never display:none — display:none has no geometry.
     const css = `position: absolute; left: -100000px; top: 0; width: ${contentWidthPx}px; display: flow-root;`;
     container.style.cssText = css;
-    /** The container is one element for every context, and a run that stops at a page shares it (*the pages are cut as far as they are asked*, 2026-10-12): the presentation composes a page with a context of its own, at its own width, and puts it away — which removes the container and the neutralizing style from under a run that is waiting to go on. So every measure makes sure of both, and of the width it was created for, before it lays anything out. Nothing else changes: where no other context ran in between, all three are already so. */
+    /** A context can stand idle while another runs (*the pages are cut as far as they are asked*, 2026-10-12), and a host may move what it wears, so every measure makes sure of the sheet, the container and the width before it lays anything out. Where nothing moved, all three are already so. */
     const ensure = () => {
         if (!style.isConnected)
             doc.head.appendChild(style);
@@ -171,7 +175,8 @@ export function createMeasureContext(doc, contentWidthPx) {
         },
         dispose() {
             container.remove();
-            style.remove();
+            if (!doc.querySelector(`#${CONTAINER_ID}`))
+                style.remove();
         }
     };
 }

package/dist/src/reads.d.ts

@@ -7,7 +7,7 @@
  *
  * **A missing target shows nothing**: no declaration is delivered for it, the fallback `""` stands, the pseudo-element still has its box (the leader the author drew still draws), and the console names the link once per paginate.
  *
- * **The loop is a consumer's too, over a chain of its own** (*the engine knows no view*, `.claude/decisions/project/the-engine-knows-no-view.md`, ruling 3). `settleReads`'s `run` and `blocksOf` are the door: a view that holds its own pages settles through this loop, with a `run` that refills the dirty entries of its chain, and never through a copy of it. What the loop assumes of its host, read in its body and its helpers: the sites are found in `doc`'s sheets and matched among `originals` (the whole document where none are given), and a site or a target counts only where it stands inside `blocksOf()`'s blocks, since the position index places it; so `originals` are the boxes that hold the blocks, never a presented copy of them. A target is `doc.getElementById`'s answer, the first element in tree order, which holds where the source boxes precede every copy that keeps the id, as `<beltype-root>` keeps its originals before its copies, or where the copies carry no id. The blocks are any elements in document order: nothing asks that they share a parent or be `body`'s children, since the position index, the counter walk and `pathOf` each walk one block on its own. The counter walk's ancestors are `html` and `body`, the two the driver's own walk reads, so another ancestor of the blocks must carry no counter operation. A changed site is measured on a clone of its block in the measure container, at its page's content width, the ruler the run measures with. The run's result carries an `account` whose entries have the driver's shape (`pos`, `cut`, `carried`, `blank`, `trace.forced`, and `closes` with `pageNumber`, `contentW`, `contentH` and `strings`), every address in `blocksOf()`'s numbering, and the `index` it was handed; and, where its pages publish values of their own, `laidFacts`, the page values each page was laid out under (a flow site reads them), which the loop compares the truth with in place of the table it handed the run (a run that returns none was laid out under the table it was handed, as the driver's is; see CHANGELOG 2026-10-28); a layout sent round again is handed `resume.at`, the addresses of the moved boxes, which such a `run` maps to the entries they dirty. The values reach every element in `doc`'s own tree through one adopted sheet, and the page facts are the page hosts' (`chase.js`). One assumption was the root's alone and is a parameter: the sheet that hides a reservation scopes its rules to `beltype-root`, and `hide` names another scope.
+ * **The loop is a consumer's too, over a chain of its own** (*the engine knows no view*, `.claude/decisions/project/the-engine-knows-no-view.md`, ruling 3). `settleReads`'s `run` and `blocksOf` are the door: a view that holds its own pages settles through this loop, with a `run` that refills the dirty entries of its chain, and never through a copy of it. What the loop assumes of its host, read in its body and its helpers: the sites are found in `doc`'s sheets and matched among `originals` (the whole document where none are given), and a site or a target counts only where it stands inside `blocksOf()`'s blocks, since the position index places it; so `originals` are the boxes that hold the blocks, never a presented copy of them. A target is the first element in tree order carrying the id among `originals` (`doc.getElementById`'s answer where none are given), which holds where the source boxes precede every copy that keeps the id, as `<beltype-root>` keeps its originals before its copies, or where the copies carry no id; a host's own element that carries an author's id is outside the originals and is never a target, and a `target-text()` target outside `blocksOf()`'s blocks shows nothing, as a counter or page target there does. The blocks are any elements in document order: nothing asks that they share a parent or be `body`'s children, since the position index, the counter walk and `pathOf` each walk one block on its own. The counter walk's ancestors are `html` and `body`, the two the driver's own walk reads, so another ancestor of the blocks must carry no counter operation. A changed site is measured on a clone of its block in the measure container, at its page's content width, the ruler the run measures with. The run's result carries an `account` whose entries have the driver's shape (`pos`, `cut`, `carried`, `blank`, `trace.forced`, and `closes` with `pageNumber`, `contentW`, `contentH` and `strings`), every address in `blocksOf()`'s numbering, and the `index` it was handed; and, where its pages publish values of their own, `laidFacts`, the page values each page was laid out under (a flow site reads them), which the loop compares the truth with in place of the table it handed the run (a run that returns none was laid out under the table it was handed, as the driver's is; see CHANGELOG 2026-10-28); a layout sent round again is handed `resume.at`, the addresses of the moved boxes, which such a `run` maps to the entries they dirty. The values reach every element in `doc`'s own tree through one adopted sheet, and the page facts are the page hosts' (`chase.js`). One assumption was the root's alone and is a parameter: the sheet that hides a reservation scopes its rules to `beltype-root`, and `hide` names another scope.
  *
  * @packageDocumentation
  */
@@ -224,7 +224,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).
+ * @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.
  */
 export declare function settleReads<R extends {
     account: any[];
@@ -232,6 +232,7 @@ export declare function settleReads<R extends {
     resumed?: Resumed | null;
     why?: string | null;
     laidFacts?: PagePublish[] | null;
+    complete?: boolean;
 }>(doc: Document, { run, blocksOf, originals, warm, warmFacts, hide, keep }: {
     run: (laid: Laid) => Promise<R>;
     blocksOf: () => Element[];