@vincemakes/kiso-tui-cells 0.33.0 → 0.34.0

package/dist/md.d.ts

@@ -37,8 +37,9 @@
  * described twice.
  */
 /** The block kinds. `fence-open`/`fence-line` are separate kinds on
- *  purpose: a fence's rows must be able to freeze ONE AT A TIME. */
-export type MdKind = "para" | "heading" | "list" | "table" | "quote" | "rule" | "fence-open" | "fence-line" | "fence-close";
+ *  purpose: a fence's rows must be able to freeze ONE AT A TIME, and
+ *  MD-1.4's `code-line` is the same shape for the same reason. */
+export type MdKind = "para" | "heading" | "list" | "table" | "quote" | "rule" | "fence-open" | "fence-line" | "fence-close" | "code-line";
 /** One block: its SOURCE lines, never a rendered form. The render is a
  *  pure function of (block, width), which is what makes the freeze
  *  property a property of the scanner alone. */

package/dist/md.js

@@ -52,6 +52,46 @@ const RULE = /^ {0,3}(?:-{3,}|\*{3,}|_{3,}) *$/;
 const QUOTE = /^ {0,3}> ?(.*)$/;
 const TABLE = /^ {0,3}\|/;
 const ITEM = /^( *)([-*+]|\d{1,9}[.)])[ \t]+(.*)$/;
+/** MD-1.4 — a SETEXT underline. Only meaningful under an OPEN paragraph,
+ *  which is the only place `#line` consults it. Before this, `=` was not a
+ *  construct at all, so it leaked into the paragraph's own text, and a `-`
+ *  underline classified as a RULE, so the heading's text became a
+ *  paragraph with a full-width divider under it. Both outputs were
+ *  CORRUPTED, not merely unstyled, and a guess printed into scrollback is
+ *  indistinguishable from a fact. */
+const SETEXT = /^ {0,3}(=+|-+) *$/;
+/** MD-1.4 — an indented code block's line. Four columns, the markdown
+ *  marker; tested AFTER `ITEM`, so a nested list written with four spaces
+ *  stays a list. That is a deliberate deviation, and the reason is
+ *  frequency: a four-space nested list is far more common in model prose
+ *  than an indented code block that opens with a list marker. A TAB indent
+ *  is not recognised here (it stays prose) — stated rather than implied.
+ *
+ *  MD1-F4 — and the indent alone is NOT enough: a line that would classify
+ *  here is PROSE when the most recent block is a `list`. For `1. ` the
+ *  content indent is three columns, so a line indented four after a blank
+ *  is the item's continuation paragraph and code inside that item would
+ *  need seven. Models write that shape constantly — numbered steps, each
+ *  with an explanatory paragraph under it — and rendering it verbatim
+ *  destroyed the reflow and kept a four-space indent. `code-line` is
+ *  therefore reached only after a paragraph, heading, rule, quote, table
+ *  or fence, or at the start of a message.
+ *
+ *  MD1-F4b — and the context OUTLIVES the paragraph it demoted. A demoted
+ *  block is the item's continuation, so closing one leaves the context as
+ *  `list` and the SECOND and third indented paragraphs under one item are
+ *  prose as well. An earlier version of this rule consulted only the most
+ *  recent block, and a numbered step with two paragraphs under it rendered
+ *  the second one verbatim — the same defect one paragraph later. The
+ *  context ends where it should: at the first unindented block, or at a
+ *  heading, rule, quote, table or fence, each of which names its own kind.
+ *
+ *  Two consequences, stated rather than discovered: an indented code block
+ *  nested INSIDE a list item is not recognised (it renders as the item's
+ *  paragraph), and blank lines inside an indented block collapse to ONE gap
+ *  row, exactly as they do between paragraphs — two blank lines in a code
+ *  block come back as one. */
+const CODE = /^ {4,}/;
 /** The kind a line would START. null = blank (a block separator). */
 function classify(line) {
     if (line.trim() === "")
@@ -68,6 +108,8 @@ function classify(line) {
         return "table";
     if (ITEM.test(line))
         return "list";
+    if (CODE.test(line))
+        return "code-line";
     return "para";
 }
 /** Can `line` JOIN an open block of this kind? Headings, rules and the
@@ -78,13 +120,16 @@ function joins(kind, line) {
         return false; // a blank closes everything
     switch (kind) {
         case "para":
-            return c === "para";
+            // MD-1.4: an indented line CONTINUES a paragraph rather than opening
+            // a code block — indented code cannot interrupt a paragraph, so a
+            // `code-line` only ever starts one after a blank.
+            return c === "para" || c === "code-line";
         case "list":
             // a list item's continuation must be INDENTED — an unindented
             // paragraph after a list starts a paragraph (the lazy-continuation
             // rule is a documented deviation: predictable beats compliant when
             // the output is committed).
-            return c === "list" || (c === "para" && /^[ \t]/.test(line));
+            return c === "list" || ((c === "para" || c === "code-line") && /^[ \t]/.test(line));
         case "table":
             return c === "table";
         case "quote":
@@ -93,6 +138,16 @@ function joins(kind, line) {
             return false;
     }
 }
+/** A heading's LEVEL and TEXT, ATX or setext. A setext block's lines are
+ *  the paragraph's own with the underline last — the SOURCE, never a
+ *  rewritten ATX form, so the block still says what the model sent. */
+function headingShape(lines) {
+    const last = lines[lines.length - 1] ?? "";
+    if (lines.length > 1 && SETEXT.test(last))
+        return { level: last.trimStart().startsWith("=") ? 1 : 2, text: lines.slice(0, -1).join(" ") };
+    const m = HEADING.exec(lines[0] ?? "");
+    return { level: (m?.[1] ?? "#").length, text: m?.[2] ?? lines[0] ?? "" };
+}
 /** The fence marker a line opens with (``` or ~~~, 3+). */
 function fenceMark(line) {
     return FENCE.exec(line)?.[1] ?? "```";
@@ -121,6 +176,18 @@ export class MdStream {
     /** blocks STARTED so far — the gap rule's only input (the first block
      *  of a message opens tight; every later one carries its own blank). */
     #started = 0;
+    /** MD-1.4 / MD1-F4 — the kind of the most recent BLOCK, which is what
+     *  decides whether an indented line is code or prose. Kept HERE rather
+     *  than read back off `#closed`: the tail block is not in `#closed` at
+     *  all, and `blocks()` hands out fresh objects. It is only ever read
+     *  while `#open` is null, so "most recent" is never ambiguous. */
+    #lastKind = null;
+    /** MD-1.4 — was the last COMPLETE line an indented code line? Each such
+     *  line is its own block (line-local, so a long indented block streams
+     *  through the live region exactly as a fence body does), which means the
+     *  gap rule needs to know that the block before it was the same block:
+     *  the FIRST line of a block carries the blank, the rest do not. */
+    #code = false;
     /** Append streamed text. Only COMPLETE lines reach the state machine. */
     push(text) {
         // the renderer consumes already-scrubbed text and never re-introduces
@@ -157,16 +224,30 @@ export class MdStream {
             out.push(p === "" ? frozen(this.#open) : frozen(this.#open, p));
             return out;
         }
-        const k = classify(p);
+        const { kind: k } = this.#kindOf(p);
         if (k !== null)
-            out.push({ kind: k, lines: [p], gap: this.#started > 0, lang: k === "fence-open" ? fenceLang(p) : "" });
+            out.push({ kind: k, lines: [p], gap: this.#started > 0 && !(k === "code-line" && this.#code), lang: k === "fence-open" ? fenceLang(p) : "" });
         return out;
     }
+    /** MD1-F4 — the kind a line starts HERE: `classify` plus the one piece of
+     *  context that decides code from prose, an indented line after a list
+     *  being the list item's continuation paragraph. `demoted` says the
+     *  answer CAME from that context, which is what the open block is marked
+     *  with so the context can outlive it (MD1-F4b). */
+    #kindOf(line) {
+        const k = classify(line);
+        const demoted = k === "code-line" && this.#lastKind === "list";
+        return { kind: demoted ? "para" : k, demoted };
+    }
     /** How many leading blocks are CLOSED — the commit-eligible count. */
     closed() {
         return this.#closed.length;
     }
     #line(line) {
+        // MD-1.4: `#code` describes the PREVIOUS complete line, so it is read
+        // and cleared here and set again only on the code-line path.
+        const wasCode = this.#code;
+        this.#code = false;
         if (this.#fence !== null) {
             // E2: the closer emits its OWN block now. The rule it used to
             // obey — "a bottom border is drawn only by an actual close, and
@@ -183,7 +264,31 @@ export class MdStream {
             this.#push({ kind: "fence-line", lines: [line], gap: false, lang: "" });
             return;
         }
-        const k = classify(line);
+        // MD-1.4 — a SETEXT underline closes the OPEN paragraph as a HEADING.
+        // The decision is taken on the COMPLETE underline line, which is the
+        // freeze rule itself: the paragraph has not closed yet when the
+        // underline arrives, so no committed row changes. This is also the
+        // whole of the `rule` interaction — a `-` underline outranks RULE
+        // exactly where a paragraph is open, which is the only condition under
+        // which it could be an underline at all. The block keeps its SOURCE
+        // lines, underline last; `headingShape` reads the level off it.
+        //
+        // One interaction worth naming rather than leaving to be discovered:
+        // the live cell holding an OPEN paragraph is eligible for the
+        // compositor's force-commit (`#capLive` excludes only a RUNNING tool
+        // card), so on a short terminal a long paragraph can reach scrollback
+        // before its underline arrives — and the promotion then applies to
+        // rows that are already committed and plain. Pre-existing class (the
+        // report's §4.9 escalated risk, FINDING TUI2-MD-1's neighbourhood);
+        // what is new here is that the flip it misses is a STYLE flip. Not
+        // reproduced in this round.
+        if (this.#open !== null && this.#open.kind === "para" && SETEXT.test(line)) {
+            this.#closed.push({ kind: "heading", lines: [...this.#open.lines, line], gap: this.#open.gap, lang: "" });
+            this.#open = null;
+            this.#lastKind = "heading";
+            return;
+        }
+        const { kind: k, demoted } = this.#kindOf(line);
         if (k === null) {
             this.#shut();
             return;
@@ -202,18 +307,32 @@ export class MdStream {
             this.#push({ kind: k, lines: [line], gap: this.#started > 0, lang: "" });
             return;
         }
-        this.#open = { kind: k, lines: [line], gap: this.#started > 0, lang: "" };
+        if (k === "code-line") {
+            // line-local like a fence body: final the moment its newline lands.
+            // Only the FIRST line of the block carries the blank above it.
+            this.#push({ kind: k, lines: [line], gap: this.#started > 0 && !wasCode, lang: "" });
+            this.#code = true;
+            return;
+        }
+        this.#open = { kind: k, lines: [line], gap: this.#started > 0, lang: "", cont: demoted };
         this.#started += 1;
     }
     /** A block that is final the moment its line is. */
     #push(b) {
         this.#closed.push(b);
         this.#started += 1;
+        this.#lastKind = b.kind;
     }
     #shut() {
         if (this.#open === null)
             return;
         this.#closed.push(frozen(this.#open));
+        // MD1-F4b — a DEMOTED block is the list item's continuation, so the
+        // list context outlives it: the second and third indented paragraphs
+        // under one item are prose too. The context ends where it should, at
+        // the first unindented block or at a heading, rule, quote, table or
+        // fence, because those set `#lastKind` to their own kind.
+        this.#lastKind = this.#open.cont ? "list" : this.#open.kind;
         this.#open = null;
     }
 }
@@ -232,10 +351,22 @@ export function renderMarkdown(text, W) {
 /** One block's screen rows. Pure in (block, W) — this is the whole
  *  freeze guarantee: same source, same width, same bytes, forever. */
 export function renderBlock(b, W) {
-    const rows = blockBody(b, Math.max(1, W));
-    return b.gap ? ["", ...rows] : rows;
+    return withGap(b, blockBody(b, Math.max(1, W), 0));
 }
-function blockBody(b, W) {
+/** The markdown rhythm: a block that carries `gap` opens with a blank row.
+ *  One helper because there are two callers — this module's entry point and
+ *  the nested render inside a quote, which has to reproduce the rhythm of
+ *  the blocks it contains. */
+function withGap(b, rows) {
+    return b.gap ? ["", ...rows] : [...rows];
+}
+/** MD-1.5 — how deep a quote may nest before it stops being rendered as
+ *  blocks. A `>>>>>` quote in a narrow terminal spends two columns per
+ *  level, and past this it degrades to the flattened form rather than
+ *  recursing on nothing. Cheap insurance: the wrapper already degrades an
+ *  over-wide prefix instead of throwing. */
+const QUOTE_DEPTH = 4;
+function blockBody(b, W, depth) {
     const p = palette();
     switch (b.kind) {
         case "heading": {
@@ -247,18 +378,31 @@ function blockBody(b, W) {
             // and a marker is the only carrier that survives a pipe. A
             // `**bold**` inside a heading is still a no-op, which is the mono
             // discipline paying for itself.
-            const m = HEADING.exec(b.lines[0] ?? "");
-            const level = (m?.[1] ?? "#").length;
-            const text = m?.[2] ?? b.lines[0] ?? "";
+            const { level, text } = headingShape(b.lines);
             const style = level === 1 ? `${p.bold}${p.underline}` : p.bold;
             const marker = level >= 3 ? `${"#".repeat(level)} ` : "";
             return wrap(`${style}${marker}${inlineSpans(text, style)}${p.reset}`, W, "", "");
         }
-        case "rule":
-            // R2: the dashed rule, at the block's own width. The 28 was a
-            // guess that read as a short line rather than a divider, and ─
-            // belonged to the box vocabulary this round is collapsing.
-            return [`${p.dim}${"\u2500".repeat(Math.max(1, W))}${p.reset}`];
+        case "rule": {
+            // R2: the rule at the block's own width. The 28 was a guess that
+            // read as a short line rather than a divider.
+            //
+            // MD-1.6 — and it takes the BLOCK INSET, two columns, like a fence
+            // body. Without it this row and `boxTop` emitted identical bytes —
+            // same glyph, same dim, same full width — so in scrollback you could
+            // not tell "the model drew a divider" from "kiso closed a panel".
+            // The fix is the inset and NOT a new glyph: R3 (owner, 2026-08-27)
+            // ruled the rule is a solid hairline everywhere, "one line, one
+            // weight, no exceptions to remember", and a new glyph would reverse
+            // that. Content and chrome differ by their LEFT EDGE instead, which
+            // is how every other register is told apart under R13 E3.
+            //
+            // The inset is chrome this renderer generates, so at a width that
+            // cannot pay for it, it yields — the same rule `mdWrap` applies to
+            // an over-wide prefix.
+            const inset = W >= 4 ? "  " : "";
+            return [`${inset}${p.dim}${"\u2500".repeat(Math.max(1, W - inset.length))}${p.reset}`];
+        }
         case "fence-open":
             // E2: the RAIL, not a gutter. A block drawn with ``` is still a
             // fenced block when a human selects it and pastes it somewhere
@@ -271,14 +415,20 @@ function blockBody(b, W) {
             // unterminated fence draws no bottom, which is the truth about
             // an unterminated fence.
             return [`${p.dim}${RAIL}${p.reset}`];
-        case "fence-line": {
+        case "fence-line":
+        case "code-line": {
             // a fence body's INDENTATION is its content. The wrapper drops
             // leading spaces \u2014 right for prose, a lie for code \u2014 so the indent
             // rides as the row prefix instead, and a wrapped long line hangs
             // under it rather than returning to the gutter.
             const src = (b.lines[0] ?? "").replace(/\t/g, "    ");
             const indent = /^ */.exec(src)[0];
-            const gutter = "  "; // E2: the rails bound the block; the body just insets
+            // MD-1.4: a fence body insets under its own ``` rails. An indented
+            // code block has no rails, so it takes no gutter either: its four
+            // spaces ARE the marker the model wrote, and a block that pastes
+            // back as indented code is the copy-fidelity goal. Saying "verbatim"
+            // twice would cost four columns and buy nothing.
+            const gutter = b.kind === "fence-line" ? "  " : "";
             // DC-3: a fenced BODY carries no colour token. It used to take
             // `code` — 1.54:1 on a white terminal, applied to whole blocks,
             // which made the code the model just wrote the least readable
@@ -288,15 +438,8 @@ function blockBody(b, W) {
             // nothing.
             return foldLineWidth(src.slice(indent.length), W - visibleWidth(gutter), indent).map((r) => `${gutter}${r}`);
         }
-        case "quote": {
-            const text = b.lines.map((l) => QUOTE.exec(l)?.[1] ?? l).join(" ");
-            // R2: one gutter glyph. A quote and a fenced block both say "this
-            // text is not mine", and the screen was saying it two ways — ▏
-            // here and │ for code. The fences took their own ``` rails, so │
-            // is free and the quote takes it.
-            const gutter = `${p.dim}\u2502${p.reset} `;
-            return wrap(`${p.dim}${inlineSpans(text, p.dim)}${p.reset}`, W - visibleWidth(gutter), "", "").map((r) => `${gutter}${r}`);
-        }
+        case "quote":
+            return quoteRows(b, W, depth);
         case "list":
             return listRows(b, W);
         case "table":
@@ -507,12 +650,53 @@ function listRows(b, W) {
     flush();
     return out.length > 0 ? out : [""];
 }
+/**
+ * The quote. Its content is BLOCKS, and it is rendered as blocks: the `> `
+ * markers come off, the stripped text goes through a NESTED stream — a
+ * local, built per render, so `renderBlock` stays pure in (block, W) — and
+ * every row it produces takes the `│ ` gutter.
+ *
+ * R2: one gutter glyph. A quote and a fenced block both say "this text is
+ * not mine", and the screen was saying it two ways — ▏ here and │ for code.
+ * The fences took their own ``` rails, so │ is free and the quote takes it.
+ *
+ * MD-1.5 — joining the quote's lines with spaces made a quoted list and a
+ * quoted second paragraph into one reflowed line, which is the same class
+ * of defect as MD-1.4's: the structure the model sent was destroyed, not
+ * merely unstyled.
+ *
+ * MD-1.5's judgement call: the blanket `dim` over the whole quote is GONE
+ * and the gutter carries "not mine" alone. With inner blocks the blanket
+ * dim would put dim OVER bold in a quoted heading, which is a
+ * contradiction, and over a fence body's inset in a quoted fence. It is
+ * also MD-1.2's argument one item earlier: `dim` is a LABEL tier and a
+ * quote is body text. The gutter stays dim, because a gutter IS a label.
+ */
+function quoteRows(b, W, depth) {
+    const p = palette();
+    const gutter = `${p.dim}\u2502${p.reset} `;
+    const bar = `${p.dim}\u2502${p.reset}`;
+    const text = b.lines.map((l) => QUOTE.exec(l)?.[1] ?? l).join("\n");
+    const room = Math.max(1, W - visibleWidth(gutter));
+    if (depth >= QUOTE_DEPTH)
+        return wrap(inlineSpans(text.split("\n").join(" "), ""), room, "", "").map((r) => `${gutter}${r}`);
+    const inner = new MdStream();
+    inner.push(text);
+    inner.end();
+    const rows = inner.blocks().flatMap((blk) => withGap(blk, blockBody(blk, room, depth + 1)));
+    // a blank row inside a quote takes the bar and no trailing space: the
+    // gutter says "still the quote", the space would be whitespace a human
+    // copies for nothing.
+    return rows.map((r) => (r === "" ? bar : `${gutter}${r}`));
+}
 /**
  * The table. Columns are measured at their NATURAL widths, on the
  * inline-rendered text with the SGR stripped (a bold cell is four
- * columns, not twelve). If the whole table fits, it is drawn aligned
- * with the dim rails; if it does not, it does NOT shrink and it does
- * NOT cut — every row becomes a record, and every cell survives.
+ * columns, not twelve). If the natural widths fit, the table is drawn at
+ * them; if they do not, the columns SHRINK and the cells wrap inside
+ * them (MD-1.1); only when every column has reached its floor and the
+ * table still does not fit does every row become a record. It never
+ * cuts, at any width, in any form.
  *
  * A rejected shape (no delimiter row, or a body row wider than the
  * header) falls back to its own source lines, which are still valid
@@ -521,40 +705,126 @@ function listRows(b, W) {
  * fact.
  */
 function tableRows(b, W) {
-    const p = palette();
     const t = tableShape(b.lines);
     if (t === null)
         return b.lines.flatMap((l) => wrap(l, W, "", ""));
-    const cols = t.header.map((h, i) => Math.max(cellWidth(h), ...t.rows.map((r) => cellWidth(r[i] ?? ""))));
+    const natural = t.header.map((h, i) => Math.max(cellWidth(h), ...t.rows.map((r) => cellWidth(r[i] ?? ""))));
+    const cols = shrinkCols(natural, W);
+    if (cols === null)
+        return recordRows(t, W);
+    const p = palette();
     // R2: no rails. The drawn width is two columns of inset plus the
     // columns and their two-space gutters — a table is bounded by the
     // blank lines above and below it, exactly as every other block on the
     // screen is, and it was the last box left on a screen that has decided
     // not to have boxes. Alignment does the work the rails were doing, and
     // a copied table is closer to markdown without them.
-    const total = cols.reduce((n, w) => n + w + 2, 2);
-    if (total > W)
-        return recordRows(t, W);
-    const row = (cells, bold) => `  ${cells.map((c, i) => pad(c, cols[i], t.align[i], bold)).join("  ")}`.replace(/\s+$/, "");
-    return [row(t.header, true), ...t.rows.map((r) => row(r, false))];
+    const row = (cells, bold) => {
+        const boxes = cells.map((c, i) => cellBox(c, cols[i], t.align[i], bold));
+        const rows = [];
+        for (let k = 0; k < Math.max(...boxes.map((x) => x.length)); k += 1) {
+            // a short box pays its blanks so the columns to its right do not
+            // move: a cell is a BOX, and the row is as tall as its tallest.
+            rows.push(`  ${boxes.map((x, i) => x[k] ?? " ".repeat(cols[i])).join("  ")}`.replace(/\s+$/, ""));
+        }
+        return rows;
+    };
+    // MD-1.3 / R2 AMENDMENT 1 (owner ruling, 2026-09-11) — ONE rule under
+    // the header row, at the grid's own width. R2 removed the RAILS: the
+    // four-sided box that BOUNDS a table. This bounds nothing; it SEPARATES
+    // the header from the body, which is the one job the round's governing
+    // distinction gives a rule — a rule separates, a gutter scopes, a rail
+    // bounds. Rails stay out.
+    //
+    // What it buys is not decoration: without it a six-row table's header
+    // was carried by SGR bold ALONE, so in a pipe, under NO_COLOR, or on a
+    // terminal with weak bold, seven identical rows arrived with nothing
+    // saying which one names the columns.
+    const ruleW = cols.reduce((n, w) => n + w, 0) + Math.max(0, cols.length - 1) * 2;
+    return [...row(t.header, true), `  ${p.dim}${"\u2500".repeat(ruleW)}${p.reset}`, ...t.rows.flatMap((r) => row(r, false))];
 }
 /** A cell's column count: what a human sees, styling removed. */
 function cellWidth(cell) {
     return visibleWidth(inlineSpans(cell, ""));
 }
-/** One padded cell — the styling goes on AFTER the measure, so it can
- *  never move a column. */
-function pad(cell, w, align, bold) {
+/** MD-1.1 — the SHRINK FLOOR: eight columns, four CJK characters. A
+ *  column whose natural width is already at or below it never shrinks at
+ *  all. The 8 is a judgement and not a measurement — it is where the
+ *  report's sample stopped reading as a table — and it is the one number
+ *  that decides when the record form is still the better answer. */
+const CELL_FLOOR = 8;
+/** The drawn width of a grid with these columns, by the measure the R2
+ *  table has always used: the two-column inset plus every column AND its
+ *  two-space gutter. Conservative by one gutter (the last column has
+ *  none), which is where the table's right margin comes from — kept as
+ *  it was, because the record threshold has always been stated in it. */
+function gridWidth(cols) {
+    return cols.reduce((n, w) => n + w + 2, 2);
+}
+/**
+ * MD-1.1 — take one column off the WIDEST column until the grid fits.
+ * Returns null when every column has reached its floor and it still does
+ * not, which is the one case the record form exists for.
+ *
+ * There was no shrink step at all before this: a table either fitted at
+ * its natural width or the whole block was abandoned. That made the
+ * degradation a cliff — the owner's 6-column sample missed the grid by 8
+ * columns at terminal 80 and collapsed into eleven rows of records, when
+ * the two columns carrying long CJK phrases would each have wrapped
+ * inside their cell for free.
+ *
+ * Greedy, and therefore PREDICTABLE rather than optimal: always the
+ * widest column, ties to the left. A column holding one long unbreakable
+ * token will spend its way to the floor and force its neighbours
+ * narrower — the cost of a rule a human can hold in their head.
+ */
+function shrinkCols(natural, W) {
+    const floor = natural.map((w) => Math.min(w, CELL_FLOOR));
+    const cols = [...natural];
+    while (gridWidth(cols) > W) {
+        let at = -1;
+        for (let i = 0; i < cols.length; i += 1)
+            if (cols[i] > floor[i] && (at < 0 || cols[i] > cols[at]))
+                at = i;
+        if (at < 0)
+            return null;
+        cols[at] = cols[at] - 1;
+    }
+    return cols;
+}
+/** One cell as a BOX: its text wrapped inside the column, every row
+ *  padded to the column's width by the column's alignment. The styling
+ *  goes on AFTER the measure, so it can never move a column, and the
+ *  wrapper is the same one every other block folds through — so a cell
+ *  obeys the kinsoku set and the width authority like all other text. */
+function cellBox(cell, w, align, bold) {
     const p = palette();
     const body = bold ? `${p.bold}${inlineSpans(cell, p.bold)}${p.reset}` : inlineSpans(cell, "");
-    const slack = Math.max(0, w - cellWidth(cell));
-    const left = align === "right" ? slack : align === "center" ? Math.floor(slack / 2) : 0;
-    return `${" ".repeat(left)}${body}${" ".repeat(slack - left)}`;
-}
-/** The narrow degradation: one record per row. The first column names
- *  the record (bold, with a dim colon); the rest is a dim `label:
- *  value` run joined by `·`, wrapped rather than cut. A blank row
- *  separates records — nothing is dropped at any width. */
+    return mdWrap(body, w, "", "").map((r) => {
+        const slack = Math.max(0, w - visibleWidth(r));
+        const left = align === "right" ? slack : align === "center" ? Math.floor(slack / 2) : 0;
+        return `${" ".repeat(left)}${r}${" ".repeat(slack - left)}`;
+    });
+}
+/**
+ * The narrow degradation: one record per row. The first column names the
+ * record (bold, with a dim colon); the rest is a `label: value` run
+ * joined by `·`, wrapped rather than cut. A blank row separates records —
+ * nothing is dropped at any width.
+ *
+ * MD-1.2 — the LABEL is dim and the VALUE is not. This used to wrap every
+ * label AND every value in ONE `p.dim` span, so a table's actual content
+ * arrived at the lowest contrast tier on the screen while the labels —
+ * scaffolding the reader already read in the header row — carried equal
+ * weight. The emphasis was exactly inverted.
+ *
+ * Per-token contrast was never the defect: `dim` measures 4.54:1 on a
+ * resolved light ground, which is legal for a LABEL. Setting a whole
+ * paragraph of body text in it is a different thing, and on a terminal
+ * that never answered OSC 11 it is worse — the palette keeps SGR 2 there
+ * rather than an absolute grey. `dim` is a label tier; this is the first
+ * place it was asked to be a body tier, and it is no longer asked.
+ */
 function recordRows(t, W) {
     const p = palette();
     const out = [];
@@ -562,9 +832,10 @@ function recordRows(t, W) {
         if (out.length > 0)
             out.push("");
         out.push(...wrap(`${p.bold}${inlineSpans(t.header[0] ?? "", p.bold)}${p.reset}${p.dim}:${p.reset} ${inlineSpans(r[0] ?? "", "")}`, W, "", ""));
-        const rest = t.header.slice(1).map((h, i) => `${h}: ${r[i + 1] ?? ""}`);
+        const rest = t.header.slice(1).map((h, i) => `${p.dim}${inlineSpans(h, p.dim)}:${p.reset} ${inlineSpans(r[i + 1] ?? "", "")}`);
+        // the `·` stays dim: it is punctuation between pairs, not content.
         if (rest.length > 0)
-            out.push(...wrap(`${p.dim}${inlineSpans(rest.join(" · "), p.dim)}${p.reset}`, W, "", ""));
+            out.push(...wrap(rest.join(`${p.dim} · ${p.reset}`), W, "", ""));
     }
     return out.length > 0 ? out : [row0(t)];
 }
@@ -624,7 +895,18 @@ function tokens(text) {
             prev = ch;
             continue;
         }
-        if (cur !== "" && prev !== "" && breaks(prev, ch))
+        // MD1-F1: a `cur` holding nothing but SGR is ZERO-WIDTH and RIDES the
+        // token it precedes — this function's own contract, which the flush
+        // below used to break. Emitted as a token of its own it measures 0, so
+        // `w + pendW + 0 > room` can take a break AT it: the pending space is
+        // dropped, the style lands at the head of the next row, and the word it
+        // belonged to goes to the row after. Invisible while every style
+        // boundary sat at a space (every ASCII case), reachable the moment one
+        // sits before a CJK character, which MD-1.2's per-label dim made
+        // common in the record form. What it costs there is a trailing space
+        // and an empty style span; what it does NOT cause is FINDING MD1-F3
+        // below, which is older than this and survives the guard.
+        if (cur !== "" && w > 0 && prev !== "" && breaks(prev, ch))
             flush();
         cur += ch;
         w += charWidth(cp);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui-cells",
-	"version": "0.33.0",
+	"version": "0.34.0",
 	"description": "kiso tui-cells — the components cell renderer (components, diff, width, the render slice). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",