@vincemakes/kiso-tui-cells 0.9.0 → 0.11.0

package/dist/render.d.ts

@@ -34,7 +34,25 @@ export interface Palette {
     readonly dim: string;
     readonly red: string;
     readonly green: string;
+    /** TUI2-R2 ①: the third functional exception, finally spelled. The
+     *  mono-discipline ruling above names "green ✓, yellow warn and red
+     *  error" as the ONLY functional colours; warn had no entry because
+     *  nothing had needed it yet. The uncertain badge needs exactly it —
+     *  a state that is neither success nor failure but a question
+     *  addressed to the human. This is the ruling's own set gaining its
+     *  missing member, not a fourth colour. */
+    readonly warn: string;
     readonly code: string;
+    /** TUI2-MD (MD-1, the owner's circle) — the markdown round's ONE new
+     *  member. `*italic*` needs a rendering, and under the mono discipline
+     *  the answer cannot be a colour: SGR 3 is an ATTRIBUTE, it costs the
+     *  alphabet nothing chromatic, and a terminal without italics simply
+     *  draws the text — a harmless degradation rather than a lie.
+     *  It ships with its own close (23) for the same reason `rv` does: an
+     *  italic span inside a bold heading must be able to end WITHOUT the
+     *  SGR-0 that would strand the heading's own style. */
+    readonly italic: string;
+    readonly italicEnd: string;
     readonly rv: string;
     readonly rvEnd: string;
     readonly reset: string;

package/dist/render.js

@@ -6,8 +6,8 @@
  * dependencies (the tui-cells package has none).
  */
 import { charWidth, displayWidth } from "./width.js";
-export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", code: "\x1b[38;5;252m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
-export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", code: "", rv: "", rvEnd: "", reset: "" };
+export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", warn: "\x1b[33m", code: "\x1b[38;5;252m", italic: "\x1b[3m", italicEnd: "\x1b[23m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
+export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", warn: "", code: "", italic: "", italicEnd: "", rv: "", rvEnd: "", reset: "" };
 export function palette() {
     return process.env.NO_COLOR === undefined && process.stdout.isTTY ? COLOR_ON : COLOR_OFF;
 }

package/dist/strings.d.ts

@@ -111,6 +111,10 @@ export interface KeyBinding {
  * then the completions.
  */
 export declare const KEY_BINDINGS: readonly KeyBinding[];
+/** A tool's name as the SCREEN says it. Display-only: the raw name stays
+ *  on the cell, and dispatch, the mode gate, the policy keys, the /last
+ *  RAW block and every model-facing byte keep reading that. */
+export declare function displayVerb(name: string): string;
 /** The panel keys, which belong to a panel rather than the composer —
  *  one dim line rather than four table rows, because they apply only
  *  while a panel is up. */

package/dist/strings.js

@@ -155,6 +155,40 @@ export const KEY_BINDINGS = [
     { keys: "tab", what: "complete (menu / @)" },
     { keys: "?", what: "this sheet" },
 ];
+/**
+ * TUI2-R2pre ④ — THE display-verb table (the integrator's ruling).
+ *
+ * The screen names the ACT; the tool table names the CALL. Two
+ * audiences, two vocabularies, and only the human's one lives here: the
+ * API names DO NOT change, because the model-request surface is frozen
+ * rent and every byte of it is paid for on every turn. The
+ * rename-the-tools path is REJECTED by ruling.
+ *
+ * One table, for the same reason KEY_BINDINGS above is one table. The
+ * mapping used to exist three and a half times — a `.replace("_file",
+ * "")` in components.ts, another in render.ts, two more in the
+ * compositor, and a private three-tool table for the rollup's expanded
+ * list — and the drift was visible on a single screen: a card head
+ * reading `read` directly above one reading `list_dir`.
+ *
+ * An unmapped tool (an extension's, an MCP server's) renders its own
+ * name. Inventing a verb for a tool this package has never heard of
+ * would be a worse lie than printing what the model actually calls.
+ */
+const DISPLAY_VERB = {
+    read_file: "read",
+    list_dir: "list",
+    search_text: "search",
+    write_file: "write",
+    edit_file: "edit",
+    shell: "shell",
+};
+/** A tool's name as the SCREEN says it. Display-only: the raw name stays
+ *  on the cell, and dispatch, the mode gate, the policy keys, the /last
+ *  RAW block and every model-facing byte keep reading that. */
+export function displayVerb(name) {
+    return DISPLAY_VERB[name] ?? name;
+}
 /** The panel keys, which belong to a panel rather than the composer —
  *  one dim line rather than four table rows, because they apply only
  *  while a panel is up. */

package/dist/width.d.ts

@@ -1,18 +1,42 @@
 /**
  * The display-width primitives — the SINGLE width authority (TUI v5
- * #16e: "charWidth is the width authority"). The eastAsianWidth table
- * is a ~40-line subset (CJK ideographs/kana/hangul/fullwidth/common
- * wide symbols = 2, everything else = 1 — the box-drawing/brick glyphs
- * █▀▄▞▸ are narrow). Known limitation, documented in the README: emoji
- * ZWJ clusters are not guaranteed perfect — each code point counts as
- * its width. Zero dependencies (importable from any module).
+ * #16e: "charWidth is the width authority"). The table covers the East
+ * Asian Wide/Fullwidth ranges and Emoji_Presentation=Yes; everything
+ * else is one column, the box-drawing/brick glyphs █▀▄▞▸ and the text-
+ * presentation marks ✓ ✗ ⚠ ⏸ included.
+ *
+ * This is the compositor's FLOOR, not a cosmetic detail: a glyph scored
+ * one column that a terminal draws in two makes a line whose measured
+ * width is <= W really need W+1, the terminal soft-wraps the tail onto
+ * the row below, and the live region silently eats a row it never
+ * budgeted (TUI2-R2pre ① — the composer clobber).
+ *
+ * Known limitation, documented in the README: emoji ZWJ clusters and
+ * variation-selector sequences are not guaranteed perfect — each code
+ * point counts as its own width (U+26A0 + FE0F sums to 2, which is what
+ * a terminal draws, but that is arithmetic luck, not a model).
+ * Zero dependencies (importable from any module).
  */
 /** A code point's display width: 2 for the wide ranges, 1 otherwise. */
 export declare function charWidth(cp: number): number;
+/** TUI2-MD ③ — may a row break immediately before/after this code
+ *  point? True for the CJK scripts (they break between any two
+ *  characters), false for everything else INCLUDING the wide
+ *  pictographs. The wrapper asks this; the width table answers it. */
+export declare function breakable(cp: number): boolean;
 /** Display width of a code-point array (cursor math, scrolling). */
 export declare function widthOf(chars: readonly number[]): number;
 /** Display width of a string. */
 export declare function displayWidth(text: string): number;
+/** The visible width of a RENDERED line — the same table, asked with
+ *  the SGR/CSI sequences skipped. The compositor's invariant ① measures
+ *  with this, so every producer of a screen row must measure with it
+ *  too. TUI2-MD ⑤: moved here verbatim from components.ts, where it had
+ *  lived since the extraction. The markdown renderer needs it and
+ *  components.ts needs the markdown renderer — and a width question
+ *  belongs to the width authority anyway. components.ts re-exports it,
+ *  so every existing importer and the barrel are untouched. */
+export declare function visibleWidth(line: string): number;
 /** A LEAD's display width — the prompt / the panel's phase lead,
  *  ANSI-stripped. W23: the ONE width authority shared by the editor
  *  (selfRender, #reflow), the compositor's #inputRow, and editCol — a

package/dist/width.js

@@ -1,47 +1,141 @@
 /**
  * The display-width primitives — the SINGLE width authority (TUI v5
- * #16e: "charWidth is the width authority"). The eastAsianWidth table
- * is a ~40-line subset (CJK ideographs/kana/hangul/fullwidth/common
- * wide symbols = 2, everything else = 1 — the box-drawing/brick glyphs
- * █▀▄▞▸ are narrow). Known limitation, documented in the README: emoji
- * ZWJ clusters are not guaranteed perfect — each code point counts as
- * its width. Zero dependencies (importable from any module).
+ * #16e: "charWidth is the width authority"). The table covers the East
+ * Asian Wide/Fullwidth ranges and Emoji_Presentation=Yes; everything
+ * else is one column, the box-drawing/brick glyphs █▀▄▞▸ and the text-
+ * presentation marks ✓ ✗ ⚠ ⏸ included.
+ *
+ * This is the compositor's FLOOR, not a cosmetic detail: a glyph scored
+ * one column that a terminal draws in two makes a line whose measured
+ * width is <= W really need W+1, the terminal soft-wraps the tail onto
+ * the row below, and the live region silently eats a row it never
+ * budgeted (TUI2-R2pre ① — the composer clobber).
+ *
+ * Known limitation, documented in the README: emoji ZWJ clusters and
+ * variation-selector sequences are not guaranteed perfect — each code
+ * point counts as its own width (U+26A0 + FE0F sums to 2, which is what
+ * a terminal draws, but that is arithmetic luck, not a model).
+ * Zero dependencies (importable from any module).
  */
-/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
-export function charWidth(cp) {
+/** TUI2-R2pre ① — the Emoji_Presentation=Yes code points inside
+ *  U+2000..U+2BFF. The rest of that span is TEXT presentation and stays
+ *  one column: ✓ ✗ ⚠ ⏸ ▞ ▸ and the box-drawing rails are all narrow, and
+ *  widening any of them would move every card head on the screen. Listed
+ *  as ranges because that is what the property is — the singles are
+ *  singles in Unicode too. */
+const EMOJI_PRESENTATION = [
+    [0x231a, 0x231b],
+    [0x23e9, 0x23ec],
+    [0x23f0, 0x23f0],
+    [0x23f3, 0x23f3],
+    [0x25fd, 0x25fe],
+    [0x2614, 0x2615],
+    [0x2648, 0x2653],
+    [0x267f, 0x267f],
+    [0x2693, 0x2693],
+    [0x26a1, 0x26a1],
+    [0x26aa, 0x26ab],
+    [0x26bd, 0x26be],
+    [0x26c4, 0x26c5],
+    [0x26ce, 0x26ce],
+    [0x26d4, 0x26d4],
+    [0x26ea, 0x26ea],
+    [0x26f2, 0x26f3],
+    [0x26f5, 0x26f5],
+    [0x26fa, 0x26fa],
+    [0x26fd, 0x26fd],
+    [0x2705, 0x2705],
+    [0x270a, 0x270b],
+    [0x2728, 0x2728],
+    [0x274c, 0x274c],
+    [0x274e, 0x274e],
+    [0x2753, 0x2755],
+    [0x2757, 0x2757],
+    [0x2795, 0x2797],
+    [0x27b0, 0x27b0],
+    [0x27bf, 0x27bf],
+    [0x2b1b, 0x2b1c],
+    [0x2b50, 0x2b50],
+    [0x2b55, 0x2b55],
+];
+/** TUI2-MD ③ — the CJK half of the wide table, split out so the SAME
+ *  ranges answer a SECOND question: may a line break here? The width
+ *  authority stays one table; the break class is a view of it, never a
+ *  fork (a second copy would drift, and a drifted width table is the
+ *  composer clobber all over again).
+ *
+ *  These scripts break between any two characters, which is why a
+ *  space-free CJK run must not be treated as one unbreakable word: a
+ *  whitespace-only wrapper cannot place it at all. */
+function cjkWide(cp) {
     if (cp >= 0x1100 && cp <= 0x115f)
-        return 2; // hangul jamo
+        return true; // hangul jamo
     if (cp >= 0x2e80 && cp <= 0x303e)
-        return 2; // radicals .. CJK punctuation
+        return true; // radicals .. CJK punctuation
     if (cp >= 0x3041 && cp <= 0x33ff)
-        return 2; // kana, CJK compat
+        return true; // kana, CJK compat
     if (cp >= 0x3400 && cp <= 0x4dbf)
-        return 2; // CJK ext A
+        return true; // CJK ext A
     if (cp >= 0x4e00 && cp <= 0x9fff)
-        return 2; // CJK unified
+        return true; // CJK unified
     if (cp >= 0xa000 && cp <= 0xa4cf)
-        return 2; // yi
+        return true; // yi
     if (cp >= 0xa960 && cp <= 0xa97f)
-        return 2; // hangul jamo ext
+        return true; // hangul jamo ext
     if (cp >= 0xac00 && cp <= 0xd7a3)
-        return 2; // hangul syllables
+        return true; // hangul syllables
     if (cp >= 0xf900 && cp <= 0xfaff)
-        return 2; // CJK compat ideographs
+        return true; // CJK compat ideographs
     if (cp >= 0xfe10 && cp <= 0xfe19)
-        return 2; // vertical forms
+        return true; // vertical forms
     if (cp >= 0xfe30 && cp <= 0xfe6f)
-        return 2; // CJK compat forms
+        return true; // CJK compat forms
     if (cp >= 0xff00 && cp <= 0xff60)
-        return 2; // fullwidth forms
+        return true; // fullwidth forms
     if (cp >= 0xffe0 && cp <= 0xffe6)
-        return 2; // fullwidth signs
+        return true; // fullwidth signs
+    return cp >= 0x20000 && cp <= 0x3fffd; // CJK ext B..G
+}
+/** The PICTOGRAPHIC half: wide, and deliberately NOT breakable — a
+ *  ZWJ/variation sequence must survive a line break whole. */
+function emojiWide(cp) {
+    // TUI2-R1.5 shipped only two of the pictographic ranges; the holes
+    // (transport, mahjong/cards, enclosed, colored shapes, the extended
+    // block) were scored ONE column while every terminal draws them in
+    // two — the composer clobber of the owner's field report (①).
+    if (cp === 0x1f004 || cp === 0x1f0cf)
+        return true; // mahjong red dragon, joker
+    if (cp >= 0x1f18e && cp <= 0x1f19a)
+        return true; // enclosed alphanumerics
+    if (cp >= 0x1f200 && cp <= 0x1f251)
+        return true; // enclosed ideographic
     if (cp >= 0x1f300 && cp <= 0x1f64f)
-        return 2; // emoji (misc + emoticons)
+        return true; // emoji (misc + emoticons)
+    if (cp >= 0x1f680 && cp <= 0x1f6ff)
+        return true; // transport + map
+    if (cp >= 0x1f7e0 && cp <= 0x1f7eb)
+        return true; // colored circles + squares
     if (cp >= 0x1f900 && cp <= 0x1f9ff)
-        return 2; // supplemental emoji
-    if (cp >= 0x20000 && cp <= 0x3fffd)
-        return 2; // CJK ext B..G
-    return 1;
+        return true; // supplemental emoji
+    if (cp >= 0x1fa70 && cp <= 0x1faff)
+        return true; // symbols + pictographs ext-A
+    if (cp >= 0x231a && cp <= 0x2b55) {
+        for (const [lo, hi] of EMOJI_PRESENTATION)
+            if (cp >= lo && cp <= hi)
+                return true;
+    }
+    return false;
+}
+/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
+export function charWidth(cp) {
+    return cjkWide(cp) || emojiWide(cp) ? 2 : 1;
+}
+/** TUI2-MD ③ — may a row break immediately before/after this code
+ *  point? True for the CJK scripts (they break between any two
+ *  characters), false for everything else INCLUDING the wide
+ *  pictographs. The wrapper asks this; the width table answers it. */
+export function breakable(cp) {
+    return cjkWide(cp);
 }
 /** Display width of a code-point array (cursor math, scrolling). */
 export function widthOf(chars) {
@@ -57,6 +151,31 @@ export function displayWidth(text) {
         w += charWidth(ch.codePointAt(0));
     return w;
 }
+/** The visible width of a RENDERED line — the same table, asked with
+ *  the SGR/CSI sequences skipped. The compositor's invariant ① measures
+ *  with this, so every producer of a screen row must measure with it
+ *  too. TUI2-MD ⑤: moved here verbatim from components.ts, where it had
+ *  lived since the extraction. The markdown renderer needs it and
+ *  components.ts needs the markdown renderer — and a width question
+ *  belongs to the width authority anyway. components.ts re-exports it,
+ *  so every existing importer and the barrel are untouched. */
+export function visibleWidth(line) {
+    let w = 0;
+    for (let i = 0; i < line.length;) {
+        if (line[i] === "\x1b") {
+            const m = /^\x1b\[[0-9;?]*[A-Za-z]/.exec(line.slice(i));
+            if (m !== null) {
+                i += m[0].length;
+                continue;
+            }
+            i += 1;
+            continue;
+        }
+        w += displayWidth(line[i]);
+        i += 1;
+    }
+    return w;
+}
 /** A LEAD's display width — the prompt / the panel's phase lead,
  *  ANSI-stripped. W23: the ONE width authority shared by the editor
  *  (selfRender, #reflow), the compositor's #inputRow, and editCol — a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui-cells",
-  "version": "0.9.0",
+  "version": "0.11.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",