@vincemakes/kiso-tui 0.15.3 → 0.15.5

package/dist/ask-panel.d.ts

@@ -53,6 +53,11 @@ export interface AskStep {
     readonly state: AskRuntime;
     readonly result?: AskResult;
 }
+/** REL-0152-D4: is the cursor on the type-your-own row? The editor asks
+ *  before it decides what a printable key means — on this row a key is
+ *  the first character of an answer, everywhere else it is a shortcut.
+ *  Exported so that rule lives on ONE definition of the row. */
+export declare function askOnCustomRow(spec: AskSpec, state: AskRuntime): boolean;
 export declare function askKey(spec: AskSpec, state: AskRuntime, key: string): AskStep;
 /** The typed answer commits: it becomes THE answer for this question
  *  (clearing its picks) and the walk advances. An empty line is a

package/dist/ask-panel.js

@@ -107,6 +107,14 @@ function toggle(state, option, multi) {
  *  option, which is where `askBlockRows` draws it. Options and this row
  *  are one list to the eye, so they are one list to the cursor. */
 const customRow = (q) => q.options.length;
+/** REL-0152-D4: is the cursor on the type-your-own row? The editor asks
+ *  before it decides what a printable key means — on this row a key is
+ *  the first character of an answer, everywhere else it is a shortcut.
+ *  Exported so that rule lives on ONE definition of the row. */
+export function askOnCustomRow(spec, state) {
+    const q = spec.questions[state.qIndex];
+    return q !== undefined && state.phase === "options" && state.cursor === customRow(q);
+}
 export function askKey(spec, state, key) {
     const q = spec.questions[state.qIndex];
     const multi = q.multiSelect === true;
@@ -119,7 +127,11 @@ export function askKey(spec, state, key) {
     }
     if (key === "esc")
         return { state, result: askDeclineAll(spec) };
-    if (key === "t")
+    // `t` is the shortcut from anywhere in the list; `type` is the
+    // REL-0152-D4 gesture — the editor sends it when the cursor is
+    // already on the custom row and a printable key arrives, so the
+    // keystroke that opened the phase is also its first character.
+    if (key === "t" || key === "type")
         return { state: { ...state, phase: "custom" } };
     if (key === "left")
         return { state: state.qIndex === 0 ? state : { ...state, qIndex: state.qIndex - 1, cursor: 0 } };
@@ -202,9 +214,17 @@ export function askBlockRows(view, state, W, maxRows) {
     // look like a footnote.
     const typed = state.custom[state.qIndex];
     const onCustom = state.cursor === customRow(q);
-    body.push(`${gutter}${cutLine(typed === null || typed === undefined
-        ? `${onCustom ? p.bold : p.dim} t   type your own answer${p.reset}`
-        : `${onCustom ? p.bold : ""} t ◉ ${escapeTerminal(typed)}${p.reset}`, Math.max(1, W - 2))}`);
+    // REL-0152-D4: while the phase is OPEN the row becomes the answer's
+    // box — a faint placeholder standing where the text will land, so an
+    // empty typing phase looks like somewhere to type instead of looking
+    // like nothing happened. The placeholder is dim and the answer is
+    // not: the two can never be mistaken for each other.
+    const typingHere = state.phase === "custom";
+    body.push(`${gutter}${cutLine(typed !== null && typed !== undefined
+        ? `${onCustom || typingHere ? p.bold : ""} t ◉ ${escapeTerminal(typed)}${p.reset}`
+        : typingHere
+            ? `${p.bold} t ▸${p.reset} ${p.dim}type your answer — enter sends, esc backs out${p.reset}`
+            : `${onCustom ? p.bold : p.dim} t   type your own answer${p.reset}`, Math.max(1, W - 2))}`);
     // the bounded block: the options fold nothing and cut individually,
     // so the cap drops whole rows with the W21 notice row.
     const budget = Math.max(1, maxRows - 5);

package/dist/editor.js

@@ -21,6 +21,7 @@
  * (?2004h) unwraps and inserts its newlines LITERALLY; every newline
  * source funnels through the ONE normalizer in feed() (§3).
  */
+var _a;
 import { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // the width primitives moved to width.ts (W1, the single width
 // authority) — re-exported so the editor's public surface is unchanged.
@@ -29,7 +30,7 @@ import { palette } from "./render.js";
 import { PICK_MAX, panelOptions, saferDegradedNote, } from "./approval-panel.js";
 // KC3.5: the panel-slot dispatchers — the ask branch folded into the
 // W21 lead/rows, so this file keeps ONE panel and one key owner.
-import { askCommitCustom, askKey, askStart, panelLead } from "./ask-panel.js";
+import { askCommitCustom, askKey, askOnCustomRow, askStart, panelLead } from "./ask-panel.js";
 import { AT_VISIBLE, atFilter } from "./at-picker.js";
 // TUI2-R2 ②: the session picker — the band's THIRD occupant. Its filter
 // is the @ picker's rank aimed at the session id; the editor owns the
@@ -110,6 +111,48 @@ export class Editor {
     // user's next turn.
     #panel = null;
     #pasting = false;
+    /**
+     * REL-0152-D8 — the paste capsule.
+     *
+     * A paste large enough to break the composer's layout is held HERE
+     * and shown in the buffer as `[Pasted text #N +M lines]`. The buffer
+     * is the display; this map is the content; the line that LEAVES the
+     * editor is the content again. That ordering is the whole design —
+     * the capsule can never truncate what gets sent, because expansion
+     * happens on the way out and reads from a map the display cannot
+     * edit.
+     *
+     * A capsule the human deletes is a paste that never happened: the
+     * token is gone, the expansion finds nothing to replace, and the
+     * entry is simply never read. That is how you take a paste back.
+     *
+     * The map is per-editor and grows by one entry per large paste in a
+     * session — bounded by how many times a human can press cmd-V, and
+     * every entry is text they chose to paste and may still submit.
+     */
+    #pastes = new Map();
+    #pasteSeq = 0;
+    /** The buffer index where the in-flight paste began; null outside one. */
+    #pasteAt = null;
+    /**
+     * REL-0152-D9 — the in-flight paste's characters, held OUT of the
+     * buffer until the paste ends.
+     *
+     * Every character used to go through #insert, which splices one code
+     * point and then reflows — and a reflow scans the line to find the
+     * cursor's bounds and measures its width. That is linear work per
+     * character, so a paste cost time in the SQUARE of its size: measured
+     * on the shipped build, 10k characters took 33ms and 30k took 278ms,
+     * with a 100k paste heading for three seconds of a frozen composer.
+     * The owner's report: the capsule appears, but only after a long wait.
+     *
+     * Held here, the whole run splices in ONCE and reflows ONCE, so the
+     * cost is linear and the arithmetic is done on a finished string
+     * rather than re-done at every character of it. It survives across
+     * chunks by construction — a terminal delivers a large paste in many
+     * reads, and this is a field, not a local.
+     */
+    #pasteRun = null;
     /** TUI2-R3v2 ①: one-shot — a panel that just closed swallows the
      *  habitual trailing enter rather than submitting the restored draft. */
     #swallowEnter = false;
@@ -760,6 +803,19 @@ export class Editor {
                         continue;
                     }
                     if (c === "\x0d" || c === "\x0a") {
+                        // REL-0152-D10: a newline inside a PASTE is content, never a
+                        // commit. Bracketed paste marks its own boundaries, so a
+                        // \n between them is a line of the pasted text and nothing
+                        // else. Without this, pasting a stack trace into a typed
+                        // panel phase submitted the first line and dropped the
+                        // rest into the composer behind the closed panel — the
+                        // owner asked whether the type-your-own box takes a paste,
+                        // and the answer was no, in the worst way.
+                        if (this.#pasting) {
+                            this.#insert(NEWLINE);
+                            i += c === "\x0d" && text[i + 1] === "\x0a" ? 2 : 1;
+                            continue;
+                        }
                         this.#pickPanelEnter();
                         i += 1;
                         continue;
@@ -791,10 +847,39 @@ export class Editor {
                         continue;
                     }
                     if (c === "\x0d" || c === "\x0a") {
+                        // REL-0152-D10: a newline inside a PASTE is content, never a
+                        // commit. Bracketed paste marks its own boundaries, so a
+                        // \n between them is a line of the pasted text and nothing
+                        // else. Without this, pasting a stack trace into a typed
+                        // panel phase submitted the first line and dropped the
+                        // rest into the composer behind the closed panel — the
+                        // owner asked whether the type-your-own box takes a paste,
+                        // and the answer was no, in the worst way.
+                        if (this.#pasting) {
+                            this.#insert(NEWLINE);
+                            i += c === "\x0d" && text[i + 1] === "\x0a" ? 2 : 1;
+                            continue;
+                        }
                         this.#askStep(typing ? "commit" : "enter");
                         i += 1;
                         continue;
                     }
+                    // REL-0152-D4 — on the custom row a printable key is TEXT.
+                    // The row names typing as its purpose and then swallowed
+                    // the first thing you typed; only enter or `t` opened the
+                    // phase. Now the keystroke opens it AND lands in the
+                    // buffer, so the character you meant is the character you
+                    // get. This is checked BEFORE the shortcut branch below on
+                    // purpose: on this row "3" and "t" are the start of an
+                    // answer, not a pick and not a mode key. Everywhere else
+                    // in the list they keep their fast-path meaning exactly.
+                    if (askOnCustomRow(panel.view.ask, panel.ask) && c !== undefined && c >= " " && c !== "\x7f") {
+                        this.#askStep("type");
+                        this.#insert(c.codePointAt(0));
+                        this.#onRender();
+                        i += 1;
+                        continue;
+                    }
                     if (!typing && (c === " " || (c !== undefined && c >= "1" && c <= "4") || c === "t" || c === "T")) {
                         this.#askStep(c === " " ? "space" : c === "T" ? "t" : c);
                         i += 1;
@@ -827,6 +912,19 @@ export class Editor {
                     continue;
                 }
                 if (c === "\x0d" || c === "\x0a") {
+                    // REL-0152-D10: a newline inside a PASTE is content, never a
+                    // commit. Bracketed paste marks its own boundaries, so a
+                    // \n between them is a line of the pasted text and nothing
+                    // else. Without this, pasting a stack trace into a typed
+                    // panel phase submitted the first line and dropped the
+                    // rest into the composer behind the closed panel — the
+                    // owner asked whether the type-your-own box takes a paste,
+                    // and the answer was no, in the worst way.
+                    if (this.#pasting) {
+                        this.#insert(NEWLINE);
+                        i += c === "\x0d" && text[i + 1] === "\x0a" ? 2 : 1;
+                        continue;
+                    }
                     this.#panelEnter();
                     i += 1;
                     continue;
@@ -1186,10 +1284,14 @@ export class Editor {
             const n = Number(params);
             if (n === 3)
                 this.#delete();
-            else if (n === 200)
+            else if (n === 200) {
                 this.#pasting = true;
+                this.#pasteAt = this.#cursor; // REL-0152-D8: where the capsule will go
+                this.#pasteRun = []; // REL-0152-D9: collect, do not insert
+            }
             else if (n === 201) {
                 this.#pasting = false;
+                this.#commitPaste();
                 this.#onRender();
             }
         }
@@ -1568,7 +1670,10 @@ export class Editor {
             return;
         const spec = panel.view.ask;
         const before = panel.ask.phase;
-        const step = key === "commit" ? askCommitCustom(spec, panel.ask, this.line()) : askKey(spec, panel.ask, key);
+        // REL-0152-D8: a typed ask answer is a line leaving the editor too —
+        // pasting a stack trace into "type your own answer" must send the
+        // stack trace, not the capsule that stands for it.
+        const step = key === "commit" ? askCommitCustom(spec, panel.ask, this.#expandPastes(this.line())) : askKey(spec, panel.ask, key);
         panel.ask = step.state;
         if (step.state.phase !== before) {
             this.#chars = [];
@@ -1664,6 +1769,13 @@ export class Editor {
     }
     // ---- editing ----
     #insert(cp) {
+        // REL-0152-D9: inside a paste the character is COLLECTED, not
+        // inserted — see #pasteRun. Every other caller (a typed key, a
+        // ctrl+J newline) is outside a paste and lands below unchanged.
+        if (this.#pasteRun !== null) {
+            this.#pasteRun.push(cp);
+            return;
+        }
         if (this.#historyIdx !== null)
             this.#historyIdx = null; // editing leaves the browse
         this.#queuePopMode = false; // W22: editing leaves the pop-walk too
@@ -1737,6 +1849,100 @@ export class Editor {
      *  reset together (W22: a departing line ends the pop-walk, so the
      *  next esc at rest interrupts again). Shared by the submit and the
      *  redirect — the two doors a line can leave by. */
+    /**
+     * REL-0152-D8 — how big a paste has to be before it is a capsule.
+     *
+     * LINES first, because lines are what actually break the layout: the
+     * composer grows a row per line and walks up the terminal. The
+     * character bound catches the pathological one-liner, which wraps to
+     * the same screenful by another route.
+     *
+     * Below both, the paste is left exactly as it arrived. A four-line
+     * snippet is something you want to SEE in the composer, and a capsule
+     * there would be pure obstruction.
+     */
+    static #PASTE_LINES = 8;
+    static #PASTE_CHARS = 900;
+    /** The token a capsule shows as. Parsed back by the same regexp on
+     *  the way out — one definition, so the two can never drift. */
+    static #capsuleText(id, lines) {
+        return `[Pasted text #${id} +${lines} line${lines === 1 ? "" : "s"}]`;
+    }
+    static #CAPSULE = /\[Pasted text #(\d+) \+\d+ lines?\]/g;
+    /**
+     * Close an in-flight paste: if it was large, swap the pasted run out
+     * of the buffer for its capsule and keep the text.
+     *
+     * The swap is a splice at the recorded start, so a paste in the
+     * MIDDLE of a line leaves the prose on both sides of it untouched —
+     * the capsule is a character run like any other from here on, and
+     * every editing operation in this file works on it without knowing
+     * it exists.
+     */
+    /** REL-0152-D9: code points to a string WITHOUT spreading the whole
+     *  array into one call. `String.fromCodePoint(...run)` throws
+     *  RangeError on a large paste — the argument list is the stack — and
+     *  a composer that crashes on a big paste is worse than one that is
+     *  slow. Chunked, it is linear and bounded. */
+    static #textOf(run) {
+        const CHUNK = 4096;
+        let out = "";
+        for (let i = 0; i < run.length; i += CHUNK)
+            out += String.fromCodePoint(...run.slice(i, i + CHUNK));
+        return out;
+    }
+    /**
+     * Close an in-flight paste: the collected run goes into the buffer in
+     * ONE splice — as itself when it is small, as its capsule when it is
+     * not (REL-0152-D8).
+     *
+     * The splice is at the recorded start, so a paste in the MIDDLE of a
+     * line leaves the prose on both sides untouched — what lands is a
+     * character run like any other from here on, and every editing
+     * operation in this file works on it without knowing it exists.
+     */
+    #commitPaste() {
+        const run = this.#pasteRun ?? [];
+        const start = this.#pasteAt ?? this.#cursor;
+        this.#pasteRun = null;
+        this.#pasteAt = null;
+        if (run.length === 0)
+            return;
+        if (this.#historyIdx !== null)
+            this.#historyIdx = null;
+        this.#queuePopMode = false;
+        const pasted = _a.#textOf(run);
+        const lines = pasted.split("\n").length;
+        const small = lines < _a.#PASTE_LINES && run.length < _a.#PASTE_CHARS;
+        let placed;
+        if (small) {
+            placed = run;
+        }
+        else {
+            this.#pasteSeq += 1;
+            this.#pastes.set(this.#pasteSeq, pasted);
+            placed = [..._a.#capsuleText(this.#pasteSeq, lines)].map((ch) => ch.codePointAt(0));
+        }
+        this.#chars.splice(start, 0, ...placed);
+        this.#cursor = start + placed.length;
+        this.#reflow();
+        this.#refreshMenu();
+    }
+    /**
+     * The way out: every capsule token becomes its text again.
+     *
+     * Applied to the line the editor HANDS OVER, never to the buffer —
+     * so what the human sees stays short and what the model receives is
+     * what the human pasted. A token whose entry is missing (a stale id
+     * recalled from history after the map moved on) is left standing as
+     * literal text rather than silently becoming an empty string: a
+     * visible oddity beats a silent deletion of someone's paste.
+     */
+    #expandPastes(line) {
+        if (this.#pastes.size === 0)
+            return line;
+        return line.replace(_a.#CAPSULE, (whole, id) => this.#pastes.get(Number(id)) ?? whole);
+    }
     #takeLine() {
         const line = String.fromCodePoint(...this.#chars);
         this.#chars = [];
@@ -1850,16 +2056,21 @@ export class Editor {
             }
         }
         const line = this.#takeLine();
+        // REL-0152-D8: the capsule expands ON THE WAY OUT. The consumer
+        // gets what was pasted; the HISTORY keeps the short form, so ↑
+        // recalls a readable line that still expands when it is sent
+        // again (the map outlives the buffer, by design).
+        const sent = this.#expandPastes(line);
         const cb = this.#questionCb;
         this.#questionCb = null;
         if (cb !== null) {
-            cb(line);
+            cb(sent);
         }
         else if (this.#lineCb !== null) {
-            this.#lineCb(line);
+            this.#lineCb(sent);
         }
         else {
-            this.#pendingLines.push(line); // nobody wired yet — hold it
+            this.#pendingLines.push(sent); // nobody wired yet — hold it
         }
         if (cb === null && line !== "")
             this.#remember(line);
@@ -1949,3 +2160,4 @@ export class Editor {
         return end;
     }
 }
+_a = Editor;

package/dist/session-picker.d.ts

@@ -28,6 +28,10 @@
  *  imports nothing from the runtime, by rule). */
 export interface SessionCardView {
     readonly id: string;
+    /** REL-0152-D6b: the session's first substantive prompt. Optional so
+     *  a caller that has not got one still renders — the row simply
+     *  carries no title, which is where this picker started. */
+    readonly title?: string;
     readonly badge: "uncertain" | "ask" | "interrupted" | "completed" | "failed";
     readonly turns: number;
     readonly updatedAt: number;

package/dist/session-picker.js

@@ -150,6 +150,11 @@ export function sessionFilter(cards, query) {
  * CRASHES the compositor, so the arithmetic has to be provably right at
  * every width rather than right at eighty.
  */
+/** REL-0152-D6b: what the title may take, and what it must leave. The
+ *  reserve is the widest note this picker writes ("N uncertain
+ *  executions"), so an actionable row keeps saying so. */
+const TITLE_MAX = 44;
+const NOTE_RESERVE = 22;
 function rowSpans(card, budget, now, idCol) {
     const p = palette();
     let text = "";
@@ -175,6 +180,20 @@ function rowSpans(card, budget, now, idCol) {
     put(" ".repeat(pad), " ".repeat(pad));
     const meta = `  ${sessionAge(card.updatedAt, now)} · ${card.turns} turn${card.turns === 1 ? "" : "s"}`;
     put(meta, `${p.dim}${meta}${p.reset}`);
+    // REL-0152-D6b: the TITLE — the only span on this row that answers
+    // "which conversation is this?". It goes after the meta and before
+    // the note, and it is bounded so the note (which can be the one that
+    // demands an action) still has room at ordinary widths; on a narrow
+    // terminal `put` drops whichever no longer fits, in that order.
+    const title = card.title ?? "";
+    if (title !== "") {
+        const room = Math.max(0, Math.min(budget - w - 3 - NOTE_RESERVE, TITLE_MAX));
+        const cut = widthCut(escapeTerminal(title), room);
+        if (cut !== "") {
+            put("  ", "  ");
+            put(cut, `${p.bold}${cut}${p.reset}`);
+        }
+    }
     const note = widthCut(sessionNote(card), Math.max(0, budget - w - 3));
     if (note !== "") {
         // the ? note carries the warn tint — the row's own words are what

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.15.3",
+	"version": "0.15.5",
 	"description": "kiso tui \u2014 the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.15.3"
+		"@vincemakes/kiso-tui-cells": "0.15.5"
 	}
 }