@vincemakes/kiso-tui 0.15.4 → 0.15.5

package/dist/editor.js

@@ -134,6 +134,25 @@ export class Editor {
     #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;
@@ -784,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;
@@ -815,6 +847,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.#askStep(typing ? "commit" : "enter");
                         i += 1;
                         continue;
@@ -867,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;
@@ -1229,10 +1287,11 @@ export class Editor {
             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.#encapsulate();
+                this.#commitPaste();
                 this.#onRender();
             }
         }
@@ -1710,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
@@ -1813,21 +1879,54 @@ export class Editor {
      * every editing operation in this file works on it without knowing
      * it exists.
      */
-    #encapsulate() {
-        const start = this.#pasteAt;
+    /** 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 (start === null || this.#cursor <= start)
+        if (run.length === 0)
             return;
-        const pasted = String.fromCodePoint(...this.#chars.slice(start, this.#cursor));
+        if (this.#historyIdx !== null)
+            this.#historyIdx = null;
+        this.#queuePopMode = false;
+        const pasted = _a.#textOf(run);
         const lines = pasted.split("\n").length;
-        if (lines < _a.#PASTE_LINES && pasted.length < _a.#PASTE_CHARS)
-            return;
-        this.#pasteSeq += 1;
-        this.#pastes.set(this.#pasteSeq, pasted);
-        const capsule = [..._a.#capsuleText(this.#pasteSeq, lines)].map((ch) => ch.codePointAt(0));
-        this.#chars.splice(start, this.#cursor - start, ...capsule);
-        this.#cursor = start + capsule.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.

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.4",
+	"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.4"
+		"@vincemakes/kiso-tui-cells": "0.15.5"
 	}
 }