@vincemakes/kiso-tui-cells 0.16.2 → 0.16.4

package/dist/components.js

@@ -171,12 +171,17 @@ export function cellComponent(cell) {
  * the ▍ rail and the indent are retired — the rail's stated pipe
  * fallback was theoretical redundancy: the CLI's pipe path is the
  * line-mode "you>" form and never renders UserMessage). The chip folds
- * the text at W−2 (the side pads), then pads EVERY row to the longest
- * row's DISPLAY width + one space each side, flush left: the block is
- * only as wide as what was said (never the full-width band — a short
- * message like /think would paint a bar across the terminal). The
- * padding is by cells (charWidth is the width authority), so a CJK row
- * pads by width, never by chars, and the chip never overruns its fold.
+ * the text at W−2 (the side pads) and pads every row to the FULL width.
+ *
+ * R2 — law 1.6's recorded reversal. This used to size the block to its
+ * longest row, on the argument that "a short message like /think would
+ * paint a bar across the terminal". That optimises the degenerate case
+ * at the cost of every real message, which is a paragraph and reads as
+ * a block only when the block has an edge. The `/think` case is the
+ * accepted price, and it is recorded as such in design.md §1.6.
+ *
+ * The padding is by cells (charWidth is the width authority), so a CJK
+ * row pads by width, never by chars, and the chip never overruns.
  * SGR 7 closed with SGR 27 — never SGR 0, the chip composes with a
  * surrounding span — and NEVER dim: reverse video inverts the CURRENT
  * colours, so dimmed text would invert into a dimmed block with no
@@ -206,22 +211,39 @@ class UserMessage {
         // was a 3000-line turn writing 260,298 bytes in one frame.
         const paras = this.cell.text.split("\n");
         let truncated = false;
+        // DC-6: the folded CONTENT first, then ONE width over all of it.
+        // The pad used to be computed per source paragraph, so a message
+        // with two lines drew as two bars of two different lengths — a
+        // ragged right edge on a block that is one block. A single
+        // paragraph was always correct, which is why it survived: the
+        // shape only appears once a message has a second line.
+        const content = [];
         for (const para of paras) {
-            if (rows.length >= USER_CHIP_ROWS) {
+            if (content.length >= USER_CHIP_ROWS) {
                 truncated = true;
                 break;
             }
-            const folded = foldLine(escapeTerminal(para), chipW);
-            const inner = Math.max(...folded.map((r) => displayWidth(r)));
-            for (const row of folded) {
-                if (rows.length >= USER_CHIP_ROWS) {
+            for (const row of foldLine(escapeTerminal(para), chipW)) {
+                if (content.length >= USER_CHIP_ROWS) {
                     truncated = true;
                     break;
                 }
-                const pad = inner - displayWidth(row);
-                rows.push(`${p.rv} ${row}${" ".repeat(pad)} ${p.rvEnd}`);
+                content.push(row);
             }
         }
+        // R2 (law 1.6's recorded reversal): the band is FULL WIDTH. It was
+        // sized to its longest row, on the argument that a one-word turn
+        // like `/think` would otherwise paint a bar across the terminal —
+        // which optimises the degenerate case at the cost of every real
+        // message. The human's words are the one surface that gets the
+        // whole row.
+        //
+        // displayWidth stays the padding authority (never `length`): a CJK
+        // row is two cells per character and pads by cells.
+        const inner = chipW;
+        for (const row of content) {
+            rows.push(`${p.rv} ${row}${" ".repeat(Math.max(0, inner - displayWidth(row)))} ${p.rvEnd}`);
+        }
         if (!truncated)
             return rows;
         // The notice is OUTSIDE the chip's reverse video, in the cut-row
@@ -265,19 +287,57 @@ class ThinkingFold {
         this.cell = cell;
     }
     render(W, _ctx) {
+        const p = palette();
         const block = this.cell.text;
         const trimmed = escapeTerminal(block.trim());
-        // the SHORT branch is width-aware TOO: the ≤100 short-circuit was
-        // W-blind — a short block at a narrow width returned the line
-        // UNFOLDED and tripped invariant ① (the crash class still live on
-        // npm for short /think blocks after a resize).
-        if (trimmed.length <= 100)
-            return [`${palette().dim}⋯${widthCut(trimmed, Math.max(1, W - 1))}${palette().reset}`];
-        const suffix = ` (${block.length} chars · /think)`;
-        const slice = Math.max(1, W - 1 - suffix.length);
-        return [`${palette().dim}⋯${widthCut(trimmed, slice)}${suffix}${palette().reset}`];
+        // R2 (owner, 2026-08-27) — three changes, each independent.
+        //
+        // ITALIC marks the row as not-the-answer without spending a colour,
+        // on the same argument that admitted italic to the alphabet.
+        //
+        // The cut lands on a WORD. It used to cut on a byte, so the fold
+        // read as `…the user's h` and the reader's eye had to reassemble a
+        // word it already knew.
+        //
+        // The affordance moves to the RIGHT EDGE, so the left edge of every
+        // row on screen is content. The char count goes with the move: it
+        // told the reader nothing they could act on, and the row it was
+        // crowding is the one thing this cell says.
+        //
+        // The ≤100 short-circuit stays width-aware: a short block at a
+        // narrow width returned the line UNFOLDED and tripped invariant ①.
+        // DC-15: the affordance is DROPPED, not squeezed. `room` floored at
+        // 1 while `pad` floored at 1 independently, so a narrow terminal
+        // produced 2 + cut + pad + 6 = 11 cells no matter what W was — and
+        // invariant ① does not truncate, it THROWS. Measured 11 cells at
+        // every W ≤ 10. Below the width where the tail and one word of
+        // content can both stand, the row is the CONTENT: a cell that
+        // cannot hold the key's name has nothing to say about the key.
+        const tail = "/think";
+        const room = W - 2 - tail.length - 1;
+        // the belt: cutLine is SGR-aware and single-row, so the invariant
+        // holds by CONSTRUCTION at every width rather than by arithmetic
+        // that has to be re-proved every time a span moves.
+        if (room < 2)
+            return [cutLine(`${p.dim}⋯ ${p.italic}${wordCut(trimmed, Math.max(1, W - 2))}${p.italicEnd}${p.reset}`, W)];
+        const cut = wordCut(trimmed, room);
+        const body = `⋯ ${p.italic}${cut}${p.italicEnd}`;
+        const pad = Math.max(1, W - 2 - visibleWidth(cut) - tail.length);
+        return [cutLine(`${p.dim}${body}${" ".repeat(pad)}${tail}${p.reset}`, W)];
     }
 }
+/** R2 — cut at a word boundary, with the honest ellipsis. widthCut cuts
+ *  at a cell, which is right for verbatim output and wrong for prose:
+ *  the reader has to reassemble "h" into "home". Falls back to the cell
+ *  cut when the first word alone overruns, because a row that cannot
+ *  hold one word has no boundary to find. */
+function wordCut(text, room) {
+    if (visibleWidth(text) <= room)
+        return text;
+    const hard = widthCut(text, Math.max(1, room - 1));
+    const at = hard.lastIndexOf(" ");
+    return `${at > room / 3 ? hard.slice(0, at) : hard}\u2026`;
+}
 /** Fold a line's CONTENT at W−2 and prefix EVERY row with the gutter
  *  (W2: a wrapped tool row keeps its state mark — the left edge alone
  *  distinguishes the states at --plain; the UserMessage rail precedent,
@@ -498,7 +558,7 @@ class ToolExecution {
             // list of calls, not a body of output.
             const r = c.rolled;
             const counts = exploreCounts(parts);
-            const head = `${p.bold}✓${p.reset} explored ${p.bold}${counts}${p.reset}`;
+            const head = `  explored ${p.bold}${counts}${p.reset}`; // R2: no tick
             const tail = ` (${r.elapsed}s)`;
             const room = W - visibleWidth(head) - tail.length;
             const affordance = " · ctrl+r lists them";
@@ -513,7 +573,7 @@ class ToolExecution {
             // W15 expand history — the head's commit captures it).
             const r = c.rolled;
             const noun = ROLLUP_NOUN[c.name] ?? "calls";
-            const out = gutterCut(`${p.bold}✓${p.reset} `, `${verbCol} ${r.count} ${noun} (${kUnit(r.lines)} lines, ${r.elapsed}s)`, W);
+            const out = gutterCut("  ", `${verbCol} ${r.count} ${noun} (${kUnit(r.lines)} lines, ${r.elapsed}s)`, W); // R2: no tick
             const shown = r.targets.slice(0, 3);
             if (shown.length > 0)
                 out.push(`  ${p.dim}${CUT_ROW}${escapeTerminal(shown.join(" · "))}${p.reset}`);
@@ -531,7 +591,7 @@ class ToolExecution {
             // names the decider; a human denial (no decidedBy) has no tail.
             if (c.reason !== null) {
                 const by = attribution(c);
-                const out = gutterCut(`${p.red}✗${p.reset} `, `${p.red}${escapeTerminal(`${c.name} ${toolTargetOf(c)}`)} (${escapeTerminal(c.reason)}${by})${p.reset}`, W);
+                const out = gutterCut("  ", `${p.red}${escapeTerminal(`${c.name} ${toolTargetOf(c)}`)} (${escapeTerminal(c.reason)}${by})${p.reset}`, W);
                 out.push(...toolBlockBody(c, W));
                 return out;
             }
@@ -568,7 +628,14 @@ class ToolExecution {
             // the semantics. TUI2-R1.5 pin 4: and the parts give way in a
             // PINNED ORDER, rather than whichever happened to be last.
             const text = settledHeadText(verbCol, escapeTerminal(toolTargetOf(c)), meta, approvedBy, elapsed, W - 2 - (hidden === null ? 0 : SUFFIX_MIN));
-            const out = c.isError ? [`${p.red}✗${p.reset} ${p.red}${text}${p.reset}`] : [`${p.bold}✓${p.reset} ${text}`];
+            // R2 (owner, 2026-08-27): no tick, no cross. A symbol earns its
+            // cell by carrying a fact the words do not, and a row that
+            // already says `exit 0` does not need one more thing saying it
+            // went fine. The gutter is two spaces; the OUTCOME lives in the
+            // metadata, in words, which is also the only form that survives
+            // a pipe with the colour stripped. A failure keeps its colour
+            // AND its words — see settledMeta.
+            const out = c.isError ? [`  ${p.red}${text}${p.reset}`] : [`  ${text}`];
             out[0] = appendSuffix(out[0], expandSuffix(hidden, W - visibleWidth(out[0])));
             out.push(...toolBlockBody(c, W));
             return out;
@@ -758,7 +825,7 @@ function appendSuffix(row, suffix) {
  * would put the invariant "exactly one bright token" in as many hands as
  * there are emitters. Here it has exactly one.
  *
- * NO_COLOR: p.code is empty, so the row's bytes are untouched.
+ * NO_COLOR: p.dim is empty, so the row's bytes are untouched.
  */
 export function focusToken(row, W) {
     const p = palette();
@@ -766,9 +833,17 @@ export function focusToken(row, W) {
     if (at !== -1) {
         // the row already names the key — brighten the token in place, and
         // leave every other span exactly as it was
-        if (p.code === "")
+        if (p.dim === "")
             return row;
-        return `${row.slice(0, at)}${p.code}${CTRL_R}${p.reset}${p.dim}${row.slice(at + CTRL_R.length)}`;
+        // DC-3: the marker takes the WASH. It used to take the inline-code
+        // tint and inherited its 1.54:1 — the cue naming the key that
+        // reveals a cell was itself the least readable thing on a white
+        // terminal. The wash is right for a second reason: this token has
+        // to be UNIQUE on the frame ("exactly one bright token"), and an
+        // attribute like bold is spent everywhere. It closes with washEnd
+        // rather than a reset, so the surrounding dim survives instead of
+        // having to be re-applied.
+        return `${row.slice(0, at)}${p.wash}${CTRL_R}${p.washEnd}${row.slice(at + CTRL_R.length)}`;
     }
     // A LIVE row does not carry the affordance today, and the live cell is
     // the one ctrl+r takes FIRST (expandNext scans the live tail before
@@ -780,7 +855,7 @@ export function focusToken(row, W) {
     const room = W - visibleWidth(row);
     if (room < SUFFIX_MIN)
         return row; // never at the cost of invariant ①
-    return `${row}${p.dim} · ${p.reset}${p.code}${CTRL_R}${p.reset}`;
+    return `${row}${p.dim} · ${p.reset}${p.wash}${CTRL_R}${p.washEnd}`;
 }
 const CTRL_R = "ctrl+r";
 /** TUI2-R1 (A) — the expanded block's last row: the way back. The
@@ -894,26 +969,26 @@ export function turnFold(t, W) {
     const meta = parts.join(" · ");
     const words = escapeTerminal(t.words);
     if (words === "") {
-        const row = `${p.bold}▞${p.reset} ${meta}`;
-        return visibleWidth(row) <= W ? [row] : [`${p.bold}▞${p.reset} ${widthCut(meta, Math.max(1, W - 3))}…`]; // a wordless turn folds to the W14 shape
+        const row = `${p.bold}✦${p.reset} ${meta}`;
+        return visibleWidth(row) <= W ? [row] : [`${p.bold}✦${p.reset} ${widthCut(meta, Math.max(1, W - 3))}…`]; // a wordless turn folds to the W14 shape
     }
     // A9 (ruling R2, mock A): the user chip rides the fold — the human's
     // words LEAD the one line, the same SGR-7 bracket as the live user
     // row (#16f, side pads included). The words take the fold's width
-    // budget: W − the gutter ("▞ " = 2) − the join (" · " = 3) − the
+    // budget: W − the gutter ("✦ " = 2) − the join (" · " = 3) − the
     // chip's side pads (2) − the cut-tail reserve (1, the "…") − the
     // metadata's own width — the metadata survives, the words width-cut
     // at the end with the honest "…" (the "…" alone is the honest floor:
     // the words were there, cut).
-    const budget = Math.max(0, W - visibleWidth(`▞ ${meta}`) - 6);
+    const budget = Math.max(0, W - visibleWidth(`✦ ${meta}`) - 6);
     const cut = visibleWidth(words) > budget ? `${widthCut(words, budget)}…` : words;
-    const row = `${p.bold}▞${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${meta}`;
+    const row = `${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${meta}`;
     if (visibleWidth(row) <= W)
         return [row];
     // the last resort: the METADATA gives way — the words hold their
     // budget, the meta cuts with the honest "…"; invariant ① never trips
     // at ANY width (a degenerate W's fold is a cut, never a crash).
-    return [`${p.bold}▞${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(meta, Math.max(1, W - 8 - visibleWidth(cut)))}…`];
+    return [`${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(meta, Math.max(1, W - 8 - visibleWidth(cut)))}…`];
 }
 // ---- the bounded-block flow contract (W7, W8, W10) ----
 /** The caps — screen rows counted AFTER the fold, at the current width
@@ -1270,8 +1345,11 @@ class Banner {
     }
     render(W, ctx) {
         const p = palette();
-        const rows = bannerLines(W, ctx.height, this.cell.version, this.cell.extensionsText, this.cell.resume, ctx.now);
-        return rows.map((r) => `${p.dim}${r}${p.reset}`);
+        // R2: NO blanket dim. bannerLines styles itself — the labels are
+        // dim, the values are ink — and wrapping the whole thing in dim
+        // made the answers as faint as the questions.
+        void p;
+        return bannerLines(W, ctx.height, this.cell.version, this.cell.extensionsText, this.cell.resume, ctx.now, this.cell.meta);
     }
 }
 /** W20 — the task block's fixed-window height: the whole live block
@@ -1355,7 +1433,7 @@ class Checklist {
         const fixed = done
             ? `task done · ${plural(items.length, "item")} · ${formatDuration(durationSeconds)}`
             : `task · ${plural(items.length, "item")} · ${active.length} active · ${doneCount} done`;
-        const header = `${p.bold}▞${p.reset} ${escapeTerminal(fixed + tail)}`;
+        const header = `${p.bold}✦${p.reset} ${escapeTerminal(fixed + tail)}`;
         // the FULL-list forms: SETTLED — the durable record (the fold is
         // fine — committed content wraps naturally) — and the LIVE ctrl+r
         // toggle (the header CUTS — the block stays one window high; the
@@ -1457,20 +1535,38 @@ export function widthCut(text, max) {
  */
 export function selectionBar(styled, visible, W) {
     const p = palette();
-    const inner = styled.replaceAll(p.reset, `${p.reset}${p.rv}`);
+    // R2 (design §2.1 — nothing dim ever sits on the wash): the bar IS a
+    // wash. A dim span inside it renders grey-on-grey — 3.91:1 on the
+    // light ground, under the 4.5 floor — and the dim spans are exactly
+    // the descriptions and the metadata, i.e. the half of the row the
+    // selection was supposed to help you read. Dim is dropped INSIDE the
+    // bar and nowhere else; the same row unselected keeps it.
+    const inner = (p.dim === "" ? styled : styled.replaceAll(p.dim, "")).replaceAll(p.reset, `${p.reset}${p.rv}`);
     return `${p.rv} ${inner}${" ".repeat(Math.max(0, W - visible - 2))} ${p.rvEnd}`;
 }
-/** W6 — the box: the chrome's top rail. The two ╌ dotted rows become
- *  a rounded box (the box already says "input lives here"); the rails
- *  stay dim, the width is still the full W (the box is a rail with
- *  corners — the menu/gap rows above and the status below are
- *  untouched). */
+/**
+ * R2 — the composer's rails, and the ONE edge vocabulary.
+ *
+ * W6 turned two \u254c dotted rows into a rounded box, reasoning that
+ * "the box already says input lives here". That is reversed here, and
+ * the reason is not taste: a rule is a DELIMITER and a box is a
+ * CONTAINER, and the screen was carrying six edge vocabularies at once
+ * (this box, the panel's \u2502 gutter and \u2514\u2500\u2500 tail, the
+ * diff gutter, the quote's \u258f, the table's rails, the markdown
+ * rule). One dashed rule replaces the ones that SEPARATE; the \u2502
+ * gutter survives where it SCOPES.
+ *
+ * Row-neutral by construction: CHROME_ROWS is still 4, so every gate
+ * keyed on H \u2212 4 is untouched, and the input row gains the two
+ * columns the walls were taking.
+ */
 export function boxTop(W) {
-    return `\x1b[2m╭${"─".repeat(Math.max(0, W - 2))}╮\x1b[0m`;
+    return `\x1b[2m${"\u254c".repeat(Math.max(0, W))}\x1b[0m`;
 }
-/** W6 — the box: the chrome's bottom rail. */
+/** R2 — the same rule below. Named for its POSITION, not its shape, so
+ *  the compositor's two call sites did not have to move. */
 export function boxBottom(W) {
-    return `\x1b[2m╰${"─".repeat(Math.max(0, W - 2))}╯\x1b[0m`;
+    return `\x1b[2m${"\u254c".repeat(Math.max(0, W))}\x1b[0m`;
 }
 /** The terminal label + rhythm gap (the pipe path's v2c bytes — the
  *  exact render the passthrough needs). */

package/dist/ground.d.ts

@@ -0,0 +1,46 @@
+/**
+ * DC-3 §1 — the GROUND: is the terminal light or dark.
+ *
+ * Every colour in the palette is chosen against a background, and until
+ * now kiso had no way to know what that background was: `palette()`
+ * returned one constant, its greys were picked on a dark terminal, and
+ * on a white one the inline-code token measured 1.54:1 against a 4.5:1
+ * floor (finding DC-3).
+ *
+ * This module is the answer, and it is deliberately PURE. The terminal's
+ * reply arrives as a string and the environment arrives as fields, so
+ * the whole decision is testable without a terminal and the terminal
+ * work is reduced to plumbing.
+ *
+ * `unknown` is a real answer, not a failure. It means the caller must
+ * use the mark that is correct on ANY ground — reverse video rather than
+ * a wash, the terminal's own dim rather than a chosen grey. A design
+ * that degrades is the price of never painting light-mode paint onto a
+ * dark screen.
+ */
+export type Ground = "light" | "dark" | "unknown";
+export interface Rgb {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+}
+export declare function parseOscColor(body: string): Rgb | null;
+/** The WCAG relative luminance — the same formula the contrast ratios in
+ *  `packages/tui/design.md` §2 are computed with, so the ground and the
+ *  floor cannot drift apart. */
+export declare function relativeLuminance({ r, g, b }: Rgb): number;
+export declare function groundFrom(rgb: Rgb): Exclude<Ground, "unknown">;
+export interface GroundInputs {
+    /** KISO_THEME — an explicit answer from the human. */
+    readonly theme?: string | undefined;
+    /** The body of the terminal's OSC 11 answer, if one arrived. */
+    readonly osc?: string | undefined;
+    /** The COLORFGBG environment variable, if it is set. */
+    readonly colorfgbg?: string | undefined;
+}
+/**
+ * The ladder, first hit wins. Every rung that cannot answer falls
+ * through rather than guessing, and the bottom of the ladder is
+ * `unknown` — see the module comment for why that is a result.
+ */
+export declare function resolveGround({ theme, osc, colorfgbg }: GroundInputs): Ground;

package/dist/ground.js

@@ -0,0 +1,76 @@
+/**
+ * DC-3 §1 — the GROUND: is the terminal light or dark.
+ *
+ * Every colour in the palette is chosen against a background, and until
+ * now kiso had no way to know what that background was: `palette()`
+ * returned one constant, its greys were picked on a dark terminal, and
+ * on a white one the inline-code token measured 1.54:1 against a 4.5:1
+ * floor (finding DC-3).
+ *
+ * This module is the answer, and it is deliberately PURE. The terminal's
+ * reply arrives as a string and the environment arrives as fields, so
+ * the whole decision is testable without a terminal and the terminal
+ * work is reduced to plumbing.
+ *
+ * `unknown` is a real answer, not a failure. It means the caller must
+ * use the mark that is correct on ANY ground — reverse video rather than
+ * a wash, the terminal's own dim rather than a chosen grey. A design
+ * that degrades is the price of never painting light-mode paint onto a
+ * dark screen.
+ */
+/** `<n>;rgb:R/G/B` with 1–4 hex digits per component — the body of an
+ *  OSC 10/11 answer, already stripped of its introducer and terminator
+ *  by the editor (DC-7). Anything else is null: a guess about the
+ *  ground is worse than admitting there isn't one. */
+const OSC_RGB = /^\d+;rgb:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})$/i;
+export function parseOscColor(body) {
+    const m = OSC_RGB.exec(body.trim());
+    if (m === null)
+        return null;
+    // a component is n hex digits of a full-scale value, so it scales by
+    // its own maximum — `f` is full white exactly as `ffff` is.
+    const comp = (h) => Math.round((Number.parseInt(h, 16) / (16 ** h.length - 1)) * 255);
+    return { r: comp(m[1]), g: comp(m[2]), b: comp(m[3]) };
+}
+/** The WCAG relative luminance — the same formula the contrast ratios in
+ *  `packages/tui/design.md` §2 are computed with, so the ground and the
+ *  floor cannot drift apart. */
+export function relativeLuminance({ r, g, b }) {
+    const lin = (v) => {
+        const c = v / 255;
+        return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+export function groundFrom(rgb) {
+    return relativeLuminance(rgb) > 0.5 ? "light" : "dark";
+}
+/** COLORFGBG is `fg;bg` or `fg;default;bg` — the BACKGROUND is the last
+ *  field, as an ANSI index. 0–6 and 8 are the dark half of the sixteen;
+ *  7 and 9–15 are the light half. Absent on most terminals, which is why
+ *  it sits below the question kiso can actually ask. */
+function fromColorFgBg(value) {
+    const fields = value.split(";");
+    const bg = Number.parseInt(fields[fields.length - 1] ?? "", 10);
+    if (!Number.isInteger(bg) || bg < 0 || bg > 15)
+        return "unknown";
+    return bg === 7 || bg >= 9 ? "light" : "dark";
+}
+/**
+ * The ladder, first hit wins. Every rung that cannot answer falls
+ * through rather than guessing, and the bottom of the ladder is
+ * `unknown` — see the module comment for why that is a result.
+ */
+export function resolveGround({ theme, osc, colorfgbg }) {
+    const explicit = theme?.trim().toLowerCase();
+    if (explicit === "light" || explicit === "dark")
+        return explicit;
+    if (osc !== undefined && osc !== "") {
+        const rgb = parseOscColor(osc);
+        if (rgb !== null)
+            return groundFrom(rgb);
+    }
+    if (colorfgbg !== undefined && colorfgbg !== "")
+        return fromColorFgBg(colorfgbg);
+    return "unknown";
+}

package/dist/index.d.ts

@@ -14,4 +14,7 @@ export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWi
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, type TrustArtifact, } from "./strings.js";
 export { extensionsBannerText, helpRows, unansweredAskView, type BannerExtension } from "./strings.js";
 export { displayVerb } from "./strings.js";
-export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_ON, currentGround, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";
+/** DC-3 — the ground: is the terminal light or dark. Pure; see the
+ *  module comment for why `unknown` is a result and not a failure. */
+export { groundFrom, parseOscColor, relativeLuminance, resolveGround, type Ground, type GroundInputs, type Rgb } from "./ground.js";

package/dist/index.js

@@ -28,4 +28,7 @@ export { extensionsBannerText, helpRows, unansweredAskView } from "./strings.js"
 // TUI2-R2pre ④: the ONE display-verb table — the screen names the act,
 // the tool table names the call.
 export { displayVerb } from "./strings.js";
-export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_ON, currentGround, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";
+/** DC-3 — the ground: is the terminal light or dark. Pure; see the
+ *  module comment for why `unknown` is a result and not a failure. */
+export { groundFrom, parseOscColor, relativeLuminance, resolveGround } from "./ground.js";

package/dist/md.d.ts

@@ -38,7 +38,7 @@
  */
 /** 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";
+export type MdKind = "para" | "heading" | "list" | "table" | "quote" | "rule" | "fence-open" | "fence-line" | "fence-close";
 /** 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. */