@vincemakes/kiso-tui-cells 0.10.0 → 0.12.0

package/dist/render.d.ts

@@ -43,6 +43,16 @@ export interface Palette {
      *  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", warn: "\x1b[33m", code: "\x1b[38;5;252m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
-export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", warn: "", 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

@@ -1,6 +1,6 @@
 /**
- * tui-cells — the human-facing STRINGS (KC3 slice 1, the ADR-0041
- * escape hatch: extraction, never a raise): the readline prompt, the
+ * tui-cells — the human-facing STRINGS (KC3 slice 1, the escape hatch
+ * of ADR-0043, which supersedes ADR-0041): the readline prompt, the
  * project-trust listing rows and its panel view, the uncertain
  * execution's panel view, and the non-TTY not-trusted note. All five
  * were built inline in the CLI's trust-ui.ts before the move.
@@ -53,10 +53,14 @@ export declare function projectTrustView(root: string, files: readonly TrustArti
  *  stderr by the caller; never silent. */
 export declare function projectUntrustedNote(count: number, root: string): string;
 /** rounds 8/10 — the uncertain execution's panel: the SIMPLE flavor
- *  again, with the options re-labelled in the rule line (1 rerun · 3
- *  abandon). The tool name is escaped for the dock-less fallback
- *  question because it reaches the terminal as raw text there; the
- *  panel's own rows are escaped by the panel renderer. */
+ *  again. TUI2-R3v2 ①: the option labels used to be smuggled into the
+ *  rule line ("— 1 rerun · 3 abandon") because the panel only ever
+ *  rendered "Yes" and "No"; they ride `simpleOptions` now and land on the
+ *  rows themselves, which is both where they belong and the only way they
+ *  stay true — the digits moved, and copy naming a digit it does not own
+ *  goes stale silently. The tool name is escaped for the dock-less
+ *  fallback question because it reaches the terminal as raw text there;
+ *  the panel's own rows are escaped by the panel renderer. */
 export declare function uncertainView(name: string, executionId: string): PanelView;
 /**
  * KC3.5 — the SAME uncertainty gate, said honestly for an ask_user call.
@@ -70,7 +74,7 @@ export declare function uncertainView(name: string, executionId: string): PanelV
  * (The round's ① probe pinned why this surface exists at all: the
  * shipped recovery blocks on a started-unreported execution regardless
  * of idempotency, so an interrupted ask meets this gate on the way
- * back. Re-asking is safe — that is what "1 re-ask" says out loud.)
+ * back. Re-asking is safe — that is what the first option says out loud.)
  */
 export declare function unansweredAskView(executionId: string): PanelView;
 /** An extension as the banner names it — the live `connecting` flag is
@@ -119,24 +123,20 @@ export declare function displayVerb(name: string): string;
  *  one dim line rather than four table rows, because they apply only
  *  while a panel is up. */
 /**
- * TUI2-R1.5 pin 6 — this row has to be true of BOTH panel flavors, and
- * "digits select" was wrong in both directions at once.
+ * TUI2-R1.5 pin 6 — this row has to be true of BOTH panel flavors.
  *
- * On an APPROVAL a digit only moves the selection (editor's #panelSelect
- * sets `sel` and renders); ENTER is what resolves it. A reader who
- * pressed 1 and walked away had approved nothing — the worst kind of
- * false affordance, on the surface where the stakes are a side effect.
+ * The R1.5 wording ("digits pick · ⏎ confirms") was the sentence that
+ * covered an approval where a digit only SELECTED and an ask where a
+ * digit ANSWERED. TUI2-R3v2 ① removed the disagreement it was papering
+ * over: every panel is a list with a bar on it, ↑↓ move the bar, ⏎ (or a
+ * click) takes the row under it, and a digit takes its row outright.
+ * One sentence, now true of every flavor for the same reason rather than
+ * by careful omission.
  *
- * On an ASK the opposite: a digit on a SINGLE-choice question answers it
- * and advances the walk (ask-panel's askKey → advance), so "select"
- * undersold it. A multi-select question toggles and waits for enter,
- * like the approval.
- *
- * "digits pick · ⏎ confirms" is the sentence both flavors satisfy. The
- * single-choice fast path — where the confirm is implicit — is the one
- * thing a single row cannot also carry; it is an omission, never a lie.
+ * The two ask-only gestures keep their clauses because the ask is the
+ * only flavor with a set to build and an answer to write.
  */
-export declare const PANEL_KEYS_ROW = "panels: digits pick \u00B7 \u23CE confirms \u00B7 space toggles \u00B7 t types an answer";
+export declare const PANEL_KEYS_ROW = "panels: \u2191\u2193 move \u00B7 \u23CE or click confirms \u00B7 1-4 instant \u00B7 space toggles \u00B7 t types";
 /**
  * TUI2-R1 (D) — the sheet, one screen, static.
  *

package/dist/strings.js

@@ -1,6 +1,6 @@
 /**
- * tui-cells — the human-facing STRINGS (KC3 slice 1, the ADR-0041
- * escape hatch: extraction, never a raise): the readline prompt, the
+ * tui-cells — the human-facing STRINGS (KC3 slice 1, the escape hatch
+ * of ADR-0043, which supersedes ADR-0041): the readline prompt, the
  * project-trust listing rows and its panel view, the uncertain
  * execution's panel view, and the non-TTY not-trusted note. All five
  * were built inline in the CLI's trust-ui.ts before the move.
@@ -64,10 +64,14 @@ export function projectUntrustedNote(count, root) {
     return `[project .kiso] found ${count} artifact(s) in ${root} — not trusted, not loaded (run kiso interactively once to decide)`;
 }
 /** rounds 8/10 — the uncertain execution's panel: the SIMPLE flavor
- *  again, with the options re-labelled in the rule line (1 rerun · 3
- *  abandon). The tool name is escaped for the dock-less fallback
- *  question because it reaches the terminal as raw text there; the
- *  panel's own rows are escaped by the panel renderer. */
+ *  again. TUI2-R3v2 ①: the option labels used to be smuggled into the
+ *  rule line ("— 1 rerun · 3 abandon") because the panel only ever
+ *  rendered "Yes" and "No"; they ride `simpleOptions` now and land on the
+ *  rows themselves, which is both where they belong and the only way they
+ *  stay true — the digits moved, and copy naming a digit it does not own
+ *  goes stale silently. The tool name is escaped for the dock-less
+ *  fallback question because it reaches the terminal as raw text there;
+ *  the panel's own rows are escaped by the panel renderer. */
 export function uncertainView(name, executionId) {
     return {
         flavor: "simple",
@@ -76,7 +80,8 @@ export function uncertainView(name, executionId) {
         speaker: "kiso",
         statusText: "▸ uncertain execution",
         args: { kind: "text", lines: [executionId] },
-        ruleOverride: "did the interrupted execution apply? — 1 rerun · 3 abandon",
+        ruleOverride: "did the interrupted execution apply?",
+        simpleOptions: ["rerun it", "abandon it"],
         fallbackQuestion: `⚠ interrupted execution: ${escapeTerminal(name)} (${executionId}) — did it apply? (y)es / (n)o `,
     };
 }
@@ -92,7 +97,7 @@ export function uncertainView(name, executionId) {
  * (The round's ① probe pinned why this surface exists at all: the
  * shipped recovery blocks on a started-unreported execution regardless
  * of idempotency, so an interrupted ask meets this gate on the way
- * back. Re-asking is safe — that is what "1 re-ask" says out loud.)
+ * back. Re-asking is safe — that is what the first option says out loud.)
  */
 export function unansweredAskView(executionId) {
     return {
@@ -102,7 +107,8 @@ export function unansweredAskView(executionId) {
         speaker: "kiso",
         statusText: "▸ unanswered question",
         args: { kind: "text", lines: [executionId] },
-        ruleOverride: "an unanswered question was interrupted — ask it again? — 1 re-ask · 3 drop",
+        ruleOverride: "an unanswered question was interrupted — ask it again?",
+        simpleOptions: ["ask it again", "drop it"],
         fallbackQuestion: `⚠ an unanswered question was interrupted (${executionId}) — ask it again? (y)es / (n)o `,
     };
 }
@@ -193,24 +199,20 @@ export function displayVerb(name) {
  *  one dim line rather than four table rows, because they apply only
  *  while a panel is up. */
 /**
- * TUI2-R1.5 pin 6 — this row has to be true of BOTH panel flavors, and
- * "digits select" was wrong in both directions at once.
+ * TUI2-R1.5 pin 6 — this row has to be true of BOTH panel flavors.
  *
- * On an APPROVAL a digit only moves the selection (editor's #panelSelect
- * sets `sel` and renders); ENTER is what resolves it. A reader who
- * pressed 1 and walked away had approved nothing — the worst kind of
- * false affordance, on the surface where the stakes are a side effect.
+ * The R1.5 wording ("digits pick · ⏎ confirms") was the sentence that
+ * covered an approval where a digit only SELECTED and an ask where a
+ * digit ANSWERED. TUI2-R3v2 ① removed the disagreement it was papering
+ * over: every panel is a list with a bar on it, ↑↓ move the bar, ⏎ (or a
+ * click) takes the row under it, and a digit takes its row outright.
+ * One sentence, now true of every flavor for the same reason rather than
+ * by careful omission.
  *
- * On an ASK the opposite: a digit on a SINGLE-choice question answers it
- * and advances the walk (ask-panel's askKey → advance), so "select"
- * undersold it. A multi-select question toggles and waits for enter,
- * like the approval.
- *
- * "digits pick · ⏎ confirms" is the sentence both flavors satisfy. The
- * single-choice fast path — where the confirm is implicit — is the one
- * thing a single row cannot also carry; it is an omission, never a lie.
+ * The two ask-only gestures keep their clauses because the ask is the
+ * only flavor with a set to build and an answer to write.
  */
-export const PANEL_KEYS_ROW = "panels: digits pick · ⏎ confirms · space toggles · t types an answer";
+export const PANEL_KEYS_ROW = "panels: ↑↓ move · ⏎ or click confirms · 1-4 instant · space toggles · t types";
 /** The sheet's grid: the first six bindings in two 3-column rows, the
  *  last four in two 2-column rows (the wide entries get the room). The
  *  COLUMN STOPS are the prototype's absolute positions, floored by the

package/dist/width.d.ts

@@ -19,10 +19,24 @@
  */
 /** 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

@@ -58,62 +58,84 @@ const EMOJI_PRESENTATION = [
     [0x2b50, 0x2b50],
     [0x2b55, 0x2b55],
 ];
-/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
-export function charWidth(cp) {
+/** 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 2; // mahjong red dragon, joker
+        return true; // mahjong red dragon, joker
     if (cp >= 0x1f18e && cp <= 0x1f19a)
-        return 2; // enclosed alphanumerics
+        return true; // enclosed alphanumerics
     if (cp >= 0x1f200 && cp <= 0x1f251)
-        return 2; // enclosed ideographic
+        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 2; // transport + map
+        return true; // transport + map
     if (cp >= 0x1f7e0 && cp <= 0x1f7eb)
-        return 2; // colored circles + squares
+        return true; // colored circles + squares
     if (cp >= 0x1f900 && cp <= 0x1f9ff)
-        return 2; // supplemental emoji
+        return true; // supplemental emoji
     if (cp >= 0x1fa70 && cp <= 0x1faff)
-        return 2; // symbols + pictographs ext-A
-    if (cp >= 0x20000 && cp <= 0x3fffd)
-        return 2; // CJK ext B..G
+        return true; // symbols + pictographs ext-A
     if (cp >= 0x231a && cp <= 0x2b55) {
         for (const [lo, hi] of EMOJI_PRESENTATION)
             if (cp >= lo && cp <= hi)
-                return 2;
+                return true;
     }
-    return 1;
+    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) {
@@ -129,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.10.0",
+  "version": "0.12.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",