@vincemakes/kiso-tui 0.15.4 → 0.15.6

package/dist/compositor.js

@@ -803,8 +803,14 @@ export class Body {
         // "[?1000l[?1006l" into piped stdout and four gates caught it
         // (compact-cli, tui-modes, tui-v7-planmode, tui2-r2-resume-picker):
         // the invariant is about terminals, and a pipe is not one.
+        // REL-0152-D14: autowrap goes back on with the mouse, and for the
+        // same reason — the terminal outlives kiso, and a mode kiso turned
+        // off inside a frame must never be what the shell inherits. The
+        // frame restores it itself; this is the second belt, on the same
+        // TTY gate, because a half-torn-down compositor is exactly where a
+        // mode leak survives.
         if (process.stdout.isTTY === true)
-            this.#write(MOUSE_OFF);
+            this.#write(`${MOUSE_OFF}\x1b[?7h`);
         if (!this.#docked) {
             // TUI2-R2pre ③: an un-docked compositor can still hold a listener
             // (it was superseded, or enter() ran and the dock was torn down by
@@ -1180,6 +1186,36 @@ export class Body {
             panelSpan === null ? null : { top: liveTop + panelSpan.offset, count: panelSpan.count, first: panelSpan.first };
         // 5. the frame bytes.
         const out = [];
+        // REL-0152-D14 — AUTOWRAP OFF for the frame's duration.
+        //
+        // Found in the owner's own capture: 97 of the rows kiso emitted at
+        // 80 columns are EXACTLY 80 cells wide — the box top, the box
+        // bottom, the composer row, every gap row the chrome pads out. A
+        // character printed into the last column does not move the cursor
+        // past it; it sets the terminal's PENDING WRAP flag, and the next
+        // printed character goes to column 1 of the following row. What
+        // terminals do with that flag when a cursor MOVE arrives instead
+        // of a character is not agreed on — some clear it, some keep it —
+        // and this frame then makes 65 relative cursor-ups through exactly
+        // that state.
+        //
+        // So the frame's layout depended on a behaviour terminals disagree
+        // about, on every frame, at every width where a row happens to
+        // fill the screen. That is enough to explain a layout that is
+        // correct on one terminal and damaged on another, and damaged only
+        // while frames are being painted.
+        //
+        // With autowrap off, a character in the last column simply stays
+        // there: no pending flag, no disagreement, and relative moves mean
+        // what they say. kiso can never lose content to it either, because
+        // #checked already refuses to emit a row wider than the screen —
+        // the invariant that makes turning wrapping off safe was in place
+        // long before this.
+        //
+        // Restored at the end of every frame: prose written OUTSIDE a
+        // frame (bodyLog, an error) is ordinary output and must still
+        // wrap, and the shell inherits the terminal when kiso exits.
+        out.push("\x1b[?7l");
         out.push(this.#conservative ? "\x1b[?25l" : "\x1b[?2026h"); // D1: sync ON, or cursor-hide where 2026 is dead bytes
         // A8: the bottom-anchored window (the model's last H rows) shifts
         // DOWN when the live region SHRINKS — the done-fold, the fold-hold
@@ -1202,6 +1238,7 @@ export class Body {
             this.#drawSteady(out, W, H, liveTop, liveLines, queueRows, menuRows, editor);
         }
         out.push(this.#conservative ? "\x1b[?25h" : "\x1b[?2026l");
+        out.push("\x1b[?7h"); // REL-0152-D14: autowrap back on for everything outside the frame
         this.#write(out.join(""));
         this.#lastLiveTop = liveTop;
         this.#lastLiveRows = liveRowsTotal;

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.6",
 	"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.6"
 	}
 }