@vincemakes/kiso-tui-cells 0.47.0 → 0.47.1

package/dist/components.js

@@ -726,8 +726,17 @@ class ToolExecution {
                 // and answered); a policy's is ambient. The outcome word says
                 // which, once.
                 const word = c.verdict !== null && c.verdict.decision === "denied" && c.verdict.decidedBy === undefined ? "denied by you" : "denied";
-                const outcome = [`${word} \u00b7 ${escapeTerminal(c.reason)}`, word];
-                const body = toolBlockParts(c, W, ctx);
+                // 0.47.1 (finding 0470-F4, owner 2026-10-07): said once. The
+                // runtime's reason when the person gave none is the words
+                // "denied by user" — `denied by you · denied by user` said the
+                // refusal twice on one row, and the body (`[Permission denied]
+                // denied by user`, what the model was handed) a third time. So
+                // that refusal is `denied by you` alone, with no body. A refusal
+                // WITH a reason keeps both: the head gives its reason way on a
+                // narrow row (the pinned order), and the body still says it.
+                const quiet = word === "denied by you" && c.reason === DEFAULT_REFUSAL;
+                const outcome = quiet ? [word] : [`${word} \u00b7 ${escapeTerminal(c.reason)}`, word];
+                const body = quiet && c.resultText.trim() === `[Permission denied] ${c.reason}` ? { rows: [] } : toolBlockParts(c, W, ctx);
                 return card("fail", "  ", verb, escapeTerminal(toolTargetOf(c)), outcome, body.rows, null, W, true, fold);
             }
             // 4c: a card settled from the durable log carries no clock at
@@ -1324,9 +1333,12 @@ function toolBlockParts(c, W, ctx) {
         // A shell's conclusion is at the bottom, so its note goes ABOVE the
         // tail; everything else answers at the top, so its note closes it.
         // The card round: a settled, collapsed card's key rides the note.
-        return dir === "tail"
-            ? [...cutNote(all.length - CAP_PREVIEW, "earlier", W, tone, keyed), ...tailWindow(all, CAP_PREVIEW, starts)]
-            : [...all.slice(0, CAP_PREVIEW), ...cutNote(all.length - CAP_PREVIEW, "more", W, tone, keyed)];
+        if (dir === "tail") {
+            const w = tailWindow(all, CAP_PREVIEW, starts);
+            return [...cutNote(w.lines, "earlier", W, tone, keyed, w.partial), ...w.rows];
+        }
+        const h = headCut(all, CAP_PREVIEW, starts);
+        return [...h.rows, ...cutNote(h.lines, "more", W, tone, keyed, h.partial)];
     };
     const shellTail = (out, dir) => capped(out.rows, dir, out.starts);
     // a diff inside a card: its own rows, the head of them until the key
@@ -1466,17 +1478,44 @@ function blockLines(text, W, tone = "dim") {
  *  REVERSAL of §7.4's foot for a collapsed card — the note and the key
  *  were two rows for one fact. The key gives way after the count's word,
  *  the count never. */
-function cutNote(cut, word, W, tone, key = false) {
-    const n = `${cut} ${word} line${cut === 1 ? "" : "s"}`;
+function cutNote(cut, word, W, tone, key = false, partial = false) {
+    // 0.47.1 (finding 0470-F1, owner 2026-10-07): `cut` counts output
+    // LINES, the unit the note names (it counted rows: a wrapped line hidden
+    // whole was two or more "lines"). `partial`: the line at the cut is
+    // shown only in part — its start above a tail, its rest below a head —
+    // and the note says so rather than counting it.
+    const part = word === "earlier" ? "start" : "rest";
+    const lines = `${cut} ${word} line${cut === 1 ? "" : "s"}`;
+    const n = !partial ? lines : cut === 0 ? `the ${part} of this line` : `${lines} and the ${part} of this one`;
+    const short = !partial ? `\u2026 ${cut}` : cut === 0 ? "\u2026" : `\u2026 ${cut}+`;
+    // the part's clause gives way before the count's word does
+    const tiers = partial && cut > 0 ? [`\u2026 ${n}`, `\u2026 ${lines}`, short] : [`\u2026 ${n}`, short];
     const room = bodyTextWidth(W);
     if (key) {
-        for (const [left, k] of [[`\u2026 ${n}`, EXPAND_ROW], [`\u2026 ${cut}`, EXPAND_ROW], [`\u2026 ${cut}`, "ctrl+o"]]) {
+        for (const [left, k] of [...tiers.map((l) => [l, EXPAND_ROW]), [short, "ctrl+o"]]) {
             const gap = room - visibleWidth(left) - visibleWidth(k);
             if (gap >= 2)
                 return noteRow(`${left}${" ".repeat(gap)}${k}`, W, tone);
         }
     }
-    return noteRow(pickTier([`\u2026 ${n}`, `\u2026 ${cut}`], room), W, tone);
+    return noteRow(pickTier(tiers, room), W, tone);
+}
+/** What a cut window hides, for its note (0.47.1, finding 0470-F1): the
+ *  output lines among the hidden rows, and whether the line at the cut is
+ *  shown in part. `starts` marks each row that begins a line; where it is
+ *  unknown (empty) every row counts as a line, as before. A tail that opens
+ *  on a continuation row shows the end of a line whose start is hidden —
+ *  that line is not counted, it is the note's `partial`. */
+function tailCount(shown, hidden, starts, first) {
+    const partial = starts[first] === false;
+    return { rows: shown, lines: hidden.filter((i) => starts[i] !== false).length - (partial ? 1 : 0), partial };
+}
+function headCut(rows, cap, starts) {
+    let lines = 0;
+    for (let i = cap; i < rows.length; i += 1)
+        if (starts[i] !== false)
+            lines += 1;
+    return { rows: rows.slice(0, cap), lines, partial: starts[cap] === false };
 }
 /** The card round — a shell's tail never opens on a blank row or in the
  *  middle of a wrapped line, and keeps its height (DC-46: a live window
@@ -1489,10 +1528,13 @@ function cutNote(cut, word, W, tone, key = false) {
  *  the plain tail. The rows it hides are counted in the note. `starts`
  *  marks each row that begins a line of output. */
 const TAIL_REACH = 12;
+/** The runtime's reason for a refusal the person gave no words for
+ *  (session.approve(id, false)) — a card says `denied by you` alone then. */
+const DEFAULT_REFUSAL = "denied by user";
 function tailWindow(rows, cap, starts) {
     const n = rows.length;
     if (n <= cap)
-        return [...rows];
+        return { rows: [...rows], lines: 0, partial: false };
     const blank = (i) => visibleWidth(rows[i]) <= visibleWidth(bodyRow());
     let blanks = 0;
     for (let i = n - cap; i < n; i += 1)
@@ -1507,16 +1549,19 @@ function tailWindow(rows, cap, starts) {
         if (blank(s) || starts[s] === false || blanks < extra)
             continue;
         const out = [];
+        const hidden = Array.from({ length: s }, (_, i) => i);
         let dropped = 0;
         for (let i = s; i < n; i += 1) {
-            if (dropped < extra && blank(i))
+            if (dropped < extra && blank(i)) {
                 dropped += 1;
+                hidden.push(i);
+            }
             else
                 out.push(rows[i]);
         }
-        return out;
+        return tailCount(out, hidden, starts, s);
     }
-    return rows.slice(n - cap);
+    return tailCount(rows.slice(n - cap), Array.from({ length: n - cap }, (_, i) => i), starts, n - cap);
 }
 /** The error text, uncapped: the answer is at the start, and the whole
  *  of it is the body — the head row carries only the outcome word
@@ -1571,9 +1616,12 @@ function liveWindow(c, W, cap, tone) {
     const rows = all.slice(from);
     if (rows.length <= cap)
         return rows;
-    return c.name === "shell"
-        ? [...cutNote(rows.length - cap, "earlier", W, tone), ...tailWindow(rows, cap, starts.slice(from))]
-        : [...rows.slice(0, cap), ...cutNote(rows.length - cap, "more", W, tone)];
+    if (c.name === "shell") {
+        const w = tailWindow(rows, cap, starts.slice(from));
+        return [...cutNote(w.lines, "earlier", W, tone, false, w.partial), ...w.rows];
+    }
+    const h = headCut(rows, cap, starts.slice(from));
+    return [...h.rows, ...cutNote(h.lines, "more", W, tone, false, h.partial)];
 }
 /** DC-46 — the window's HIGH-WATER, per cell: the room a frame leaves
  *  caps how far a window may GROW, and never shrinks one that already

package/dist/graphite.d.ts

@@ -39,25 +39,25 @@ export declare const GRAPHITE: {
     readonly dark: {
         readonly ground: "#0b0b0b";
         readonly ink: "#ededed";
-        readonly ink2: "#b5b5b5";
-        readonly dim: "#8e8e8e";
+        readonly ink2: "#c2c2c2";
+        readonly dim: "#a4a4a4";
         readonly rail: "#6b6b6b";
-        readonly line: "#212121";
-        readonly washRun: "#141b28";
-        readonly washDone: "#1b1b1b";
-        readonly washFail: "#2a1716";
-        readonly washAsk: "#211d13";
-        readonly human: "#efe6cf";
+        readonly line: "#656565";
+        readonly washRun: "#2b3854";
+        readonly washDone: "#333333";
+        readonly washFail: "#4d2b28";
+        readonly washAsk: "#483818";
+        readonly human: "#e8dfc6";
         readonly humanInk: "#141620";
         readonly gold: "#e3b04b";
         readonly goldMark: "#e3b04b";
         readonly blue: "#82a8f5";
-        readonly code: "#1a2438";
+        readonly code: "#283658";
         readonly ok: "#8fd19e";
         readonly fail: "#f2877a";
-        readonly add: "#16301f";
-        readonly del: "#3a1b1a";
-        readonly track: "#2a2a2a";
+        readonly add: "#2a5034";
+        readonly del: "#5e302d";
+        readonly track: "#474747";
     };
 };
 export type Token = Exclude<keyof (typeof GRAPHITE)["light"], "ground">;
@@ -84,11 +84,21 @@ export declare function contrast(a: Rgb, b: Rgb): number;
 /** `t` of the way from `a` to `b`, per channel. */
 export declare function mix(a: Rgb, b: Rgb, t: number): Rgb;
 /**
- * §3.4 — one surface for any ground. Per channel an affine map
- * `s = a + k·g`, fitted so that the white reference ground gives the
- * table's white value and the black one its black value: the two
- * grounds reproduce the table exactly, and a terminal whose black is
- * `#1e1e1e` gets a card that sits the same distance off ITS ground.
+ * §3.4 — one surface for any ground. A DARK ground: per channel an affine
+ * map `s = a + k·g`, fitted so that the white reference ground gives the
+ * table's white value and the black one its black value — a terminal
+ * whose black is `#1e1e1e` gets a card that sits the same distance off
+ * ITS ground, and the distance narrows as a dark ground lightens, which
+ * keeps the text above the floor on the lighter dark themes. A LIGHT
+ * ground: the light table, moved by how far the ground sits from white.
+ * The two reference grounds reproduce the table exactly.
+ *
+ * 0.47.1 (the dark table's re-adaptation): DECLARED REVERSAL for the
+ * light grounds only. The one map through both tables tied them to the
+ * dark table — lifting the dark cards pulled a card on `#eeeeee` to within
+ * 1.09:1 of its ground. A light ground now answers to the light table
+ * alone; on the light grounds measured the cards move by a channel step
+ * or two at most.
  */
 export declare function deriveSurface(token: Token, ground: Rgb): Rgb;
 /** A colour as the terminal will show it: itself in the 24-bit tier, the
@@ -118,6 +128,16 @@ export declare function nearest256(c: Rgb): number;
  *  standard statement; anything else gets the 256 tier, which every
  *  terminal kiso docks in renders. */
 export declare function colourTier(colorterm: string | undefined): Tier;
+/** 0.47.1 (owner, 2026-10-07) — 24-bit where the terminal is KNOWN to
+ *  render it, though it does not say so in COLORTERM. Windows Terminal is
+ *  the case that found it: drawn in the 256 tier, the person's cream block
+ *  became pink (index 224) and its gold edge olive (186). Each terminal is
+ *  recognised by what it sets; the list is the reference implementation's.
+ *  Inside tmux or screen only COLORTERM counts — the outer terminal's
+ *  variables are inherited, its rendering is not. Apple Terminal says it
+ *  in COLORTERM where it renders 24-bit (§2), and keeps the 256 tier
+ *  otherwise. PURE: the environment and the platform are passed in. */
+export declare function terminalTier(env: Readonly<Record<string, string | undefined>>, platform: string): Tier;
 export declare function fg(c: Rgb, tier: Tier): string;
 export declare function bg(c: Rgb, tier: Tier): string;
 export {};

package/dist/graphite.js

@@ -32,28 +32,37 @@ export const GRAPHITE = {
         del: "#fadfdc",
         track: "#e2e2e2",
     },
+    // 0.47.1 — the dark table re-adapted (owner, 2026-10-07: preset D on
+    // the dark palette page): the surfaces were a few levels above the
+    // ground and read as heavy on a black terminal; they rise a step, and
+    // dim and ink2 rise with them to keep the floor. washAsk and code sit
+    // just under D's values (#524222, #30406a) so every pair of
+    // TEXT_PAIRS still clears 4.5, in the 256 tier too.
     dark: {
         ground: "#0b0b0b",
         ink: "#ededed",
-        ink2: "#b5b5b5",
-        dim: "#8e8e8e",
+        ink2: "#c2c2c2",
+        dim: "#a4a4a4",
         rail: "#6b6b6b",
-        line: "#212121",
-        washRun: "#141b28",
-        washDone: "#1b1b1b",
-        washFail: "#2a1716",
-        washAsk: "#211d13",
-        human: "#efe6cf",
+        // the owner, 2026-10-08: the composer's rules read too grey on Apple
+        // Terminal's Pro profile (its transparency lightens the black) — the
+        // hairlines rise to #656565
+        line: "#656565",
+        washRun: "#2b3854",
+        washDone: "#333333",
+        washFail: "#4d2b28",
+        washAsk: "#483818",
+        human: "#e8dfc6",
         humanInk: "#141620",
         gold: "#e3b04b",
         goldMark: "#e3b04b",
         blue: "#82a8f5",
-        code: "#1a2438",
+        code: "#283658",
         ok: "#8fd19e",
         fail: "#f2877a",
-        add: "#16301f",
-        del: "#3a1b1a",
-        track: "#2a2a2a",
+        add: "#2a5034",
+        del: "#5e302d",
+        track: "#474747",
     },
 };
 /** The tokens that are GROUNDS near the terminal's own (§3.4): each is
@@ -94,13 +103,28 @@ export function mix(a, b, t) {
 const REF_LIGHT = hexRgb(GRAPHITE.light.ground);
 const REF_DARK = hexRgb(GRAPHITE.dark.ground);
 /**
- * §3.4 — one surface for any ground. Per channel an affine map
- * `s = a + k·g`, fitted so that the white reference ground gives the
- * table's white value and the black one its black value: the two
- * grounds reproduce the table exactly, and a terminal whose black is
- * `#1e1e1e` gets a card that sits the same distance off ITS ground.
+ * §3.4 — one surface for any ground. A DARK ground: per channel an affine
+ * map `s = a + k·g`, fitted so that the white reference ground gives the
+ * table's white value and the black one its black value — a terminal
+ * whose black is `#1e1e1e` gets a card that sits the same distance off
+ * ITS ground, and the distance narrows as a dark ground lightens, which
+ * keeps the text above the floor on the lighter dark themes. A LIGHT
+ * ground: the light table, moved by how far the ground sits from white.
+ * The two reference grounds reproduce the table exactly.
+ *
+ * 0.47.1 (the dark table's re-adaptation): DECLARED REVERSAL for the
+ * light grounds only. The one map through both tables tied them to the
+ * dark table — lifting the dark cards pulled a card on `#eeeeee` to within
+ * 1.09:1 of its ground. A light ground now answers to the light table
+ * alone; on the light grounds measured the cards move by a channel step
+ * or two at most.
  */
 export function deriveSurface(token, ground) {
+    if (groundFrom(ground) === "light") {
+        const s = hexRgb(GRAPHITE.light[token]);
+        const shift = (sc, rc, g) => Math.max(0, Math.min(255, Math.round(sc + (g - rc))));
+        return { r: shift(s.r, REF_LIGHT.r, ground.r), g: shift(s.g, REF_LIGHT.g, ground.g), b: shift(s.b, REF_LIGHT.b, ground.b) };
+    }
     const w = hexRgb(GRAPHITE.light[token]);
     const d = hexRgb(GRAPHITE.dark[token]);
     const chan = (wc, dc, lw, ld, g) => {
@@ -249,6 +273,36 @@ export function colourTier(colorterm) {
     const v = colorterm?.trim().toLowerCase();
     return v === "truecolor" || v === "24bit" ? "24bit" : "256";
 }
+/** 0.47.1 (owner, 2026-10-07) — 24-bit where the terminal is KNOWN to
+ *  render it, though it does not say so in COLORTERM. Windows Terminal is
+ *  the case that found it: drawn in the 256 tier, the person's cream block
+ *  became pink (index 224) and its gold edge olive (186). Each terminal is
+ *  recognised by what it sets; the list is the reference implementation's.
+ *  Inside tmux or screen only COLORTERM counts — the outer terminal's
+ *  variables are inherited, its rendering is not. Apple Terminal says it
+ *  in COLORTERM where it renders 24-bit (§2), and keeps the 256 tier
+ *  otherwise. PURE: the environment and the platform are passed in. */
+export function terminalTier(env, platform) {
+    if (colourTier(env.COLORTERM) === "24bit")
+        return "24bit";
+    const term = (env.TERM ?? "").toLowerCase();
+    if (env.TMUX !== undefined || term.startsWith("tmux") || term.startsWith("screen"))
+        return "256";
+    const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+    const known = env.WT_SESSION !== undefined ||
+        env.ITERM_SESSION_ID !== undefined ||
+        env.WEZTERM_PANE !== undefined ||
+        env.KITTY_WINDOW_ID !== undefined ||
+        env.GHOSTTY_RESOURCES_DIR !== undefined ||
+        ["iterm.app", "wezterm", "ghostty", "kitty", "vscode", "warpterminal", "alacritty"].includes(program) ||
+        term.includes("ghostty") ||
+        term === "alacritty" ||
+        (env.TERMINAL_EMULATOR ?? "").toLowerCase() === "jetbrains-jediterm" ||
+        // a Windows console renders 24-bit even where Windows Terminal hosts
+        // it without WT_SESSION (cmd.exe from Win+R)
+        platform === "win32";
+    return known ? "24bit" : "256";
+}
 export function fg(c, tier) {
     return tier === "24bit" ? `\x1b[38;2;${c.r};${c.g};${c.b}m` : `\x1b[38;5;${nearest256(c)}m`;
 }

package/dist/index.d.ts

@@ -20,4 +20,4 @@ export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_O
 export { groundFrom, parseOscColor, relativeLuminance, resolveGround, type Ground, type GroundInputs, type Rgb } from "./ground.js";
 /** Graphite (design.md §2, §3.4) — the tokens, the tier and the derived
  *  surfaces, as colours. Pure; `render.ts` writes them as SGR. */
-export { GRAPHITE, breathRamp, colourTier, contrast, deriveSurface, graphiteColours, hexRgb, nearest256, rgbHex, weakestPair, type Colours, type Kind, type Tier, type Token } from "./graphite.js";
+export { GRAPHITE, breathRamp, colourTier, terminalTier, contrast, deriveSurface, graphiteColours, hexRgb, nearest256, rgbHex, weakestPair, type Colours, type Kind, type Tier, type Token } from "./graphite.js";

package/dist/index.js

@@ -34,4 +34,4 @@ export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_O
 export { groundFrom, parseOscColor, relativeLuminance, resolveGround } from "./ground.js";
 /** Graphite (design.md §2, §3.4) — the tokens, the tier and the derived
  *  surfaces, as colours. Pure; `render.ts` writes them as SGR. */
-export { GRAPHITE, breathRamp, colourTier, contrast, deriveSurface, graphiteColours, hexRgb, nearest256, rgbHex, weakestPair } from "./graphite.js";
+export { GRAPHITE, breathRamp, colourTier, terminalTier, contrast, deriveSurface, graphiteColours, hexRgb, nearest256, rgbHex, weakestPair } from "./graphite.js";

package/dist/render.js

@@ -6,7 +6,7 @@
  * dependencies (the tui-cells package has none).
  */
 import { charWidth, displayWidth, visibleWidth, widthCut } from "./width.js";
-import { bg, breathRamp, colourTier, fg, graphiteColours, mix } from "./graphite.js";
+import { bg, breathRamp, fg, graphiteColours, mix, terminalTier } from "./graphite.js";
 const BASE = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", warn: "\x1b[33m", italic: "\x1b[3m", italicEnd: "\x1b[23m", underline: "\x1b[4m", underlineEnd: "\x1b[24m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
 /**
  * DC-9 (design §2.3) — the failure colour is theme-resolved.
@@ -217,7 +217,7 @@ export function palette() {
         return COLOR_OFF;
     if (ground === "unknown")
         return COLOR_NEUTRAL;
-    const tier = colourTier(process.env.COLORTERM);
+    const tier = terminalTier(process.env, process.platform);
     const r = groundRgb === null ? -1 : groundRgb.r;
     const g = groundRgb === null ? -1 : groundRgb.g;
     const b = groundRgb === null ? -1 : groundRgb.b;

package/package.json

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