@vincemakes/kiso-tui 0.15.5 → 0.15.7

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.d.ts

@@ -68,6 +68,10 @@ export declare class Editor {
      *  over while the run is told to stop. Mirrors onEscape (a list, so
      *  listeners can coexist); the line arrives already gone from the
      *  composer, exactly as a submit's does. */
+    /** REL-0152-D11: what to do when a paste arrives empty. See
+     *  #onEmptyPaste — the CLI owns the platform, the editor owns the
+     *  moment. */
+    onEmptyPaste(cb: () => string | null): void;
     onRedirect(cb: (line: string) => void): void;
     /** W22: bind the pending-turn queue — the CLI's live slots. The ↑
      *  pop walks them (each pop leaves the queue, cancelling the turn);

package/dist/editor.js

@@ -153,6 +153,23 @@ export class Editor {
      * reads, and this is a field, not a local.
      */
     #pasteRun = null;
+    /**
+     * REL-0152-D11 — what an EMPTY paste means.
+     *
+     * Pasting an image sends nothing: a terminal has no way to put binary
+     * into a byte stream, so the bracketed paste arrives with no content.
+     * That emptiness is the signal — the user pressed paste and the
+     * terminal had nothing to hand over — and whatever they meant has to
+     * be fetched from the clipboard instead.
+     *
+     * The editor does not know what a clipboard is and must not: this
+     * package renders and reads keys, and reaching into the operating
+     * system from it would put a platform dependency under every gate in
+     * the suite. The CLI supplies the hook; the editor supplies the
+     * moment. It returns the text to insert (a path, for the CLI's
+     * attachment scan to pick up) or null when there was nothing.
+     */
+    #onEmptyPaste = null;
     /** TUI2-R3v2 ①: one-shot — a panel that just closed swallows the
      *  habitual trailing enter rather than submitting the restored draft. */
     #swallowEnter = false;
@@ -282,6 +299,12 @@ export class Editor {
      *  over while the run is told to stop. Mirrors onEscape (a list, so
      *  listeners can coexist); the line arrives already gone from the
      *  composer, exactly as a submit's does. */
+    /** REL-0152-D11: what to do when a paste arrives empty. See
+     *  #onEmptyPaste — the CLI owns the platform, the editor owns the
+     *  moment. */
+    onEmptyPaste(cb) {
+        this.#onEmptyPaste = cb;
+    }
     onRedirect(cb) {
         this.#redirectCbs.push(cb);
     }
@@ -1902,12 +1925,19 @@ export class Editor {
      * operation in this file works on it without knowing it exists.
      */
     #commitPaste() {
-        const run = this.#pasteRun ?? [];
+        let run = this.#pasteRun ?? [];
         const start = this.#pasteAt ?? this.#cursor;
         this.#pasteRun = null;
         this.#pasteAt = null;
-        if (run.length === 0)
-            return;
+        if (run.length === 0) {
+            // REL-0152-D11: an empty paste is the image case — see
+            // #onEmptyPaste. Anything it returns is ordinary text from here
+            // on and takes the same route as if it had been typed.
+            const substitute = this.#onEmptyPaste?.() ?? null;
+            if (substitute === null || substitute === "")
+                return;
+            run = [...substitute].map((ch) => ch.codePointAt(0));
+        }
         if (this.#historyIdx !== null)
             this.#historyIdx = null;
         this.#queuePopMode = false;

package/package.json

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