@beltype/cicero 0.1.10 → 0.1.12

package/dist/src/stonehand.js

@@ -11,8 +11,8 @@
  *
  * @packageDocumentation
  */
-import { isAtom, READS_ITS_CHILDREN } from './word-space.js';
-import { ARTIFACT, hasWord } from './data-beltype.js';
+import { isAtom, READS_ITS_CHILDREN, sourceHasWord } from './word-space.js';
+import { ARTIFACT, ONE_COLUMN, hasWord } from './data-beltype.js';
 /**
  * THE MAKE-UP ORDER (*breaks are classified*, I3, amended in the fifth round) — which constraint yields first, and the standing fact that a constraint which has yielded still pulls.
  *
@@ -75,13 +75,13 @@ export function isMonolith(el, style, live = el) {
     return notYetDivided(style, live) !== null;
 }
 /**
- * **A fourth ground, and a temporary one: what the engine does not yet divide, where dividing it loses words** (*every branch gets a place*, 2026-09-21). Two arrangements lay content side by side in ways a row of sibling boxes does not describe, and each lost words at a cut until it was held whole (`packages/essay/probes/conservation.js`): a multi-column container, whose columns are fragmentainers of their own; and an inline-level block container, which is an atom of a line, with paragraphs inside it that the procession used to see. Held as a monolith each moves whole, or is sliced by the edge with its remainder painted — css-break-3's own remedy. **The remedy has a price, measured the same day, and it is why the list is this short**: a slice through text leaves the line the edge crosses half on each page, and the print's text layer reads it on both. That is better than words on no page and worse than anything else, so a grid with sized tracks or placed items — which divides without losing a word and merely opens its next page on the spent track's blank — was tried here and taken out again. Each entry leaves this list when it has a design of its own.
+ * **A fourth ground, and a temporary one: what the engine does not yet divide, where dividing it loses words** (*every branch gets a place*, 2026-09-21). Two arrangements lay content side by side in ways a row of sibling boxes does not describe, and each lost words at a cut until it was held whole (`packages/essay/probes/conservation.js`): a multi-column container, whose columns are fragmentainers of their own; and an inline-level block container, which is an atom of a line, with paragraphs inside it that the procession used to see. Held as a monolith each moves whole, or is sliced by the edge with its remainder painted — css-break-3's own remedy. **The remedy has a price, measured the same day, and it is why the list is this short**: a slice through text leaves the line the edge crosses half on each page, and the print's text layer reads it on both. A multi-column box taller than a page no longer reaches this list: it is laid out as one column (`src/scope.ts`), and the slice is left to a box that is a monolith for another reason. That is better than words on no page and worse than anything else, so a grid with sized tracks or placed items — which divides without losing a word and merely opens its next page on the spent track's blank — was tried here and taken out again. Each entry leaves this list when it has a design of its own.
  *
  * `live` is the element a measured clone stands for, kept in the signature for the day a ground needs to ask the element rather than its computed style — a grid's declared tracks are such a question: `grid-template-rows` resolves to the used tracks, implicit ones included, and only `computedStyleMap()` tells a declared list from none (measured in Chromium).
  */
 export function notYetDivided(style, live) {
-    if ((style.columnCount ?? 'auto') !== 'auto' || (style.columnWidth ?? 'auto') !== 'auto')
-        return 'multicol';
+    if (((style.columnCount ?? 'auto') !== 'auto' || (style.columnWidth ?? 'auto') !== 'auto') && !sourceHasWord(live, ONE_COLUMN))
+        return 'multicol'; // a source the run laid out as one column (`src/scope.ts`) is an ordinary block, though its own style still says columns
     if (/^inline-(block|flex|grid|table)$/.test(style.display ?? ''))
         return 'inline block container';
     return null;
@@ -331,8 +331,16 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
                     plan.push({ item, state: 'held', verdict: null }); // a monolith the height crosses resumes whole: the stated limit, as a float's (the item is the graphic, and nothing inside it is a place)
                 else {
                     const v = flowVerdict(w, item, h + lift, eps);
-                    if (!v)
-                        return null; // content crosses the height and the item offers no place above it: it shows nothing here
+                    if (!v) {
+                        // Content crosses the height and the item offers no place above it: it shows nothing here. In the first table row of the group that withdraws the offer (case 91). In a later row of a group a `rowspan` makes, that row moves whole with every row after it, the boundary before it being the break in its column, and the spanning cell is still divided at the height, as Chromium prints it (the essay's case 92).
+                        if (item.parent === row[0].parent)
+                            return null;
+                        const from = row.findIndex((r) => r.parent === item.parent);
+                        plan.splice(from);
+                        for (const rest of row.slice(from))
+                            plan.push({ item: rest, state: 'below', verdict: null });
+                        break;
+                    }
                     plan.push({ item, state: 'divided', verdict: v });
                 }
             }
@@ -358,7 +366,9 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
             const pair = siblings[si - 1];
             const anchor = last(siblings.slice(0, si).filter((b) => !parallelBox(b))) ?? null;
             // Before the rows of a continuation only the repeated header stands, and a copy is furniture (*an artifact is never read*): a boundary there takes nothing of the box, and would send the page back to where the box began.
-            if (anchor && !siblings.slice(0, si).every((b) => parallelBox(b) || copy(b))) {
+            // A table row a `rowspan` from above reaches is inside its group's row: the boundary before it would leave the spanning cell's remainder on no page, and the group's own cut is where that boundary is taken (`rowPlan`).
+            const spanned = box.blockChildren.some((c) => { const r = rowOf(c); return !!r && r[0].parent !== box; });
+            if (anchor && !spanned && !siblings.slice(0, si).every((b) => parallelBox(b) || copy(b))) {
                 candidates.push({
                     kind: 'A',
                     cls: 'A',
@@ -454,7 +464,8 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         // The place it names is before the box's first in-flow child, past the gap (*the cut divides its ancestors*, 2026-09-29): the page before carries the box's border, its padding and whatever stands in the gap — an empty float, the clearance under it — and the page after resumes the box divided, its first child whole. So the position is the child's outer top, which is the content edge plus the gap; it used to be the box's top plus its border, which put the padding on the next page and offered a break point §4.1 does not provide (`packages/essay/cases/71-the-box-that-begins-a-page`).
         const startGap = box.blockChildren.length ? report.gapAt({ box, edge: 'start' }) : 0;
         const firstInFlow = startGap > eps ? box.blockChildren.find((c) => !parallelBox(c)) : undefined;
-        if (firstInFlow && !copy(firstInFlow)) {
+        // A box that opens the page offers no start gap: the page would hold its block-start decoration and nothing else, and the next page would offer the same gap again wherever the box clones its decoration, so the cut is no progress (css-break-3 §4.4 drops an avoid that leaves only this, and Chromium's print never takes it: a row taller than the page under `break-inside: avoid` left a blank first page, and WPT's `table-fragmentation-001c` refused, assessment 2026-11-07, `outer-row-taller-than-page-avoid`).
+        if (firstInFlow && !copy(firstInFlow) && box.rect.top > pageStart + eps) {
             const prevSibling = si > 0 ? siblings[si - 1] : null;
             const bs = win.getComputedStyle(box.el);
             candidates.push({

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

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

package/dist/src/word-space.js

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

package/package.json

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