@beltype/cicero 0.1.6 → 0.1.8

package/dist/src/reads.js

@@ -7,12 +7,12 @@
  *
  * **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
  */
 import { READ_PREFIX, STRING_KEYWORDS, STRING_PROP_PREFIX, decodeRead, encodeStringProp, splitTopLevel } from './gcpm-encoding.js';
-import { styleSheetsOf } from './capture.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 { indexBlocks, pageContaining, pageIntervals, pathOf } from './positions.js';
@@ -26,7 +26,7 @@ export const MAX_RUNS = 3;
 /** The reservation a forward layout read stands at during the first run, Egildo's ruling of 2026-10-03: wrong for nearly every reference, so nothing rests on it, and never printed, because the loop keeps the last true values. */
 export const RESERVATION = '0';
 /** A CSS string literal for any text: a quote, a backslash and a line break escaped, nothing else. */
-export const cssString = (text) => `"${String(text).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\a ')}"`;
+export const cssString = (text) => `"${String(text).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/[\u0000-\u001f\u007f]/g, (ch) => `\\${ch.charCodeAt(0).toString(16)} `)}"`;
 /** The selector a delivery is keyed by: the attribute the function reads, at the value this element carries. */
 export const attrSelector = (attr, value) => `[${attr}=${cssString(value)}]`;
 /**
@@ -285,7 +285,7 @@ export function findSites(doc, originals = null, keep = null) {
                     read,
                     link,
                     key: read.attr != null ? (link == null ? null : attrSelector(read.attr, link)) : '',
-                    target: fragment == null ? null : doc.getElementById(fragment),
+                    target: fragment == null ? null : targetOf(doc, fragment, originals),
                     pseudos
                 });
             }
@@ -293,6 +293,19 @@ export function findSites(doc, originals = null, keep = null) {
     }
     return sites.length ? sites : null;
 }
+/** The element a fragment names: `doc.getElementById`'s answer, or, where the host hands its originals, the first element carrying the id among them, so a host's own element that shares an author's id is never a target. */
+function targetOf(doc, fragment, originals) {
+    const first = doc.getElementById(fragment);
+    if (!originals || !first || originals.some((box) => box.contains(first)))
+        return first;
+    const selector = `[id="${fragment.replace(/["\\]/g, '\\$&').replace(/\n/g, '\\a ')}"]`;
+    for (const box of originals) {
+        const el = box.id === fragment ? box : box.querySelector(selector);
+        if (el)
+            return el;
+    }
+    return null;
+}
 /** The engine's one delivery sheet per document, replaced at every delivery and withdrawn when a paginate finds nothing to deliver. */
 const SHEETS = new WeakMap();
 /** Deliver a table of values: one constructed sheet, adopted once, its text replaced. */
@@ -377,6 +390,7 @@ export function staticValues(sites, { doc, blocks, index = null, keep = null })
         const win = doc.defaultView;
         const ops = documentOpsOf(blocks, index ?? indexBlocks(blocks), {
             styleOf: (el) => win.getComputedStyle(el),
+            pseudoStyleOf: sheetsCountInPseudos(doc) ? (el, pseudo) => win.getComputedStyle(el, pseudo) : null,
             ancestors: [doc.documentElement, doc.body].filter(Boolean),
             marks: new Set(counted.map((s) => s.target)),
             keep
@@ -514,7 +528,7 @@ function boxAddress(site, index, blocks) {
  *
  * **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 async function settleReads(doc, { run, blocksOf, originals = null, warm = null, warmFacts = null, hide = false, keep = null }) {
     let t = performance.now(); // the site search is the reads' own cost and is inside their measure (*a resumed run keeps its reads*, 2026-10-22)
@@ -529,6 +543,10 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
     const name = (s) => ('read' in s ? `<${s.el.tagName.toLowerCase()}${s.link == null ? '' : ` ${s.read.attr ?? 'url'}="${s.link}"`}>` : `<${s.el.tagName.toLowerCase()}${s.el.id ? ` id="${s.el.id}"` : ''}>`);
     const named = (list) => [...new Set(list.map(name))].join(', ');
     const blocks = blocksOf();
+    // A text target counts only inside the blocks, as every other target does through the position index and the counter walk: an element outside them (a host's own) is no target, and the reference shows nothing.
+    for (const s of sites)
+        if (s.target && s.read.fn === 'text' && !blocks.some((b) => b.contains(s.target)))
+            s.target = null;
     // One walk of the words, shared with the run (*the run resumes from an entry*, build two: 60 ms of every manual run was this walk, done twice). The counter log is not shared, and the reason is worth a line: it is read here before the run registers the GCPM properties, and an unregistered `string-set` inherits, so a log taken now would assign every heading's string to its descendants too.
     const index = indexBlocks(blocks, undefined, undefined, keep);
     const fixed = staticValues(sites, { doc, blocks, index, keep });
@@ -573,6 +591,10 @@ export async function settleReads(doc, { run, blocksOf, originals = null, warm =
         }
         runs++;
         t = performance.now();
+        if (result.complete === false) { // a partial chain is not the document: its pages place only the targets cut so far, so the reservations stay hidden and the table it was laid out under stays the warm one
+            facts = laidFacts;
+            break;
+        }
         showReservations(doc); // the run is complete: what was reserved is delivered true on the next lines, or was true already
         const truth = pageValues(paged, result);
         unplaced = truth.unplaced;

package/dist/src/stonehand.js

@@ -12,6 +12,7 @@
  * @packageDocumentation
  */
 import { isAtom, READS_ITS_CHILDREN } from './word-space.js';
+import { ARTIFACT, 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.
  *
@@ -158,7 +159,7 @@ 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)
+        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);
@@ -197,9 +198,11 @@ function walkOf(report, sourceOf, root = null, styleCache = new Map(), forcing =
     /** A row's items are parallel flows too (*every branch gets a place*, 2026-09-21; §2.1's own list — the cells of a row, grid items, flex items). `report.rowOf` is the Gauge's answer: the side-by-side siblings a box stands among, or null. An item's interior offers nothing, exactly as a float's does, and the boundary between two items of one row is not a place in any procession — they stand beside each other, so nothing lies between them on the block axis. A row therefore offers two readings and no more: the boundary before it, on its first item, and the page edge through it. */
     const rowOf = (box) => (box === root ? null : report.rowOf?.(box) ?? null);
     const insideRowItem = (box) => climb(box, (p) => !!rowOf(p), false);
-    /** Does the walk read this box at all? Not an inline box, nothing inside a monolith, a parallel flow or a row item — and a row answers once, at its first item (see `rowOf`). */
+    /** A copy the engine repeats (`artifact`), the table's header on a continuation: furniture with a footprint, no content of the flow, so no break point stands in it (*an artifact is never read*). */
+    const copy = (box) => !box.anonymous && hasWord(box.el, ARTIFACT);
+    /** Does the walk read this box at all? Not an inline box, nothing inside a monolith, a parallel flow, a row item or a repeated copy — and a row answers once, at its first item (see `rowOf`). */
     const walks = (box) => {
-        if (box.inline || insideMonolith(box) || insideParallel(box) || insideRowItem(box))
+        if (box.inline || copy(box) || insideMonolith(box) || insideParallel(box) || insideRowItem(box) || climb(box, copy, false))
             return false;
         const row = rowOf(box);
         return !row || row[0] === box;
@@ -210,7 +213,7 @@ function walkOf(report, sourceOf, root = null, styleCache = new Map(), forcing =
      * 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).
      */
     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, walks, standsBelow };
+    return { report, sourceOf, boxes, win, root, styleCache, forcing, styleOfBox, monolithic, insideMonolith, parallelBox, insideParallel, rowOf, insideRowItem, copy, walks, standsBelow };
 }
 /** Does this feed hold the box the retreat walk stops at — the first in-flow box whose top lies below the page's limit? The check a bounded feed must pass before anything is decided on it (*the Cast-off bounds the feed*, 2026-09-26): a feed that holds that box gives the walk everything it reads, and one that does not stopped above the edge and is poured again. */
 export function reachesBelowTheEdge({ report, sourceOf, pageStart, contentHeight, eps = 0.25 }) {
@@ -261,7 +264,7 @@ export function firstBelowTheEdge({ report, sourceOf, limit, eps = 0.25, sourced
  * @param a.stats - when given, counts what the collection costs: the boxes it visited, the line stacks it measured and the ones it skipped, and the milliseconds the lines and the end gaps took (`adjudicate` publishes it as the measure's detail).
  */
 function collect(w, { boxes, limit, pageStart, eps, stats }) {
-    const { report, win, root, styleOfBox, monolithic, parallelBox, rowOf, walks, standsBelow } = w;
+    const { report, win, root, styleOfBox, monolithic, parallelBox, rowOf, copy, walks, standsBelow } = w;
     /**
      * §5.3's *leaving room*, priced (*the fragment that wraps itself*, 2026-09-15). *"When a box breaks, its content box extends to fill any remaining fragmentainer extent (leaving room for any margins/borders/padding applied by `box-decoration-break: clone`)."* So a cut inside a box that clones its decoration costs the page that box's block-end border and padding, on top of the content above it — and every ancestor the same cut breaks costs its own.
      *
@@ -280,6 +283,13 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         }
         return px;
     };
+    /** The rise a cut grants inside a table cell it divides: the cell's own nearest, the box included and the root not (a row item's rise is its row's, `rowPlan`). */
+    const liftIn = (box) => {
+        for (let p = box; p && p !== root; p = p.parent)
+            if (styleOfBox(p).display === 'table-cell')
+                return cellLift(w, p);
+        return 0;
+    };
     /** A box's bottom as a place in the procession: a row ends where its tallest item does, not where the item that happens to stand last in the source does. */
     const bottomOf = (box) => {
         const row = rowOf(box);
@@ -310,17 +320,19 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
             else if (item.rect.top >= h - eps)
                 plan.push({ item, state: 'below', verdict: null });
             else {
-                const [begins, reachesBelow] = contentSpanOf(w, item, h, eps);
+                // A cell the height divides sets its content from its own top on this page (`cellLift`), so its content is judged that much lower.
+                const lift = cellLift(w, item);
+                const [begins, reachesBelow] = contentSpanOf(w, item, h + lift, eps);
                 if (begins === null)
                     plan.push({ item, state: 'divided', verdict: null }); // holds nothing to show: a stretched box, divided by the geometry alone
-                else if (begins >= h - eps)
+                else if (begins >= h + lift - eps)
                     plan.push({ item, state: 'below', verdict: null }); // its content begins at or below the height: the break falls in the gap above it (§4.1's Class C, whatever made the gap — padding, an alignment), and the item resumes whole
                 else if (!reachesBelow)
                     plan.push({ item, state: 'done', verdict: null }); // all it has to show stands above the height; only its box reaches below, stretched by the row
                 else if (monolithic(item))
                     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, eps);
+                    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
                     plan.push({ item, state: 'divided', verdict: v });
@@ -344,15 +356,17 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         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.
-        if (si > 0 && !box.laidOutLast) {
+        // 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) {
             // 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;
-            if (anchor) {
+            // 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))) {
                 candidates.push({
                     kind: 'A',
                     cls: 'A',
-                    y: bottomOf(anchor),
+                    y: bottomOf(anchor) - liftIn(box.parent),
                     docIndex,
                     box,
                     cost: clonedBlockEnd(box.parent), // the box itself goes whole to the next page; what this boundary breaks is its container and up
@@ -425,7 +439,7 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
             stats.gapMs += performance.now() - tg;
         if (gap) {
             const y = Math.min(gap.bottom, limit);
-            if (y - gap.base > eps) {
+            if (y - (gap.base - liftIn(box)) > eps) {
                 candidates.push({
                     kind: 'C',
                     cls: 'C',
@@ -444,7 +458,7 @@ 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) {
+        if (firstInFlow && !copy(firstInFlow)) {
             const prevSibling = si > 0 ? siblings[si - 1] : null;
             const bs = win.getComputedStyle(box.el);
             candidates.push({
@@ -480,11 +494,12 @@ function collect(w, { boxes, limit, pageStart, eps, stats }) {
         const orphans = parseInt(st.orphans, 10) || 1;
         const widows = parseInt(st.widows, 10) || 1;
         const window_ = classBWindow(T, orphans, widows);
+        const lift = liftIn(box);
         for (let k = 0; k < T - 1; k++) {
             out.push({
                 kind: 'B',
                 cls: 'B',
-                y: lines[k].bottom,
+                y: lines[k].bottom - lift,
                 docIndex,
                 box,
                 cost: clonedBlockEnd(box),
@@ -545,6 +560,18 @@ function subtreeOf(boxes, root) {
     }
     return out;
 }
+/**
+ * How far a table cell's content rises when a cut divides the cell: the distance from its content box's top to its first line or monolith. A cell's `vertical-align` places its content in the cell's whole height; Chromium's print aligns a divided cell's first fragment within that fragment instead (`FinalizeTableCellLayout`: *the fragment will start at the block-start edge* on a resumption, and the free space is the fragment's own), so content the alignment set below the cut stands above it once the cell is divided. The presentation matches it by pinning the divided cell's height to the page's foot. Zero for anything else, and for a cell aligned at its top.
+ *
+ * @remarks Under collapsed borders the content box is read with the cell's whole border width where half of it is used, so the rise is under by half a border, never over.
+ */
+function cellLift(w, cell) {
+    const st = w.styleOfBox(cell);
+    if (st.display !== 'table-cell')
+        return 0;
+    const [begins] = contentSpanOf(w, cell, -Infinity, 0);
+    return begins === null ? 0 : Math.max(0, begins - (cell.rect.top + (parseFloat(st.borderTopWidth) || 0) + (parseFloat(st.paddingTop) || 0)));
+}
 /** Where a flow's content stands against a height: where it begins (the top of its first line or monolith, null where it holds none) and whether any of it stands below the height — asked of the leaves that reach below it alone, so a flow of a thousand paragraphs above the foot costs the leaves it needs and not its line stacks (a leaf whose box ends above the height has every line above it too). */
 function contentSpanOf(w, root, h, eps) {
     let begins = null;

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

@@ -216,6 +216,14 @@ export declare function blockChildrenOf(el: Element, isInline?: (el: Element) =>
  * @param el - a clone or a source element.
  */
 export declare function footerBeforeRows(el: Element): boolean;
+/**
+ * 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"*)?
+ *
+ * @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.
+ *
+ * @param el - a clone or a source element.
+ */
+export declare function headerAfterRows(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

@@ -495,6 +495,21 @@ export function footerBeforeRows(el) {
             return true;
     return false;
 }
+/**
+ * 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"*)?
+ *
+ * @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.
+ *
+ * @param el - a clone or a source element.
+ */
+export function headerAfterRows(el) {
+    if (sourceStyle(el)?.display !== 'table-header-group')
+        return false;
+    for (let s = el.previousElementSibling; s; s = s.previousElementSibling)
+        if (/^table-row(-group)?$/.test(sourceStyle(s)?.display ?? ''))
+            return true;
+    return false;
+}
 /**
  * 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/package.json

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