@beltype/cicero 0.1.8 → 0.1.10

package/dist/src/reads.js

@@ -14,7 +14,7 @@
 import { READ_PREFIX, STRING_KEYWORDS, STRING_PROP_PREFIX, decodeRead, encodeStringProp, splitTopLevel } from './gcpm-encoding.js';
 import { sheetsCountInPseudos, styleSheetsOf } from './capture.js';
 import { format as formatCounter } from './counter-styles.js';
-import { collapse, counterStatesAfter, counterValue, counterValues, documentOpsOf } from './document-state.js';
+import { collapse, contentTextOf, counterStatesAfter, counterValue, counterValues, documentOpsOf } from './document-state.js';
 import { indexBlocks, pageContaining, pageIntervals, pathOf } from './positions.js';
 import { isInlineBox } from './word-space.js';
 import { composeResumed } from './resume.js';
@@ -401,8 +401,8 @@ export function staticValues(sites, { doc, blocks, index = null, keep = null })
         if (!s.target || isPageRead(s.read))
             continue;
         if (s.read.fn === 'text') {
-            // css-content-3 §2.6.3's `content` keyword is the element's string value, `content()`'s own reading (document-state's `collapse`); `before`, `after` and `first-letter` are read as `content`, the same stated limit `string-set` has.
-            put(values, s.key, s.prop, cssString(collapse(s.target.textContent)));
+            // css-content-3 §2.6.3's `content` keyword is the element's string value, `content()`'s own reading (document-state's `contentTextOf` and `collapse`, which leave out what a printer made from generated content); `before`, `after` and `first-letter` are read as `content`, the same stated limit `string-set` has.
+            put(values, s.key, s.prop, cssString(collapse(contentTextOf(s.target))));
             continue;
         }
         const state = states.get(s.target);

package/dist/src/root.d.ts

@@ -87,7 +87,7 @@ export declare class BeltypeRoot extends HTMLElement {
     /**
      * THE INTAKE: the document's boxes become this element's light DOM (*content is one document*, I6), and are parked at once — before the first cut, not at the first presentation (*the pages are cut as far as they are asked*, 2026-10-12). A run that can stop at a page measures the sources while pages stand in the document, so it measures them where a resumed run always has: inside the root, in the flat tree under a slot that renders nothing, where `getComputedStyle` answers (*an unplaced original is parked, not unassigned*). Appended without parking they would answer nothing at all.
      *
-     * @param boxes - the blocks, then the fixed boxes, then the running elements.
+     * @param boxes - the top-level boxes: the blocks, then the fixed boxes, then the running elements. A fixed box or running element inside a block comes in with its block.
      */
     intake(...boxes: Element[]): void;
     /**
@@ -125,6 +125,23 @@ export declare class BeltypeRoot extends HTMLElement {
         oldTo: number;
         priorLength: number;
     } | null): void;
+    /**
+     * Draw again the chrome of every standing page that shows the running element at `at`, with nothing cut and nothing built (*the run resumes from an entry*, amended 2026-11-08): the seam's client replaced that element and the run's list now names the new one.
+     *
+     * @remarks A running element's edit is a chrome event: it is out of the flow, so no cut reads it, and which element a page shows is the page's `closes.running`, a fact about positions that did not move. So each page whose `closes.running` names the place lets go of its running-element clones and has its chrome drawn as a kept page whose chrome moved has it drawn in {@link present}, the bands measured again because a margin box sizes from what it says; its content, its key and every other page are left as they are.
+     * @param at - the element's place in `running`.
+     * @param running - the run's list, the new element in its place.
+     * @param marginBoxesFor - as {@link present} takes it.
+     * @returns how many pages were drawn again.
+     */
+    redrawRunning(at: number, running: {
+        el: Element;
+    }[], marginBoxesFor: (cond: {
+        name: string;
+        first: boolean;
+        parity: string;
+        blank: boolean;
+    }) => object): number;
     /**
      * @returns how many pages there are and how many have their content.
      */

package/dist/src/root.js

@@ -120,7 +120,7 @@ export class BeltypeRoot extends HTMLElement {
     /**
      * THE INTAKE: the document's boxes become this element's light DOM (*content is one document*, I6), and are parked at once — before the first cut, not at the first presentation (*the pages are cut as far as they are asked*, 2026-10-12). A run that can stop at a page measures the sources while pages stand in the document, so it measures them where a resumed run always has: inside the root, in the flat tree under a slot that renders nothing, where `getComputedStyle` answers (*an unplaced original is parked, not unassigned*). Appended without parking they would answer nothing at all.
      *
-     * @param boxes - the blocks, then the fixed boxes, then the running elements.
+     * @param boxes - the top-level boxes: the blocks, then the fixed boxes, then the running elements. A fixed box or running element inside a block comes in with its block.
      */
     intake(...boxes) {
         this.append(...boxes);
@@ -368,6 +368,32 @@ export class BeltypeRoot extends HTMLElement {
             page.setMarginBox(box, t ? t.parts.map((part) => (typeof part === 'string' ? part : this.#runningPart(pg.closes.running?.[part.element]?.[part.which], running))) : null);
         page.layoutBands();
     }
+    /**
+     * Draw again the chrome of every standing page that shows the running element at `at`, with nothing cut and nothing built (*the run resumes from an entry*, amended 2026-11-08): the seam's client replaced that element and the run's list now names the new one.
+     *
+     * @remarks A running element's edit is a chrome event: it is out of the flow, so no cut reads it, and which element a page shows is the page's `closes.running`, a fact about positions that did not move. So each page whose `closes.running` names the place lets go of its running-element clones and has its chrome drawn as a kept page whose chrome moved has it drawn in {@link present}, the bands measured again because a margin box sizes from what it says; its content, its key and every other page are left as they are.
+     * @param at - the element's place in `running`.
+     * @param running - the run's list, the new element in its place.
+     * @param marginBoxesFor - as {@link present} takes it.
+     * @returns how many pages were drawn again.
+     */
+    redrawRunning(at, running, marginBoxesFor) {
+        let drawn = 0;
+        for (const record of this.#records) {
+            const pg = record.ctx.pages[record.k];
+            if (!Object.values(pg.closes.running ?? {}).some((which) => Object.values(which).includes(at)))
+                continue;
+            for (const node of record.nodes)
+                if (!record.assigned.includes(node))
+                    node.remove();
+            record.nodes = record.nodes.filter((node) => record.assigned.includes(node));
+            this.#collect = record.nodes;
+            this.#chrome(record.page, pg, this.#marginPlan(pg, record.ctx.account, marginBoxesFor), running);
+            this.#collect = null;
+            drawn++;
+        }
+        return drawn;
+    }
     /**
      * GCPM §1.2's `element()`, delivered — a clone of the running element per page, forwarded into the margin cell through a slot.
      *

package/dist/src/stonehand.js

@@ -159,8 +159,6 @@ function walkOf(report, sourceOf, root = null, styleCache = new Map(), forcing =
     const monolithic = (box) => {
         if (box.anonymous)
             return false; // a run of lines, never one unit
-        if (box.laidOutLast || box.laidOutFirst)
-            return true; // a footer written before its rows: its words stand before the rows in the word space, so no place inside it could be addressed (*the footer before the rows*)
         const live = sourceOf(box.el) ?? box.el;
         const held = isMonolith(box.el, styleOfBox(box), live);
         // Named once per box, on the console, so a page that looks wrong for this reason says so.
@@ -210,7 +208,7 @@ function walkOf(report, sourceOf, root = null, styleCache = new Map(), forcing =
     /**
      * The walk stops at the edge (*the page asks the index*, 2026-09-25): a box the walk reads, in the procession, whose top lies below the limit. Nothing it or anything after it could offer can fit, so the walk takes the Class A boundary before it and stops.
      *
-     * A float, an absolutely positioned box and a row are not where it stops: a float's top is where the float was pushed, not the procession's, and a row's first item is not the row's top. The premise is stated rather than proved — that in-flow tops do not go backward in document order — and a negative margin taller than the box above it, or a relative offset, would break it. A table's footer written before its rows broke it too, and is walked where it is laid out instead (`gauge.js`'s `laidOutLast`, case 110).
+     * A float, an absolutely positioned box and a row are not where it stops: a float's top is where the float was pushed, not the procession's, and a row's first item is not the row's top. The premise is stated rather than proved — that in-flow tops do not go backward in document order — and a negative margin taller than the box above it, or a relative offset, would break it. A table's footer written before its rows broke it too, and is walked where it is laid out instead (`gauge.js`, in display order, case 110).
      */
     const standsBelow = (box, limit, eps) => !rowOf(box) && !parallelBox(box) && box.rect.top > limit + eps;
     return { report, sourceOf, boxes, win, root, styleCache, forcing, styleOfBox, monolithic, insideMonolith, parallelBox, insideParallel, rowOf, insideRowItem, copy, walks, standsBelow };
@@ -355,9 +353,7 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         // The root of a flow's own walk stands in no procession of its own: its row-mates are outside it, and a boundary before it is the outer walk's (*a parallel flow is a fragmentainer*, 2026-10-08).
         const siblings = box === root ? [] : report.processionOf(box).filter((b) => !isAbsolutelyPositioned(styleOfBox(b)));
         const si = siblings.indexOf(box);
-        // A footer written before its rows offers no boundary before it (*the footer before the rows*, 2026-10-15): the place is after the last row in the layout and before the first in the document, and an address can only say the second.
-        // Nor does the box after a header written after its rows (the mirror): the place is after the header in the layout and before every row in the document, so the page would hold the header's copy alone.
-        if (si > 0 && !box.laidOutLast && !siblings[si - 1].laidOutFirst) {
+        if (si > 0) {
             // Two siblings answer here, and they are not always the same one. **The keeps** are the immediately-adjacent box's, because §4.1 names *"a float and an immediately-adjacent in-flow or floated box"* as a Class A pair in as many words — a float's own `break-after` binds the boundary after it, which is §3.1's *should* on floats that this engine honours and Chromium declines. **The position** is the previous in-flow sibling's bottom border edge, because a parallel flow's extent is not a place in the procession the cuts divide (§2.1): the float is laid out beside the content, so the page closes where the previous in-flow box ended and the float's own bottom says nothing about it. Pricing this at the float's bottom is how a 96mm rail put every slab standing beside it off the page — measured, `cases/21-parallel-flows`, where the boundary before the first slab was priced at y 400 in a 264px page area.
             const pair = siblings[si - 1];
             const anchor = last(siblings.slice(0, si).filter((b) => !parallelBox(b))) ?? null;

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

@@ -26,7 +26,7 @@ export declare const UNSPACED_SCRIPT: RegExp;
 /**
  * Could the browser have drawn a hyphen at a line boundary between these two characters that the source does not carry? The one question that decides whether a line inside a word may be a cut the fragment can write: a silent break needs nothing at the cut, and a break after U+00AD needs the soft hyphen the source holds written as the hyphenation character (`fragments.js`, *the hyphen is written at the cut*). What is left is a hyphen the browser drew between two letters under `hyphens: auto`, where no character of the source says where.
  *
- * **Refuses where it cannot tell.** Under `hyphens: auto` the browser may hyphenate between any two letters of a script that hyphenates, and nothing in the DOM says whether it did — so that break is refused, the word stays whole, and the page ends a line early rather than print half a word with no hyphen. (The browser does leave its drawing in the range rects, an inked rect for the hyphen on the line it ends, so the question is answerable by measurement; what an address would say for it is its own round.) `hyphens: none` and `manual` draw one only at a soft hyphen.
+ * **Answered by measurement, read by the source on both sides.** Under `hyphens: auto` the browser may hyphenate between any two letters of a script that hyphenates, and nothing in the DOM says whether it did; the range rects do, an inked rect for the hyphen on the line the break ends. So the Gauge opens a piece at such a break only where it measured that hyphen (`gauge.js`, `drewHyphen`), and refuses one that drew none, where the page ends a line early rather than print a hyphen the browser did not draw; the fragment writer asks this same predicate of the same characters and adds the hyphenation character after the last kept letter (`fragments.js`). The address carries no mark: the measurement decides which breaks are cuts, and the source decides what the cut writes. `hyphens: none` and `manual` draw one only at a soft hyphen.
  *
  * @param before - the character before the break
  * @param after - the character after it
@@ -209,21 +209,23 @@ export declare function clonesDecoration(el: Element): boolean;
  */
 export declare function blockChildrenOf(el: Element, isInline?: (el: Element) => boolean): Element[];
 /**
- * Is this a table's footer group written before a row or row group of its table — HTML 4's order, still legal — which CSS 2.1 §17.2 lays out after them all the same (*"always displayed after all other rows and row groups"*)?
+ * A table's children in CSS 2.1 §17.2's display order: its header group before every other row and row group, its footer group after them, and everything else as written. Any other element's children are returned as they are, the same array.
  *
- * @remarks The one place the order and the layout disagree inside a table's procession (*the footer before the rows*, 2026-10-15): the Gauge walks such a footer last, the Stonehand offers no place before it or inside it, and the footer's reservation is made where it stands. Read by computed display, so a clone answers for its source.
+ * @remarks THE WORD SPACE follows this order inside a table (*the-word-space-follows-the-table-display-order*, 2026-11-07), and so does every reader of it: the position index numbers a table's words in it, a path's indices count a table's children in it, the Gauge walks a table's procession in it, and a fragment's two cuts put away the children standing before or after them in it. §17.2 lays a `table-header-group` out *"before all other rows and row groups"* and a `table-footer-group` *"after all other rows and row groups"*, wherever each is written, and Chromium paints them so; numbered in the order written, a header after its rows had its words last and its box first, which lost rows with no message (*thead-after-rows-and-tall-footer-lose-rows*). Only the first group of each kind moves, because §17.2 renders any later one as a row group. A move only ever goes toward the rows, so a table written in HTML's order is returned unchanged. Read by computed display, so a clone answers for its source, and a tree that cannot be asked (the DOM-free suites) keeps the order written.
  *
- * @param el - a clone or a source element.
+ * @param parent - the element whose children these are.
+ * @param items - its children, or what stands for them (the Gauge's boxes), in the order written.
+ * @param elOf - the element an item stands for; `null` for a text node, which stays where it is.
  */
-export declare function footerBeforeRows(el: Element): boolean;
+export declare function inDisplayOrder<T>(parent: Element, items: T[], elOf?: (item: T) => Element | null): T[];
 /**
- * Is this a table's header group written after a row or row group of its table, which CSS 2.1 §17.2 lays out before them all the same (*"always displayed before all other rows and row groups"*)?
+ * Is this a table's footer group written before a row or row group of its table — HTML 4's order, still legal — which CSS 2.1 §17.2 lays out after them all the same?
  *
- * @remarks The mirror of {@link footerBeforeRows} (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): the Gauge walks such a header first, the Stonehand offers no place inside it or right after it, and its words stand after the rows in the word space, so a page before its words shows it by its repeated copy alone. One that does not repeat, in a divided table, is refused by the driver. Read by computed display, so a clone answers for its source.
+ * @remarks Asked by the driver alone, for the one shape that stays refused: such a footer taller than the page area (*the footer before the rows*, 2026-10-15). Its words follow the rows in the word space ({@link inDisplayOrder}), so everywhere else it is a footer like any other. Read by computed display, so a clone answers for its source.
  *
  * @param el - a clone or a source element.
  */
-export declare function headerAfterRows(el: Element): boolean;
+export declare function footerBeforeRows(el: Element): boolean;
 /**
  * The computed style of the box an author declared — the clone's registered source, or the element itself where it is live and connected. `null` for everything else, which is the honest answer rather than a default: a detached clone with no registration is a `<br>` or a filler span the Compositor inserted, and an element nobody declared has no declaration to read.
  *

package/dist/src/word-space.js

@@ -29,7 +29,7 @@ export const UNSPACED_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Kata
 /**
  * Could the browser have drawn a hyphen at a line boundary between these two characters that the source does not carry? The one question that decides whether a line inside a word may be a cut the fragment can write: a silent break needs nothing at the cut, and a break after U+00AD needs the soft hyphen the source holds written as the hyphenation character (`fragments.js`, *the hyphen is written at the cut*). What is left is a hyphen the browser drew between two letters under `hyphens: auto`, where no character of the source says where.
  *
- * **Refuses where it cannot tell.** Under `hyphens: auto` the browser may hyphenate between any two letters of a script that hyphenates, and nothing in the DOM says whether it did — so that break is refused, the word stays whole, and the page ends a line early rather than print half a word with no hyphen. (The browser does leave its drawing in the range rects, an inked rect for the hyphen on the line it ends, so the question is answerable by measurement; what an address would say for it is its own round.) `hyphens: none` and `manual` draw one only at a soft hyphen.
+ * **Answered by measurement, read by the source on both sides.** Under `hyphens: auto` the browser may hyphenate between any two letters of a script that hyphenates, and nothing in the DOM says whether it did; the range rects do, an inked rect for the hyphen on the line the break ends. So the Gauge opens a piece at such a break only where it measured that hyphen (`gauge.js`, `drewHyphen`), and refuses one that drew none, where the page ends a line early rather than print a hyphen the browser did not draw; the fragment writer asks this same predicate of the same characters and adds the hyphenation character after the last kept letter (`fragments.js`). The address carries no mark: the measurement decides which breaks are cuts, and the source decides what the cut writes. `hyphens: none` and `manual` draw one only at a soft hyphen.
  *
  * @param before - the character before the break
  * @param after - the character after it
@@ -481,31 +481,59 @@ export function blockChildrenOf(el, isInline = isInlineBox) {
     return out;
 }
 /**
- * Is this a table's footer group written before a row or row group of its table — HTML 4's order, still legal — which CSS 2.1 §17.2 lays out after them all the same (*"always displayed after all other rows and row groups"*)?
+ * A table's children in CSS 2.1 §17.2's display order: its header group before every other row and row group, its footer group after them, and everything else as written. Any other element's children are returned as they are, the same array.
  *
- * @remarks The one place the order and the layout disagree inside a table's procession (*the footer before the rows*, 2026-10-15): the Gauge walks such a footer last, the Stonehand offers no place before it or inside it, and the footer's reservation is made where it stands. Read by computed display, so a clone answers for its source.
+ * @remarks THE WORD SPACE follows this order inside a table (*the-word-space-follows-the-table-display-order*, 2026-11-07), and so does every reader of it: the position index numbers a table's words in it, a path's indices count a table's children in it, the Gauge walks a table's procession in it, and a fragment's two cuts put away the children standing before or after them in it. §17.2 lays a `table-header-group` out *"before all other rows and row groups"* and a `table-footer-group` *"after all other rows and row groups"*, wherever each is written, and Chromium paints them so; numbered in the order written, a header after its rows had its words last and its box first, which lost rows with no message (*thead-after-rows-and-tall-footer-lose-rows*). Only the first group of each kind moves, because §17.2 renders any later one as a row group. A move only ever goes toward the rows, so a table written in HTML's order is returned unchanged. Read by computed display, so a clone answers for its source, and a tree that cannot be asked (the DOM-free suites) keeps the order written.
  *
- * @param el - a clone or a source element.
+ * @param parent - the element whose children these are.
+ * @param items - its children, or what stands for them (the Gauge's boxes), in the order written.
+ * @param elOf - the element an item stands for; `null` for a text node, which stays where it is.
  */
-export function footerBeforeRows(el) {
-    if (sourceStyle(el)?.display !== 'table-footer-group')
-        return false;
-    for (let s = el.nextElementSibling; s; s = s.nextElementSibling)
-        if (/^table-row(-group)?$/.test(sourceStyle(s)?.display ?? ''))
-            return true;
-    return false;
+export function inDisplayOrder(parent, items, elOf = (item) => item) {
+    if (items.length < 2 || !/^(inline-)?table$/.test(sourceStyle(parent)?.display ?? ''))
+        return items;
+    const displays = items.map((item) => {
+        const el = elOf(item);
+        return el?.nodeType === 1 ? sourceStyle(el)?.display ?? '' : '';
+    });
+    const h = displays.indexOf('table-header-group');
+    const f = displays.indexOf('table-footer-group');
+    const body = (i) => i !== h && i !== f && /^table-(row|row-group|header-group|footer-group)$/.test(displays[i]);
+    let first = -1;
+    let last = -1;
+    displays.forEach((_, i) => {
+        if (!body(i))
+            return;
+        if (first < 0)
+            first = i;
+        last = i;
+    });
+    const early = h >= 0 && first >= 0 && h > first;
+    const late = f >= 0 && last >= 0 && f < last;
+    if (!early && !late)
+        return items;
+    const out = [];
+    items.forEach((item, i) => {
+        if (early && i === first)
+            out.push(items[h]);
+        if (!((early && i === h) || (late && i === f)))
+            out.push(item);
+        if (late && i === last)
+            out.push(items[f]);
+    });
+    return out;
 }
 /**
- * Is this a table's header group written after a row or row group of its table, which CSS 2.1 §17.2 lays out before them all the same (*"always displayed before all other rows and row groups"*)?
+ * Is this a table's footer group written before a row or row group of its table — HTML 4's order, still legal — which CSS 2.1 §17.2 lays out after them all the same?
  *
- * @remarks The mirror of {@link footerBeforeRows} (*thead-after-rows-and-tall-footer-lose-rows*, 2026-11-07): the Gauge walks such a header first, the Stonehand offers no place inside it or right after it, and its words stand after the rows in the word space, so a page before its words shows it by its repeated copy alone. One that does not repeat, in a divided table, is refused by the driver. Read by computed display, so a clone answers for its source.
+ * @remarks Asked by the driver alone, for the one shape that stays refused: such a footer taller than the page area (*the footer before the rows*, 2026-10-15). Its words follow the rows in the word space ({@link inDisplayOrder}), so everywhere else it is a footer like any other. Read by computed display, so a clone answers for its source.
  *
  * @param el - a clone or a source element.
  */
-export function headerAfterRows(el) {
-    if (sourceStyle(el)?.display !== 'table-header-group')
+export function footerBeforeRows(el) {
+    if (sourceStyle(el)?.display !== 'table-footer-group')
         return false;
-    for (let s = el.previousElementSibling; s; s = s.previousElementSibling)
+    for (let s = el.nextElementSibling; s; s = s.nextElementSibling)
         if (/^table-row(-group)?$/.test(sourceStyle(s)?.display ?? ''))
             return true;
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beltype/cicero",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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",
@@ -40,6 +40,10 @@
       "types": "./dist/seam/client.d.ts",
       "import": "./dist/seam/client.js"
     },
+    "./rim": {
+      "types": "./dist/seam/rim.d.ts",
+      "import": "./dist/seam/rim.js"
+    },
     "./fragmentation": {
       "types": "./dist/src/fragmentation.d.ts",
       "import": "./dist/src/fragmentation.js"