@vincemakes/kiso-tui-cells 0.8.0 → 0.10.0

package/dist/diff.js

@@ -91,23 +91,37 @@ function stats(diff) {
     }
     return { added, removed };
 }
-/** edit_file: the search→replace windows replace in place — the changed
- *  region is KNOWN, so the diff is the old window vs the new window,
- *  context from the surrounding file. */
-export function editFileDiff(oldContent, search, replace) {
-    const oldLines = oldContent.split("\n");
-    const searchLines = search.split("\n");
-    const replaceLines = replace.split("\n");
-    // Locate the search window (the first occurrence — the edit tool's own
-    // semantics); no occurrence → the whole file is the old side.
-    let at = -1;
-    for (let i = 0; i + searchLines.length <= oldLines.length; i += 1) {
-        if (oldLines.slice(i, i + searchLines.length).join("\n") === search) {
-            at = i;
-            break;
-        }
+/** edit_file: the preview of a CHARACTER splice.
+ *
+ *  TUI2-R1.5 ② (VD-2): the locator is the tool's own, verbatim — the
+ *  workspace edit_file does `i = text.indexOf(search)` and writes
+ *  `text.slice(0, i) + replace + text.slice(i + search.length)`. This
+ *  function mirrors those two lines and diffs the result against the
+ *  original; it does not model the edit, it reproduces it.
+ *
+ *  The retired locator required the search to align to FULL LINES. A
+ *  mid-line search ("// OLD" inside "  // OLD") therefore missed, and
+ *  the miss branch rendered the WHOLE FILE as the old side: a one-line
+ *  edit was drawn as a catastrophic rewrite, on the approval panel, at
+ *  the moment a human was deciding whether to allow it. A preview that
+ *  can be that wrong is worse than no preview.
+ *
+ *  A genuine miss is now reported as a miss: the tool will return
+ *  `pattern not found in <path>` and change nothing, so the panel says
+ *  exactly that instead of inventing a diff for an edit that will not
+ *  happen. `path` names the file in that note. */
+export function editFileDiff(oldContent, search, replace, path) {
+    const at = oldContent.indexOf(search);
+    if (at < 0) {
+        return {
+            lines: [{ kind: " ", text: `pattern not found in ${path ?? "the file"}` }],
+            added: 0,
+            removed: 0,
+            notFound: true,
+        };
     }
-    const lines = at < 0 ? withContext(lcsDiff(oldLines, replaceLines)) : withContext(lcsDiff(oldLines, [...oldLines.slice(0, at), ...replaceLines, ...oldLines.slice(at + searchLines.length)]));
+    const result = oldContent.slice(0, at) + replace + oldContent.slice(at + search.length);
+    const lines = withContext(lcsDiff(oldContent.split("\n"), result.split("\n")));
     return { lines, ...stats(lines) };
 }
 /** write_file: a new file is all +; an existing file diffs row-level

package/dist/index.d.ts

@@ -6,11 +6,12 @@
  * package); the cli never imports it directly. Experimental — no
  * API-stability promise yet.
  */
-export { SPINNER, foldLine, visibleWidth, bodySpacing, Container, cellComponent, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, type FrameCtx, type RenderLine, type Component, type BodyCell, } from "./components.js";
+export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, focusToken, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, type FrameCtx, type RenderLine, type Component, type BodyCell, } from "./components.js";
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
 export { pendingQueueRows } from "./components.js";
 export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, type PanelSel, type PanelState, type PanelVerdict, type PanelView, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, } from "./approval-panel.js";
 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, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";

package/dist/index.js

@@ -6,7 +6,7 @@
  * package); the cli never imports it directly. Experimental — no
  * API-stability promise yet.
  */
-export { SPINNER, foldLine, visibleWidth, bodySpacing, Container, cellComponent, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, } from "./components.js";
+export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, focusToken, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, } from "./components.js";
 export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";
 // W22 (the v8 input round): the pending-queue chips — the SAME
 // UserMessage chip with the □ gutter, pre-rendered above the input
@@ -25,4 +25,7 @@ export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWi
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, } from "./strings.js";
 // KC3.5: the interrupted-ask copy and the extracted /help table.
 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, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";

package/dist/render.d.ts

@@ -34,6 +34,14 @@ 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;
     readonly rv: string;
     readonly rvEnd: 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", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
+export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", warn: "", code: "", rv: "", rvEnd: "", reset: "" };
 export function palette() {
     return process.env.NO_COLOR === undefined && process.stdout.isTTY ? COLOR_ON : COLOR_OFF;
 }

package/dist/strings.d.ts

@@ -93,6 +93,63 @@ export interface BannerExtension {
  * reads `built-in: mcp, skills, subagent`, from this one composition.
  */
 export declare function extensionsBannerText(builtIn: readonly BannerExtension[], user: readonly BannerExtension[], project: readonly BannerExtension[]): string;
+/** One gesture: what you press, and what it does. */
+export interface KeyBinding {
+    readonly keys: string;
+    readonly what: string;
+}
+/**
+ * TUI2-R1 (D) — THE key table. Every reader derives from it: the `?`
+ * sheet and /help's keys row. A sheet that has drifted from the keys is
+ * worse than no sheet, and the only way to make drift impossible is to
+ * have one table and no second copy of it.
+ *
+ * The order is the sheet's reading order, which is why it is grouped by
+ * WHAT A HUMAN IS DOING rather than alphabetically: the three ways to
+ * put something in (send, newline, files), the three ways to change
+ * course (stop, redirect, commands), then the walks (history, expand),
+ * 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. */
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare const PANEL_KEYS_ROW = "panels: digits pick \u00B7 \u23CE confirms \u00B7 space toggles \u00B7 t types an answer";
+/**
+ * TUI2-R1 (D) — the sheet, one screen, static.
+ *
+ * Rows CUT at the width rather than folding: the sheet's contract with
+ * the reader is "one screen", and a folded grid at 40 columns is two
+ * screens pretending to be one. A narrow terminal shows fewer columns
+ * of the same truth, which is the honest degradation.
+ */
+export declare function keysSheetRows(W: number): string[];
+/** TUI2-R1 (D) — the keys as ONE line, for /help. The same table the
+ *  sheet renders, joined — so the two can disagree only by deleting a
+ *  test. The sheet is the readable form; this is the greppable one. */
+export declare function keysHelpRow(): string;
 /**
  * KC3.5 slice ⓪ (the extraction) — the /help command table.
  *

package/dist/strings.js

@@ -18,6 +18,7 @@
  * looked up here.
  */
 import { escapeTerminal, palette } from "./render.js";
+import { displayWidth } from "./width.js";
 /** v2a: the interactive prompt — the identity accent. readline owns the
  *  echo of what the user types; we own the prompt's color. (v2c: the
  *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
@@ -130,6 +131,169 @@ export function extensionsBannerText(builtIn, user, project) {
         parts.push(`project: ${project.map(label).join(", ")}`);
     return ` · [${total} extension${total === 1 ? "" : "s"}: ${parts.join(" · ")}]`;
 }
+/**
+ * TUI2-R1 (D) — THE key table. Every reader derives from it: the `?`
+ * sheet and /help's keys row. A sheet that has drifted from the keys is
+ * worse than no sheet, and the only way to make drift impossible is to
+ * have one table and no second copy of it.
+ *
+ * The order is the sheet's reading order, which is why it is grouped by
+ * WHAT A HUMAN IS DOING rather than alphabetically: the three ways to
+ * put something in (send, newline, files), the three ways to change
+ * course (stop, redirect, commands), then the walks (history, expand),
+ * then the completions.
+ */
+export const KEY_BINDINGS = [
+    { keys: "enter", what: "send" },
+    { keys: "ctrl+j / shift+⏎", what: "newline" },
+    { keys: "@", what: "files" },
+    { keys: "esc", what: "stop" },
+    { keys: "alt+⏎ / ctrl+⏎", what: "redirect" },
+    { keys: "/", what: "commands" },
+    { keys: "↑↓", what: "history / queue pop" },
+    { keys: "ctrl+r", what: "expand cells" },
+    { 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. */
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export const PANEL_KEYS_ROW = "panels: digits pick · ⏎ confirms · space toggles · t types an answer";
+/** 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
+ *  content (a future binding widens its column rather than overrunning
+ *  it — the grid degrades to one space, never to a collision). */
+const SHEET_GRID = [
+    [0, 1, 2],
+    [3, 4, 5],
+    [6, 7],
+    [8, 9],
+];
+const SHEET_STOPS = [
+    [16, 43],
+    [16, 43],
+    [36],
+    [36],
+];
+/**
+ * TUI2-R1 (D) — the sheet, one screen, static.
+ *
+ * Rows CUT at the width rather than folding: the sheet's contract with
+ * the reader is "one screen", and a folded grid at 40 columns is two
+ * screens pretending to be one. A narrow terminal shows fewer columns
+ * of the same truth, which is the honest degradation.
+ */
+export function keysSheetRows(W) {
+    const p = palette();
+    const cell = (i) => {
+        const b = KEY_BINDINGS[i];
+        return b === undefined ? "" : `${p.code}${b.keys}${p.reset} ${b.what}`;
+    };
+    const plainCell = (i) => {
+        const b = KEY_BINDINGS[i];
+        return b === undefined ? "" : `${b.keys} ${b.what}`;
+    };
+    const rows = [`${p.bold}keys${p.reset}`];
+    for (let r = 0; r < SHEET_GRID.length; r += 1) {
+        const indexes = SHEET_GRID[r];
+        let row = "";
+        let width = 0;
+        for (let c = 0; c < indexes.length; c += 1) {
+            row += cell(indexes[c]);
+            width += displayWidth(plainCell(indexes[c]));
+            const stop = SHEET_STOPS[r][c];
+            if (stop === undefined)
+                continue; // the last column pads nothing
+            const pad = Math.max(1, stop - width);
+            row += " ".repeat(pad);
+            width += pad;
+        }
+        rows.push(row);
+    }
+    rows.push(`${p.dim}${PANEL_KEYS_ROW}${p.reset}`);
+    return rows.map((row) => cutRow(row, W));
+}
+/** One row, cut at the width — SGR-aware, the ellipsis after the reset
+ *  (the cutLine convention; duplicated here rather than imported so the
+ *  strings module keeps its no-components-dependency shape). */
+function cutRow(row, W) {
+    let out = "";
+    let width = 0;
+    for (let i = 0; i < row.length;) {
+        if (row[i] === "\x1b") {
+            const m = /^\x1b\[[0-9;]*m/.exec(row.slice(i))?.[0] ?? row[i];
+            out += m;
+            i += m.length;
+            continue;
+        }
+        const cw = displayWidth(row[i]);
+        if (width + cw > W)
+            return `${out}${palette().reset}`;
+        out += row[i];
+        width += cw;
+        i += 1;
+    }
+    return out;
+}
+/** TUI2-R1 (D) — the keys as ONE line, for /help. The same table the
+ *  sheet renders, joined — so the two can disagree only by deleting a
+ *  test. The sheet is the readable form; this is the greppable one. */
+export function keysHelpRow() {
+    return KEY_BINDINGS.map((b) => `${b.keys} ${b.what}`).join(" · ");
+}
 /**
  * KC3.5 slice ⓪ (the extraction) — the /help command table.
  *
@@ -152,6 +316,13 @@ export function helpRows() {
         cmd("/mode", "show the approval tier; /mode <name> switches (manual/default/accept-edits/plan/bypass)"),
         cmd("/model", "list model profiles; /model <name|provider/model> switches"),
         cmd("/compact", "summarize the older conversation to free context"),
+        // TUI2-R1 (D): DELIBERATELY UNCHANGED. Deriving this sentence from
+        // KEY_BINDINGS would be an improvement and it would also move an
+        // assertion outside the round's two declared supersession classes,
+        // so the sheet is the derived surface and this row keeps its bytes.
+        // `keysHelpRow()` exists for the round that is allowed to make the
+        // swap; until then the drift guard is the test that every binding
+        // in the table is mentioned here.
         `${cmd("exit", "leave the session")}\n${cmd("keys", "enter sends · ctrl+J newline (shift+enter where encoded) · esc stops the run · alt+⏎ stops it and sends this instead · @ files · 1-4 answers an ask")}`,
     ];
 }

package/dist/width.d.ts

@@ -1,11 +1,21 @@
 /**
  * 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;

package/dist/width.js

@@ -1,12 +1,63 @@
 /**
  * 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).
  */
+/** 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],
+];
 /** A code point's display width: 2 for the wide ranges, 1 otherwise. */
 export function charWidth(cp) {
     if (cp >= 0x1100 && cp <= 0x115f)
@@ -35,12 +86,33 @@ export function charWidth(cp) {
         return 2; // fullwidth forms
     if (cp >= 0xffe0 && cp <= 0xffe6)
         return 2; // fullwidth signs
+    // 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
+    if (cp >= 0x1f18e && cp <= 0x1f19a)
+        return 2; // enclosed alphanumerics
+    if (cp >= 0x1f200 && cp <= 0x1f251)
+        return 2; // enclosed ideographic
     if (cp >= 0x1f300 && cp <= 0x1f64f)
         return 2; // emoji (misc + emoticons)
+    if (cp >= 0x1f680 && cp <= 0x1f6ff)
+        return 2; // transport + map
+    if (cp >= 0x1f7e0 && cp <= 0x1f7eb)
+        return 2; // colored circles + squares
     if (cp >= 0x1f900 && cp <= 0x1f9ff)
         return 2; // supplemental emoji
+    if (cp >= 0x1fa70 && cp <= 0x1faff)
+        return 2; // symbols + pictographs ext-A
     if (cp >= 0x20000 && cp <= 0x3fffd)
         return 2; // CJK ext B..G
+    if (cp >= 0x231a && cp <= 0x2b55) {
+        for (const [lo, hi] of EMOJI_PRESENTATION)
+            if (cp >= lo && cp <= hi)
+                return 2;
+    }
     return 1;
 }
 /** Display width of a code-point array (cursor math, scrolling). */

package/package.json

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