@vincemakes/kiso-tui 0.16.0 → 0.16.2

package/dist/compositor.js

@@ -1473,7 +1473,11 @@ export class Body {
             // frame, and the PTY gates that wait on the boot stream feel
             // it; inside the frame it is four sequences and no new event.
             this.#needsReset = false;
-            out.push("\x1b[r\x1b[?69l\x1b[?7h\x1b[?25h");
+            // REL-0161: the reset ESTABLISHES the hidden cursor (?25l) —
+            // the steady state for the session's whole life. It repairs a
+            // killed predecessor straight into the same state. The visible
+            // cursor comes back exactly once, in editor.exit().
+            out.push("\x1b[r\x1b[?69l\x1b[?7h\x1b[?25l");
             // REL-0152-D20 — the mechanism is understood and the obvious fix
             // is NOT taken here. See the finding.
             //
@@ -1493,7 +1497,12 @@ export class Body {
             // for stdin).
         }
         out.push("\x1b[?7l");
-        out.push(this.#conservative ? "\x1b[?25l" : "\x1b[?2026h"); // D1: sync ON, or cursor-hide where 2026 is dead bytes
+        // REL-0161: ?25l is the STEADY state now, not a frame bracket —
+        // re-asserted at every frame open as self-healing (a subprocess
+        // or stray output that showed the cursor is corrected here), and
+        // never paired with a ?25h. Sync (2026) still brackets the frame
+        // where the terminal understands it.
+        out.push(this.#conservative ? "\x1b[?25l" : "\x1b[?2026h\x1b[?25l");
         // A8: the bottom-anchored window (the model's last H rows) shifts
         // DOWN when the live region SHRINKS — the done-fold, the fold-hold
         // release at the terminal event. The steady path's scroll syncs
@@ -1517,7 +1526,12 @@ export class Body {
         // with it.
         this.#drawFull(out, W, H, liveTop, liveLines, queueRows, menuRows, editor);
         this.#fullRedraw = false;
-        out.push(this.#conservative ? "\x1b[?25h" : "\x1b[?2026l");
+        // REL-0161: the frame close no longer shows the cursor — hidden IS
+        // the steady state (Terminal.app infers "a prompt line" from
+        // bracketed-paste + a visible cursor and decorates it with a Mark;
+        // the composer draws its own cursor cell instead — #inputRowBytes).
+        if (!this.#conservative)
+            out.push("\x1b[?2026l");
         out.push("\x1b[?7h"); // REL-0152-D14: autowrap back on for everything outside the frame
         this.#inFrame = true;
         try {
@@ -1902,16 +1916,47 @@ export class Body {
             markerLine += CURSOR_MARKER;
             markerCell = w;
         }
-        const stripped0 = markerLine.replace(CURSOR_MARKER, "");
         if (W < 4) {
             // the degenerate screen: the box cannot hold its walls — the
             // bare row (the pre-W6 bytes; the fold probe's pass-through
             // line still crashes invariant ① downstream, as before)
-            return { stripped: stripped0, markerCell };
+            return { stripped: markerLine.replace(CURSOR_MARKER, ""), markerCell };
+        }
+        // REL-0161 — the DRAWN cursor. The hardware cursor is hidden for
+        // the session's life (Terminal.app infers "a prompt line" from
+        // bracketed-paste + a visible cursor and Marks it), so the cell
+        // at the marker renders inverse instead. The hardware cursor
+        // still PARKS at the marker — the IME anchor is its position.
+        const mi = markerLine.indexOf(CURSOR_MARKER);
+        let stripped0;
+        let cursorPad = 0; // 1 when the drawn cursor consumed a pad cell
+        if (mi < 0) {
+            stripped0 = markerLine; // a row that does not own the cursor
+        }
+        else {
+            const before = markerLine.slice(0, mi);
+            const after = markerLine.slice(mi + CURSOR_MARKER.length);
+            if (after.length === 0) {
+                // the cursor rests past the content — an inverse space,
+                // taken OUT of the pad (the walk capped content at W−4,
+                // so the pad is ≥ 1 and the row still totals W)
+                stripped0 = `${before}\x1b[7m \x1b[27m`;
+                cursorPad = 1;
+            }
+            else if (after[0] === "\x1b" || (after.codePointAt(0) >= 0xd800 && after.codePointAt(0) <= 0xdfff)) {
+                // never wrap a sequence, never split a surrogate pair —
+                // the cell keeps its bytes, the parked cursor still marks
+                // the position for the terminal's own affordances
+                stripped0 = before + after;
+            }
+            else {
+                const glyph = String.fromCodePoint(after.codePointAt(0));
+                stripped0 = `${before}\x1b[7m${glyph}\x1b[27m${after.slice(glyph.length)}`;
+            }
         }
         // the pad completes the row to W — the content stopped at W−4,
-        // so the pad is ≥ 1
-        const padW = W - 3 - w;
+        // so the pad is ≥ 1 (≥ 0 after the drawn cursor consumed one)
+        const padW = W - 3 - w - cursorPad;
         return { stripped: `\x1b[2m│ \x1b[0m${stripped0}\x1b[2m${" ".repeat(padW)}│\x1b[0m`, markerCell };
     }
     /** KC1 §6 — the focus component's input ROWS (N = 1 today's single

package/dist/editor.js

@@ -270,6 +270,19 @@ export class Editor {
     #history = [];
     #historyIdx = null;
     #preBrowse = [];
+    // UD-1: minimal draft undo. Two stacks of FROZEN snapshots beside
+    // the one mutable buffer (the KC1 flat-buffer discipline holds —
+    // the stacks are history, never a second projection). A checkpoint
+    // is pushed only by a gesture about to discard ≥1 code point (the
+    // kills, the menu-esc clear, each queue-pop replacement, the
+    // @-apply splice); typing and single backspace push nothing — v1
+    // is loss-recovery, not char-granular edit history. ctrl+z
+    // restores text+cursor exactly; ctrl+y mirrors; undo never
+    // discards (what it replaces always lands on the redo stack).
+    // Both stacks clear on submit/clearLine — a sent turn is in the
+    // durable log and the ↑ history, not a loss.
+    #undoStack = [];
+    #redoStack = [];
     // W22: the pending-turn queue's bound state — the CLI's live slots
     // (chat.ts). ↑ pops the LAST queued message into the buffer and
     // enters the pop-mode (the walk: repeated ↑ pop older ones, each
@@ -355,6 +368,8 @@ export class Editor {
         return this.#sheetOpen;
     }
     clearLine() {
+        this.#undoStack.length = 0; // UD-1
+        this.#redoStack.length = 0;
         this.#chars = [];
         this.#cursor = 0;
         this.#scroll = 0;
@@ -577,6 +592,8 @@ export class Editor {
         if (view === null)
             return;
         const insert = [...`@${view.matches[view.selected].path} `].map((ch) => ch.codePointAt(0));
+        if (this.#cursor - view.start >= 1)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(view.start, this.#cursor - view.start, ...insert);
         this.#cursor = view.start + insert.length;
         this.#atClose();
@@ -748,6 +765,12 @@ export class Editor {
         process.stdout.write(MOUSE_OFF);
         this.#mouseOn = false;
         process.stdout.write("\x1b[?2004l"); // bracketed paste OFF
+        // REL-0161: the hardware cursor was hidden for the session's whole
+        // life (the compositor's entry reset); this is the one place kiso
+        // hands the terminal back. kill -9 skips it — the same exposure
+        // the reference implementation accepts; the entry repair covers
+        // the next kiso, and `reset` covers the shell.
+        process.stdout.write("\x1b[?25h");
         process.stdin.setRawMode(false);
         this.#closedResolve();
     }
@@ -1096,6 +1119,8 @@ export class Editor {
                     // v3 §04: Esc closes the menu and clears the buffer.
                     // CA-4: the closing esc consumes its burst (the `i += 1`
                     // convention) — a double-esc can never abort the turn.
+                    if (this.#chars.length > 0)
+                        this.#checkpoint(); // UD-1
                     this.#chars = [];
                     this.#cursor = 0;
                     this.#scroll = 0;
@@ -1195,6 +1220,14 @@ export class Editor {
                 this.#killWord();
                 i += 1;
             }
+            else if (c === "\x1a" || c === "\x1f") {
+                this.#undoOp(); // UD-1: ctrl+z (and the readline ctrl+_)
+                i += 1;
+            }
+            else if (c === "\x19") {
+                this.#redoOp(); // UD-1: ctrl+y
+                i += 1;
+            }
             else if (c === "\x01") {
                 this.#cursor = this.#cursorBounds().start; // A3: line-local (a single line starts at 0 — unchanged)
                 this.#reflow();
@@ -1885,8 +1918,66 @@ export class Editor {
         if (!this.#pasting)
             this.#onRender();
     }
+    // ---- UD-1: the undo machinery ----
+    /** The caps: entries and total code points (a D13-class 260KB paste
+     *  fits with room). Evict oldest; both stacks share the shape. */
+    static #UNDO_CAP = 64;
+    static #UNDO_CP_CAP = 2 * 1024 * 1024;
+    #snap() {
+        return { chars: [...this.#chars], cursor: this.#cursor };
+    }
+    #sameSnap(a, b) {
+        return a.cursor === b.cursor && a.chars.length === b.chars.length && a.chars.every((c, i) => c === b.chars[i]);
+    }
+    #capStack(stack) {
+        while (stack.length > _a.#UNDO_CAP)
+            stack.shift();
+        let total = stack.reduce((n, s) => n + s.chars.length, 0);
+        while (stack.length > 1 && total > _a.#UNDO_CP_CAP)
+            total -= stack.shift().chars.length;
+    }
+    /** Push the CURRENT state before a destructive gesture. Always
+     *  clears the redo stack (a new destruction forks history); the
+     *  push itself is deduped against the top. */
+    #checkpoint() {
+        this.#redoStack.length = 0;
+        const cur = this.#snap();
+        const top = this.#undoStack.at(-1);
+        if (top !== undefined && this.#sameSnap(top, cur))
+            return;
+        this.#undoStack.push(cur);
+        this.#capStack(this.#undoStack);
+    }
+    #restoreSnap(s) {
+        this.#chars = [...s.chars];
+        this.#cursor = s.cursor;
+        this.#scroll = 0;
+        this.#verticalGoalCol = null;
+        this.#reflow();
+        this.#refreshMenu();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #undoOp() {
+        const prev = this.#undoStack.pop();
+        if (prev === undefined)
+            return;
+        this.#redoStack.push(this.#snap());
+        this.#capStack(this.#redoStack);
+        this.#restoreSnap(prev);
+    }
+    #redoOp() {
+        const next = this.#redoStack.pop();
+        if (next === undefined)
+            return;
+        this.#undoStack.push(this.#snap());
+        this.#capStack(this.#undoStack);
+        this.#restoreSnap(next);
+    }
     #killToStart() {
         const { start } = this.#cursorBounds(); // A3: line-local (0 on a single line — unchanged)
+        if (this.#cursor > start)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(start, this.#cursor - start);
         this.#cursor = start;
         this.#reflow();
@@ -1895,6 +1986,8 @@ export class Editor {
     }
     #killToEnd() {
         const { end } = this.#cursorBounds(); // A3: line-local (the buffer's end on a single line — unchanged)
+        if (end > this.#cursor)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(this.#cursor, end - this.#cursor);
         this.#reflow();
         if (!this.#pasting)
@@ -1909,6 +2002,8 @@ export class Editor {
             i -= 1; // trailing spaces
         while (i > 0 && this.#chars[i - 1] !== 0x20)
             i -= 1; // the word
+        if (i < this.#cursor)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(i, this.#cursor - i);
         this.#cursor = i;
         this.#reflow();
@@ -2023,6 +2118,8 @@ export class Editor {
     }
     #takeLine() {
         const line = String.fromCodePoint(...this.#chars);
+        this.#undoStack.length = 0; // UD-1: a sent turn is not a loss
+        this.#redoStack.length = 0;
         this.#chars = [];
         this.#cursor = 0;
         this.#scroll = 0;
@@ -2190,6 +2287,8 @@ export class Editor {
         const line = this.#queuePop();
         if (line === null)
             return;
+        if (this.#chars.length > 0)
+            this.#checkpoint(); // UD-1: a mid-walk edit is recoverable
         this.#chars = [...line].map((ch) => ch.codePointAt(0));
         this.#cursor = this.#chars.length;
         this.#scroll = 0;

package/package.json

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