@beltype/cicero 0.1.9 → 0.1.11

package/dist/seam/rim.js

@@ -1,12 +1,14 @@
 /**
  * THE RIM — the system's edge, where a fact the engine measured before it was true announces that it is (*late truth is an edit*, 2026-10-13; `.claude/decisions/cicero/late-truth-is-an-edit.md`, Decisions three and four; *a box announces its own size*, 2026-10-21; `.claude/decisions/cicero/a-box-announces-its-own-size.md`).
  *
- * It listens on the top-level boxes the intake took, and on nothing else: an `<img>` inside one (`load` and `error`, caught in the capture phase because they do not bubble — a picture still pending and a picture whose `src` changes later are the same event), a custom element whose name is not yet defined (`customElements.whenDefined`, then one animation frame for its `connectedCallback` to have run), and `document.fonts` (`loadingdone`, a fact about the conditions and so about no box).
+ * It listens on the top-level boxes the intake took, and on nothing else: an `<img>` inside one (`load` and `error`, caught in the capture phase because they do not bubble: a picture still pending at intake, which the first run no longer waits for, and a picture whose `src` changes later are the same event), a custom element whose name is not yet defined (`customElements.whenDefined`, then one animation frame for its `connectedCallback` to have run), and `document.fonts` (`loadingdone`, a fact about the conditions and so about no box).
  *
  * **And the one cause that needs no name: a box's own size.** One `ResizeObserver` over the same boxes reports each one's border box; the report is read only while the box is drawn as itself on a page (the root's `isPresented`, and a reading above zero, since a parked box and a box on a page the browser skips read zero), and it is news only where it stands more than a quarter pixel from the height the last run measured for that box (the driver's table, which the client hands in as `measured`). The ear never measures: the observation is a trigger, and the resume measures. It is never paused; what it hears while a run is called or under way is judged when the runs have ended, against the table they leave, which is what keeps the engine's own presentations silent with no flag on its writes.
  *
  * **And the pieces a built page draws a block through** (*a fragment announces its own size*, 2026-10-22; `.claude/decisions/cicero/a-fragment-announces-its-own-size.md`). A divided block's original is parked, and so is a composed block's and one holding a nested fixed box, so the root names to the rim, through the client, every piece it slots into a built page's flow and every node a presentation takes out (`pieces`), and the same observer watches each from the frame it is built in. **A piece's expected height is its first reading above zero**, the presentation's own; a later reading more than the quarter pixel from it, judged under the same gate as an original's, is a `size` signal naming the piece's source box, the page the piece stands on beside it. The engine's own rebuild of a page makes new pieces with new first readings, so its writes pass with no flag. **Its limits**: a change of the original's tree after the copy was taken reaches no piece and is heard by nothing; a box on a page far from the reader is heard when the page comes near (the hearing probe, P40e), and a piece on a page never yet near has read nothing, so a change made before then, like one landing in the presentation's own frame, is its first reading and passes; and a reflow that keeps a box's height and moves its cut passes unheard, since a cut is a word address and the gate a height.
  *
+ * **A picture is news only where its arrival changed its box** (amended 2026-11-08, on Egildo's ruling of that day). A `load` or an `error` is judged when the runs have ended, as a size is: where the box is drawn as itself and the observer's last reading of it stands within the quarter pixel of the height the last run measured, the picture moved nothing and is no signal, which is what an image that declares its `width` and `height` gives; where the observer has read the box as nothing (a page the browser skips), the box's own `offsetHeight` is read instead. A box not drawn as itself while some page is not built is judged again when the observer next reports, since it may stand on that page. Where the reading differs, or the box is not drawn as itself once every page is built (parked, drawn through pieces) or was never measured whole, the rim cannot compare, and the picture is an `image` signal as before. A reading taken before the arrival was laid out passes, and the observer's own `size` hears the box a frame later.
+ *
  * **Every signal is one cancelable `beltype:change` on the document**, `detail: { kind, boxes }` with `kind` one of `image`, `element`, `font`, `size` and `boxes` the top-level boxes in document order (empty for a font); a `size` adds `pages`, beside each box the page it was heard on through a piece, or `null` where it was heard as itself. The same name is the one the live-values store dispatches for its writes (`kind: 'store'`, stage 2): the engine learns one name for every late truth and the host cancels one event to own the pace. A host that calls `preventDefault()` has taken it; otherwise `onSignal` runs with the same detail, and the client answers with the resumable run. **The default action is the engine's for an event the rim did not dispatch as well** (the amendment of 2026-10-13): the store's write (`kind: 'store'`) is dispatched by the host's module, which writes its fields synchronously when the dispatch returns un-cancelled, so the rim waits one animation frame and then, if nobody took the pace, hands `{ kind, boxes }` to the same `onSignal`.
  *
  * This module knows no run: it hears, tells, and hands the default action back. The `originals` array is the client's own and is read live — `patch` replaces an entry in it — so a box that left it is never named.
@@ -71,10 +73,11 @@ export function bringsNewFace(event) {
  * @param p.pageHolding - the page a piece is slotted into (`root.js`' `pageHolding`), asked when a piece is judged changed.
  * @param p.measured - the box's border-box height as the last run measured it, or undefined where it did not.
  * @param p.idle - resolves when no run is under way and nothing the rim told is still being answered: a size is judged then, against the table the run leaves.
+ * @param p.unbuilt - whether some page of the presentation is not built yet: a picture's box that is not drawn as itself may stand on it, and is judged again when the observer next reports. Absent, every page is built.
  * @param p.busy - whether a run is under way or a signal is being answered now: asked again just before a size is judged, since a named signal may have come while the ear waited for the frame.
  * @returns `add` subscribes to a box, releasing what the box it replaced (a patched edit) and the box itself already held, so one load is one signal; `pieces` observes the pieces a page was just built with, each beside its source box, and lets go of the ones a presentation took out; `stop` releases everything.
  */
-export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, onSignal, presented = () => false, pageHolding = () => null, measured = () => undefined, idle = async () => { }, busy = () => false }) {
+export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, onSignal, presented = () => false, pageHolding = () => null, measured = () => undefined, idle = async () => { }, busy = () => false, unbuilt = () => false }) {
     const win = doc.defaultView;
     let stopped = false;
     /** What each box's listeners hand back. */
@@ -86,6 +89,26 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
     const heard = new Map();
     /** The pieces a built page draws its blocks through (*a fragment announces its own size*, 2026-10-22): each one's source box and its expected height, which is the first reading above zero the observer reports for it — the presentation's own, since the feed has no number for a constructed first fragment or a two-cut fragment and a second arithmetic for the others is the fork the account ruling forbids. Zero until that reading; an entry leaves with its piece. */
     const pieces = new Map();
+    /** Each original's last border-box height as the observer reported it, zero included: what a picture's arrival is judged by. */
+    const latest = new WeakMap();
+    /** The boxes a picture loaded or failed in since the last judgment. */
+    const loaded = new Set();
+    /**
+     * What a picture's arrival in a box is: `same` where the box is drawn as itself at the height the last run measured for it, `later` where it is not drawn as itself while some page is not built (it may stand on that page, and is judged again when the observer next reports), and `moved` otherwise, which is also every box the rim cannot compare.
+     *
+     * @remarks The height is the observer's last reading, within {@link TOLERANCE}. Where the observer has read nothing above zero (a box on a page the browser skips reads zero, and a box parked when it was observed is never reported until it is laid out), the box is asked its `offsetHeight`, which lays out that one box and rounds to the whole pixel, so the gate there is half a pixel wider.
+     */
+    const verdict = (box) => {
+        if (!presented(box))
+            return unbuilt() ? 'later' : 'moved';
+        const was = measured(box);
+        if (was === undefined)
+            return 'moved';
+        const now = latest.get(box);
+        if (now)
+            return Math.abs(now - was) <= TOLERANCE ? 'same' : 'moved';
+        return box instanceof win.HTMLElement && Math.abs(box.offsetHeight - was) <= 0.5 + TOLERANCE ? 'same' : 'moved';
+    };
     let judging = false;
     const observer = new win.ResizeObserver((entries) => {
         const t = performance.now();
@@ -102,6 +125,7 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
                     piece.expected = size;
                 continue;
             }
+            latest.set(e.target, size);
             // Zero is what a box no page renders reads: a parked one, and one slotted into a page whose content the browser skips (`content-visibility: auto` on a page not yet near the reader — measured 2026-10-21: a page shown by a run stopped at it reads zero for one frame). It is not news; a box that comes into view reads again.
             if (size > 0 && presented(e.target))
                 heard.set(e.target, size);
@@ -110,7 +134,11 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
         }
         // The run keeps time (*the run keeps time*, 2026-09-25), and so does the ear: inert unless a host reads the measures.
         performance.measure('cicero:size-heard', { start: t, end: performance.now(), detail: { entries: entries.length, kept: heard.size } });
-        if (judging || heard.size === 0)
+        judge();
+    });
+    /** Judge what was heard, sizes and pictures, once the runs have ended. */
+    function judge() {
+        if (judging || (heard.size === 0 && loaded.size === 0))
             return;
         judging = true;
         // A frame to gather the batch; the runs' end; then the frame after it and the task after that frame, so the observer has reported what the last presentation left before anything is judged — and again while a run or an answer began in the meantime (the battery's parallel suite once heard a size beside an element and a face that the named signals were about to answer, 2026-10-22).
@@ -145,11 +173,24 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
                     moved.set(el, null);
             }
             heard.clear();
-            performance.measure('cicero:size-judged', { start: t, end: performance.now(), detail: { heard: n, moved: moved.size } });
+            const pictures = loaded.size;
+            const late = [];
+            for (const box of loaded) {
+                const v = verdict(box);
+                if (v !== 'later')
+                    loaded.delete(box);
+                if (v === 'moved')
+                    late.push(box);
+            }
+            performance.measure('cicero:size-judged', { start: t, end: performance.now(), detail: { heard: n, moved: moved.size, pictures, late: late.length, later: loaded.size } });
+            for (const box of late)
+                moved.delete(box);
+            if (late.length)
+                signal('image', late);
             if (moved.size)
                 signal('size', moved.keys(), moved);
         });
-    });
+    }
     /**
      * @param [pageOf] - a size's: the page each box was heard on through a piece, or null where it was heard as itself.
      */
@@ -176,12 +217,14 @@ export function watchLateTruth({ document: doc, fonts = doc.fonts, originals, on
                 held.delete(gone);
             }
         observer.observe(box, { box: 'border-box' });
-        // `load` and `error` do not bubble, so one capturing listener per box hears every picture inside it — the ones pending now and the ones whose `src` changes later, which a listener on the pending alone would miss. The intake awaited the pictures it found, so an event here is a late one.
-        const loaded = (e) => { if (e.target.localName === 'img')
-            signal('image', [box]); };
-        box.addEventListener('load', loaded, true);
-        box.addEventListener('error', loaded, true);
-        held.set(box, () => { box.removeEventListener('load', loaded, true); box.removeEventListener('error', loaded, true); observer.unobserve(box); });
+        // `load` and `error` do not bubble, so one capturing listener per box hears every picture inside it: the ones pending now, the intake waiting for none since 2026-11-08, and the ones whose `src` changes later, which a listener on the pending alone would miss. Heard, and judged with the sizes: only an arrival that changed the box is a signal.
+        const arrived = (e) => { if (!stopped && e.target.localName === 'img') {
+            loaded.add(box);
+            judge();
+        } };
+        box.addEventListener('load', arrived, true);
+        box.addEventListener('error', arrived, true);
+        held.set(box, () => { box.removeEventListener('load', arrived, true); box.removeEventListener('error', arrived, true); observer.unobserve(box); loaded.delete(box); });
         for (const el of [box, ...box.querySelectorAll('*')]) {
             const name = el.localName;
             if (!name.includes('-') || win.customElements.get(name))

package/dist/src/capture.d.ts

@@ -108,12 +108,36 @@ export declare function sheetsUseHas(doc: Document): boolean;
 export declare function sheetsCountInPseudos(doc: Document): boolean;
 /** The arguments the host rewrote, read back from the registry rules (`:not(*) { --beltype-has-<h>: "<A>" }`, one per rewritten sheet): hash → the argument's canonical text. The capture reads the CSSOM and nothing else, so the arguments come from the rule the rewriter appended and no selector is ever parsed back. */
 export declare function hasArgumentsOf(doc: Document): Map<string, string>;
+/**
+ * The properties that paint and move no box, the one list the sheets' reach reads a rule's declarations against (ruled 2026-11-08): a style rule whose every declaration sets one of these is passed over by {@link sheetReach} and {@link topLevelReach} whatever its selector, because the reach asks whether an edit can move another box's facts, and a colour, a shadow or an opacity moves none.
+ *
+ * @remarks
+ * Closed and short on purpose. The CSSOM lists a rule's declarations as longhands, so `background` arrives as its `background-*` longhands and `border-color` as the four sides', and both families are taken by their prefix and suffix besides the names here. Anything else counts as layout, custom properties (`--x`) included, since one may feed a layout value through `var()`. Four were weighed and left out: `visibility`, whose `collapse` removes a table row or column from the layout; and `filter`, `backdrop-filter` and `will-change`, which make a containing block for a fixed or absolutely positioned descendant and so move it.
+ */
+export declare const PAINT_ONLY: ReadonlySet<string>;
+/** The rule that set a reach and the sheet it stands in, which the memo's console notice names (ruled 2026-11-08): `selector` is a style rule's `selectorText`, `null` for an `@container` or `@scope` rule or a sheet the engine cannot read; `sheet` the sheet's `href`, or `<style> n` with its place among the document's sheets, counted from 1. */
+export type ReachCulprit = {
+    selector: string | null;
+    sheet: string;
+    kind: 'style' | 'container' | 'scope' | 'unreadable';
+};
+/** A reach with the first rule that set it and how many more rules reached as far, {@link sheetReachOf}'s and {@link topLevelReachOf}'s answer. */
+export type Reach = {
+    reach: 0 | 1 | 2;
+    culprit: ReachCulprit | null;
+    count: number;
+};
 /**
  * How far a box's attributes can reach through the sheets the document wears, read off the selectors (*the forced-break index is kept across runs*, 2026-10-09) — what the forcing index's memo needs to know to say which of its answers an edit made stale, when the unit of replacement is `patchBox`'s, a box at any depth ({@link topLevelReach} reads the same sheets for a whole top-level box).
  *
  * 0: nothing but the box and what is below it; a descendant combinator or a child combinator reads a box's ancestors, which an edit does not change. 1: a sibling — `+`, `~` or `:nth-child(… of …)`, by which a box's attributes decide the style of the boxes after it (or beside it) and what they hold. 2: an ancestor or anything at all — `:has(`, an `@container` rule (a size the edit moves), or a sheet the engine cannot read. Blink's invalidation sets draw the same line and take the same fallback: where a selector defeats the reasoning, widen. The reading is textual and errs only toward more reach — a `+` in a selector's attribute value is read as a combinator — which costs speed and never a stale answer.
+ *
+ * @remarks
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, and an `@container` rule every rule under which paints answers nothing of itself; its nested rules are read as rules (ruled 2026-11-08).
  */
 export declare function sheetReach(doc: Document): 0 | 1 | 2;
+/** {@link sheetReach} with the first rule that set the reach and how many more reached as far, for the memo's console notice. */
+export declare function sheetReachOf(doc: Document): Reach;
 /**
  * How far an edit's effect can travel through the sheets when the unit of replacement is a whole top-level box (*the forced-break index is kept across runs*, amended 2026-10-25): what {@link ForcingMemo.settle}, told these boxes, needs to say which top-level boxes' kept parts an edit made stale. Named for its unit, as `sheetReach` is the reading for `patchBox`'s, a box replaced at any depth.
  *
@@ -124,12 +148,16 @@ export declare function sheetReach(doc: Document): 0 | 1 | 2;
  *
  * A nested rule is read as it matches: its `&` is its parent's selector in `:is()`, as CSS Nesting defines it. Conservative by construction, and these are the cases it does not read, each answered 2: a `:is()`, `:where()`, `:not()` or other wrapper whose argument holds a combinator and also a sibling combinator, a `:has(` or a structural pseudo-class, which takes in a nested rule whose parent's selector holds them (a wrapper with a bare `*` among its arguments constrains nothing and is passed over, which is how the engine's own `:has()` union reads); a `&` in a rule nested in no style rule; a selector whose quotes or brackets do not close; a relative selector at the top of a rule. The pseudo-classes `sheetReach` passes over (`:target`, `:checked`, `:dir()`) are passed over here too.
  *
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, so a paint-only `p + p` or `body:has(.x) p` reaches nothing, and an `@container` or `@scope` rule every rule under which paints answers nothing of itself; the walk reads its nested rules as rules (ruled 2026-11-08).
+ *
  * The unit's promise, which the host keeps: a top-level box whose name or attributes change is a new element, and the element it replaced is among `before`.
  *
  * @param boxes - the top-level boxes as they stand: the element children of their one parent, in order.
  * @param before - the top-level boxes the memo was last settled with (`ForcingMemo`'s `boxes`), empty where it keeps nothing.
  */
 export declare function topLevelReach(doc: Document, boxes: ArrayLike<Element>, before?: ArrayLike<Element>): 0 | 1 | 2;
+/** {@link topLevelReach} with the first rule that set the reach, its sheet, and how many more rules reached as far, for the memo's console notice (ruled 2026-11-08). The number alone stays `topLevelReach`'s answer, which a view adapter imports. */
+export declare function topLevelReachOf(doc: Document, boxes: ArrayLike<Element>, before?: ArrayLike<Element>): Reach;
 /** What {@link topLevelReach} asks of the document while it reads a selector. */
 export type ReachContext = {
     /** Whether the selector up to a compound can match a top-level box, or the compound alone a box an edit took out. */

package/dist/src/capture.js

@@ -80,25 +80,106 @@ function someRule(doc, test) {
     };
     return styleSheetsOf(doc).some(inSheet);
 }
+/**
+ * The properties that paint and move no box, the one list the sheets' reach reads a rule's declarations against (ruled 2026-11-08): a style rule whose every declaration sets one of these is passed over by {@link sheetReach} and {@link topLevelReach} whatever its selector, because the reach asks whether an edit can move another box's facts, and a colour, a shadow or an opacity moves none.
+ *
+ * @remarks
+ * Closed and short on purpose. The CSSOM lists a rule's declarations as longhands, so `background` arrives as its `background-*` longhands and `border-color` as the four sides', and both families are taken by their prefix and suffix besides the names here. Anything else counts as layout, custom properties (`--x`) included, since one may feed a layout value through `var()`. Four were weighed and left out: `visibility`, whose `collapse` removes a table row or column from the layout; and `filter`, `backdrop-filter` and `will-change`, which make a containing block for a fixed or absolutely positioned descendant and so move it.
+ */
+export const PAINT_ONLY = new Set(['color', 'background', 'border-color', 'outline-color', 'text-decoration-color', 'text-emphasis-color', 'caret-color', 'accent-color', 'column-rule-color', 'opacity', 'mix-blend-mode', 'box-shadow', 'text-shadow', 'cursor', 'pointer-events', 'user-select', 'forced-color-adjust', 'color-scheme', 'print-color-adjust']);
+const paints = (name) => PAINT_ONLY.has(name) || name.startsWith('background-') || (name.startsWith('border-') && name.endsWith('-color'));
+/** Whether a rule's own declarations, read through `rule.style`, all paint: a rule with none does too. A rule with no `style` is not a style rule and answers no. */
+function paintOnly(rule) {
+    const style = rule.style;
+    if (!style || typeof style.length !== 'number')
+        return false;
+    for (let i = 0; i < style.length; i++)
+        if (!paints(style.item(i)))
+            return false;
+    return true;
+}
+/** Whether every rule under a grouping rule paints, nested rules and grouping rules within it included; a rule that is neither a style rule nor a grouping rule answers no. */
+function allPaint(rules) {
+    for (const rule of Array.from((rules ?? []))) {
+        if (rule.style ? !paintOnly(rule) : !rule.cssRules)
+            return false;
+        if (rule.cssRules && !allPaint(rule.cssRules))
+            return false;
+    }
+    return true;
+}
+/** Every rule of every sheet the document wears, with its sheet's name, walked as {@link someRule} walks them but to the end; a sheet the engine cannot read is handed to `unread`. */
+function eachRule(doc, visit, unread) {
+    const inRules = (rules, sheet) => {
+        for (const rule of rules) {
+            visit(rule, sheet);
+            if (rule.cssRules)
+                inRules(rule.cssRules, sheet);
+            if (rule.styleSheet)
+                inSheet(rule.styleSheet, sheet);
+        }
+    };
+    const inSheet = (sheet, name) => {
+        const own = sheet.href ?? name;
+        let rules;
+        try {
+            rules = sheet.cssRules;
+        }
+        catch {
+            unread(own);
+            return;
+        }
+        inRules(rules, own);
+    };
+    styleSheetsOf(doc).forEach((sheet, i) => inSheet(sheet, `<style> ${i + 1}`));
+}
+/** A tally of what reached how far: the highest level, the first rule at it, and the rules after it at the same level. */
+function reachTally() {
+    const found = { reach: 0, culprit: null, count: 0 };
+    const add = (reach, culprit) => {
+        if (reach > found.reach)
+            Object.assign(found, { reach, culprit, count: 0 });
+        else if (reach > 0 && reach === found.reach)
+            found.count++;
+    };
+    return { found, add };
+}
+/** A grouping rule's kind where it is one the reach answers 2 for unless every rule under it paints, else `null`. */
+const queried = (rule) => {
+    const kind = rule.constructor?.name;
+    return kind === 'CSSContainerRule' ? 'container' : kind === 'CSSScopeRule' ? 'scope' : null;
+};
 /**
  * How far a box's attributes can reach through the sheets the document wears, read off the selectors (*the forced-break index is kept across runs*, 2026-10-09) — what the forcing index's memo needs to know to say which of its answers an edit made stale, when the unit of replacement is `patchBox`'s, a box at any depth ({@link topLevelReach} reads the same sheets for a whole top-level box).
  *
  * 0: nothing but the box and what is below it; a descendant combinator or a child combinator reads a box's ancestors, which an edit does not change. 1: a sibling — `+`, `~` or `:nth-child(… of …)`, by which a box's attributes decide the style of the boxes after it (or beside it) and what they hold. 2: an ancestor or anything at all — `:has(`, an `@container` rule (a size the edit moves), or a sheet the engine cannot read. Blink's invalidation sets draw the same line and take the same fallback: where a selector defeats the reasoning, widen. The reading is textual and errs only toward more reach — a `+` in a selector's attribute value is read as a combinator — which costs speed and never a stale answer.
+ *
+ * @remarks
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, and an `@container` rule every rule under which paints answers nothing of itself; its nested rules are read as rules (ruled 2026-11-08).
  */
 export function sheetReach(doc) {
-    if (someRule(doc, (rule) => rule.constructor?.name === 'CSSContainerRule' || !!rule.selectorText?.includes(':has(')))
-        return 2;
-    // Parenthesised arguments and attribute selectors out of the way first: `:nth-child(2n+1)` and `[lang~=en]` are not combinators, and `:nth-child(2 of .x)` is the one `nth` form that looks sideways.
-    if (someRule(doc, (rule) => {
+    return sheetReachOf(doc).reach;
+}
+/** {@link sheetReach} with the first rule that set the reach and how many more reached as far, for the memo's console notice. */
+export function sheetReachOf(doc) {
+    const { found, add } = reachTally();
+    eachRule(doc, (rule, sheet) => {
+        if (rule.constructor?.name === 'CSSContainerRule') {
+            if (!allPaint(rule.cssRules))
+                add(2, { selector: null, sheet, kind: 'container' });
+            return;
+        }
         const text = rule.selectorText;
-        if (!text)
-            return false;
-        if (/:nth-[\w-]+\([^)]*\sof\s/.test(text))
-            return true;
-        return /[+~]/.test(text.replace(/\[[^\]]*\]/g, '').replace(/:nth-[\w-]+\([^)]*\)/g, ''));
-    }))
-        return 1;
-    return 0;
+        if (!text || paintOnly(rule))
+            return;
+        const culprit = { selector: text, sheet, kind: 'style' };
+        if (text.includes(':has('))
+            return add(2, culprit);
+        // Parenthesised arguments and attribute selectors out of the way first: `:nth-child(2n+1)` and `[lang~=en]` are not combinators, and `:nth-child(2 of .x)` is the one `nth` form that looks sideways.
+        if (/:nth-[\w-]+\([^)]*\sof\s/.test(text) || /[+~]/.test(text.replace(/\[[^\]]*\]/g, '').replace(/:nth-[\w-]+\([^)]*\)/g, '')))
+            add(1, culprit);
+    }, (sheet) => add(2, { selector: null, sheet, kind: 'unreadable' }));
+    return found;
 }
 /**
  * How far an edit's effect can travel through the sheets when the unit of replacement is a whole top-level box (*the forced-break index is kept across runs*, amended 2026-10-25): what {@link ForcingMemo.settle}, told these boxes, needs to say which top-level boxes' kept parts an edit made stale. Named for its unit, as `sheetReach` is the reading for `patchBox`'s, a box replaced at any depth.
@@ -110,12 +191,18 @@ export function sheetReach(doc) {
  *
  * A nested rule is read as it matches: its `&` is its parent's selector in `:is()`, as CSS Nesting defines it. Conservative by construction, and these are the cases it does not read, each answered 2: a `:is()`, `:where()`, `:not()` or other wrapper whose argument holds a combinator and also a sibling combinator, a `:has(` or a structural pseudo-class, which takes in a nested rule whose parent's selector holds them (a wrapper with a bare `*` among its arguments constrains nothing and is passed over, which is how the engine's own `:has()` union reads); a `&` in a rule nested in no style rule; a selector whose quotes or brackets do not close; a relative selector at the top of a rule. The pseudo-classes `sheetReach` passes over (`:target`, `:checked`, `:dir()`) are passed over here too.
  *
+ * A rule whose declarations all paint ({@link PAINT_ONLY}) is passed over before its selector is read, so a paint-only `p + p` or `body:has(.x) p` reaches nothing, and an `@container` or `@scope` rule every rule under which paints answers nothing of itself; the walk reads its nested rules as rules (ruled 2026-11-08).
+ *
  * The unit's promise, which the host keeps: a top-level box whose name or attributes change is a new element, and the element it replaced is among `before`.
  *
  * @param boxes - the top-level boxes as they stand: the element children of their one parent, in order.
  * @param before - the top-level boxes the memo was last settled with (`ForcingMemo`'s `boxes`), empty where it keeps nothing.
  */
 export function topLevelReach(doc, boxes, before = []) {
+    return topLevelReachOf(doc, boxes, before).reach;
+}
+/** {@link topLevelReach} with the first rule that set the reach, its sheet, and how many more rules reached as far, for the memo's console notice (ruled 2026-11-08). The number alone stays `topLevelReach`'s answer, which a view adapter imports. */
+export function topLevelReachOf(doc, boxes, before = []) {
     const now = Array.from(boxes);
     const was = Array.from(before);
     const here = new Set(now);
@@ -143,22 +230,24 @@ export function topLevelReach(doc, boxes, before = []) {
         shaped,
         changed
     };
-    let reach = 0;
-    const unread = someRule(doc, (rule) => {
-        const kind = rule.constructor?.name;
-        if (kind === 'CSSContainerRule' || kind === 'CSSScopeRule')
-            return true;
-        if (!rule.selectorText || kind === 'CSSPageRule')
-            return false;
+    const { found, add } = reachTally();
+    eachRule(doc, (rule, sheet) => {
+        const kind = queried(rule);
+        if (kind) {
+            if (!allPaint(rule.cssRules))
+                add(2, { selector: null, sheet, kind });
+            return;
+        }
+        if (!rule.selectorText || rule.constructor?.name === 'CSSPageRule' || paintOnly(rule))
+            return;
         const text = resolvedSelector(rule);
         if (text != null && !CROSSING.test(text))
-            return false;
+            return;
         const r = text == null ? 2 : selectorListReach(text, ctx);
-        if (r > reach)
-            reach = r;
-        return reach === 2;
-    });
-    return unread ? 2 : reach;
+        if (r)
+            add(r, { selector: rule.selectorText, sheet, kind: 'style' });
+    }, (sheet) => add(2, { selector: null, sheet, kind: 'unreadable' }));
+    return found;
 }
 /** A style rule's selector as it matches: a rule nested in a style rule (through any grouping rules between them) has each `&` read as the parent's selector in `:is()`, and an item with no `&` the parent's as its ancestor, which is CSS Nesting's own definition, resolved up the chain; `null` for a `&` in a rule nested in no style rule, or text that does not close. */
 function resolvedSelector(rule) {
@@ -843,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

@@ -9,7 +9,8 @@
  *
  * @packageDocumentation
  */
-import { compose } from './compositor.js';
+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)
@@ -462,7 +510,8 @@ export function composeDocument(doc, blocks, ctx, cache = new CompositionCache()
                         available: job.avail,
                         indent: r === 0 ? job.indent : 0,
                         align: job.align,
-                        breakAnywhere: job.breakAnywhere
+                        breakAnywhere: job.breakAnywhere,
+                        limitLines: job.limitLines
                     });
                     record.runs.push({ start: runs[r].start, ...result });
                     record.lineCount += result.lineCount;
@@ -471,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);
@@ -509,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; ` +