@vincemakes/kiso-tui 0.32.0 → 0.32.2

package/dist/compositor.js

@@ -57,6 +57,7 @@ import { atPanelRows, bandHeader } from "./at-picker.js";
 import { sessionPickerRows } from "./session-picker.js";
 import { CAP_PREVIEW, thinkingRow, Container, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, gutterCut, cutLine, pendingQueueRows, statusLine, visibleWidth, breathFrame, } from "./components.js";
 import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary } from "./lines.js";
+import { oneRow } from "@vincemakes/kiso-tui-cells/render";
 import { displayVerb, keysSheetRows } from "./strings.js";
 /** DC-56: does a rendered row carry any visible text once its SGR is
  *  stripped? A washed pad row is spaces under a background colour — width
@@ -2638,6 +2639,8 @@ export class Body {
      *  CRASH with the diagnostic, never a silent truncate. */
     /** DC-48 — the field cut is announced ONCE per session. */
     #cutOnce = false;
+    /** HF-1: the ①b notice, once per session (the same discipline as #cutOnce). */
+    #breakOnce = false;
     #checked(line, W) {
         // Invariant ①b (R3f): a ROW IS ONE PHYSICAL ROW.
         //
@@ -2663,7 +2666,23 @@ export class Body {
         // (it moves the cursor to column 1).
         const bad = /[\n\r]/.exec(line);
         if (bad !== null) {
-            throw new Error(`kiso-tui invariant ①b violated: a row containing ${JSON.stringify(bad[0])} was about to be emitted — a row must be ONE physical row, and the width check cannot see this (charWidth counts a newline as one cell) — ${JSON.stringify(line.slice(0, 80))}`);
+            // HF-1 (0.32.1): the SAME ruling as the width half below. This
+            // threw in the field on a heredoc shell command (the running
+            // card's head carried the model's newlines) and the owner's
+            // session died with it. Under test the crash keeps its teeth;
+            // in the field the break is projected to ⏎ — the row goes out
+            // as one row — and a notice says so once. The builders project
+            // first (tui-cells `oneRow`), so this branch is the net under
+            // the net: a builder nobody has found yet costs a mark, not a
+            // session.
+            const why = `kiso-tui invariant ①b violated: a row containing ${JSON.stringify(bad[0])} was about to be emitted — a row must be ONE physical row, and the width check cannot see this (charWidth counts a newline as one cell) — ${JSON.stringify(line.slice(0, 80))}`;
+            if (process.env.KISO_INVARIANTS === "throw")
+                throw new Error(why);
+            if (!this.#breakOnce) {
+                this.#breakOnce = true;
+                queueMicrotask(() => this.notice("kiso-tui: a row carried a line break and was shown as one row (invariant ①b) · please report"));
+            }
+            line = oneRow(line);
         }
         const w = visibleWidth(line);
         if (w > W) {

package/dist/editor.js

@@ -1107,6 +1107,37 @@ export class Editor {
                     continue;
                 }
             }
+            // DC-62 — ONE RULE, at the top of the chain: inside a paste a
+            // control byte is CONTENT OR NOTHING, never a gesture.
+            //
+            // DC-58 guarded three branches (0x07, 0x14, 0x0f) and stated the
+            // rule generally; the rule was right and the placement was not.
+            // Every other claimed control byte still ran: a pasted backspace
+            // ate the text typed BEFORE the paste, a pasted 0x15 emptied the
+            // buffer, a pasted 0x1a rewound it — and a pasted 0x03 or 0x04
+            // fired the exit callbacks, so a paste could end the session.
+            // `#insert` only COLLECTS what reaches it, so none of these ever
+            // reached the collection; they acted instead.
+            //
+            // Nothing rather than content, because that is what the chain
+            // already does with an UNCLAIMED control byte (`c < " "` discards
+            // it), and a paste should not be the one place where 0x15 becomes
+            // visible text. Three bytes are let through to branches that
+            // already know about `#pasting` and treat them as content: CR and
+            // LF become a newline, TAB stays a tab (DC-55). ESC is let
+            // through because the parser must still see `ESC[201~` to END the
+            // paste — swallow that and the editor never leaves paste mode.
+            //
+            // The three DC-58 guards are retired into this: one rule, not
+            // twelve, and the next control byte someone claims is covered
+            // without anyone remembering to guard it.
+            if (this.#pasting && c !== undefined && c !== "\x1b" && c !== "\x0d" && c !== "\x0a" && c !== "\t") {
+                const code = c.codePointAt(0);
+                if (code < 0x20 || code === 0x7f) {
+                    i += 1;
+                    continue;
+                }
+            }
             if (this.#panelInput.up()) {
                 // S5: the panel answers PARSED keys — a bare Esc, an Enter, a
                 // Tab, a character — and says how many bytes it took, or null
@@ -1172,6 +1203,19 @@ export class Editor {
                         i += seqLen; // intermediates: a report kiso did not ask for — skipped whole
                         continue;
                     }
+                    // DC-62b: inside a paste the ONLY ESC-led gesture is the paste
+                    // end. DC-62's rule passes ESC through so the parser can still
+                    // see `ESC[201~`, and everything else ESC-led rode through with
+                    // it: a pasted `ESC[3~` forward-deleted the text after the
+                    // cursor. A complete CSI that is not the paste end is skipped
+                    // WHOLE — neither content nor gesture, the same answer the C0
+                    // rule gives. The incomplete case above is untouched: a CSI
+                    // split across two feeds still parks, or a paste arriving in
+                    // pieces would lose its end.
+                    if (this.#pasting && !(m[1] === "201" && m[3] === "~")) {
+                        i += seqLen;
+                        continue;
+                    }
                     // TMUX-F1 ②: a BURST of identical arrows in ONE read is a wheel,
                     // not a hand. Apple Terminal turns wheel and trackpad scrolling
                     // into arrow keys for an alternate-screen app (tmux's client is
@@ -1211,9 +1255,74 @@ export class Editor {
                         this.#pending = tail; // incomplete OSC — wait for more
                         break;
                     }
-                    this.#oscCb?.(rest.slice(1, end.index));
+                    // DC-62b: a pasted OSC is not a terminal report. A shell's
+                    // PROMPT_COMMAND writes `ESC]0;title BEL` on every prompt, so
+                    // it is in any captured log a human might paste — and it was
+                    // reaching the ground-probe reply handler, which is DC-7's
+                    // rule inverted: kiso must not read the human's data as the
+                    // terminal's answer either. Skipped to its terminator.
+                    if (!this.#pasting)
+                        this.#oscCb?.(rest.slice(1, end.index));
                     i += 1 + end.index + end[0].length;
                 }
+                else if (this.#pasting && rest === "") {
+                    // DC-62c: a lone trailing ESC inside a paste is HELD, not
+                    // consumed — parked in `#pending` the way an incomplete CSI
+                    // parks, so the next feed resolves it.
+                    //
+                    // Measured: with the paste-end marker split immediately after
+                    // its ESC byte (the chunk ends on the bare ESC, the next
+                    // begins `[201~`), the marker was missed, `#pasting` never
+                    // cleared, and THE COMPOSER WENT DEAF — every later keystroke
+                    // collected, nothing on screen, until some intact `ESC[201~`
+                    // arrived and flushed the lot. The TMUX-F1 shape, and it
+                    // predates DC-62b: byte-identical on the editor before it.
+                    //
+                    // The hold is free HERE and nowhere else. CA-4 rules that a
+                    // bare Esc fires at once rather than waiting for a possible
+                    // CSI, because its immediacy is what a hold would spend — esc
+                    // interrupts a run. Inside a paste, after DC-62b, a bare ESC
+                    // already does nothing at all, so there is no promptness to
+                    // spend and nothing to protect. Outside a paste CA-4 is
+                    // untouched, and a gate pins that so this is not widened.
+                    //
+                    // KNOWN RESIDUAL, the mirror at the paste START: a lone
+                    // trailing ESC OUTSIDE a paste followed by `[200~body` in the
+                    // next chunk fires the bare esc, and the body arrives as
+                    // keystrokes, control bytes and all. That one cannot be fixed
+                    // without holding the ESC exactly where CA-4 says not to, so
+                    // it stays — same rarity argument, a terminal writes each
+                    // marker in one write. A real log showing it makes it a
+                    // finding of its own.
+                    this.#pending = text.slice(i);
+                    break;
+                }
+                else if (this.#pasting) {
+                    // DC-62b: inside a paste, the CSI arm above has already let
+                    // `ESC[201~` through and skipped every other complete CSI, and
+                    // the OSC arm has skipped its report. Everything ESC-led that
+                    // reaches here is a gesture the human did not make: a bare ESC
+                    // fires the escape callbacks (interrupting a running turn), a
+                    // double ESC is the redirect, and `ESC(B` — a charset reset,
+                    // in any captured terminal log — took the same road.
+                    //
+                    // ONE BYTE: the ESC is nothing and what follows is content.
+                    //
+                    // Not because the rest cannot be parsed — an ECMA-48 nF
+                    // escape is deterministic (ESC, intermediates 0x20–0x2F, one
+                    // final 0x30–0x7E), so `ESC(B` and `ESC=` COULD be consumed
+                    // whole. The reason is smaller and still enough: beside CSI
+                    // and OSC these forms are rare in pasted logs, the C0 rule
+                    // already gives the shape "nothing, not content", and the two
+                    // failure modes are not equal — `(B` left visible is
+                    // recoverable by the human, text eaten by a misread is not.
+                    //
+                    // KNOWN RESIDUAL: a pasted nF escape leaves its intermediates
+                    // and its final as text. Named here rather than implied,
+                    // because the next reader deserves the cost and not only the
+                    // choice.
+                    i += 1;
+                }
                 else if (rest.startsWith("O")) {
                     i += 3; // SS3 (function keys) — ignored
                 }
@@ -1411,6 +1520,11 @@ export class Editor {
                 if (file !== null && file !== "") {
                     // REL-0152-D16: the capsule goes in the buffer, the file
                     // goes beside it. See #attachments.
+                    //
+                    // DC-61: and it is an archive point, for the same reason
+                    // the bracketed-paste path is — this inserts a token the
+                    // human did not type, so one ctrl+z has to take it back.
+                    this.#checkpoint();
                     this.#attachSeq += 1;
                     this.#attachments.set(this.#attachSeq, file);
                     for (const ch of `[Image #${this.#attachSeq}]`)
@@ -1420,6 +1534,21 @@ export class Editor {
                 i += 1;
             }
             else if (c === "\x0f") {
+                // DC-58 (0.32.1) guarded THIS branch and the two below with
+                // `!#pasting`, the guard tab and CR already had: unguarded, a
+                // pasted BEL opened $VISUAL mid-paste and the rest of the body
+                // went to that child's stdin — DC-7's rule from the third side (a
+                // byte from a paste is data the human handed over, as a reply's
+                // byte is the terminal's).
+                //
+                // DC-62 (0.32.2) RETIRED those three guards into one rule at the
+                // top of the byte loop, because the same question asked of every
+                // other branch found the same answer: a pasted backspace ate the
+                // text typed before the paste, and a pasted 0x03 fired the exit
+                // callback. There is no per-branch guard here any more — look at
+                // the top of the loop, not at this line, for why a control byte
+                // inside a paste reaches nothing.
+                //
                 // W15: the expand key — rides the chain like a command, the
                 // editor just forwards it.
                 //
@@ -2137,6 +2266,19 @@ export class Editor {
         if (this.#historyIdx !== null)
             this.#historyIdx = null;
         this.#queuePopMode = false;
+        // DC-61: a paste is an ARCHIVE POINT. UD-1's invariant was written
+        // around destructive gestures — no gesture may discard more than one
+        // code point without a checkpoint — and a paste discards nothing, so
+        // it never took one. The loss arrived from the other side: ctrl+z
+        // after a paste did nothing, or reached an OLDER checkpoint and threw
+        // away the paste plus everything typed since it in one press.
+        //
+        // It sits here, after the image branch has either returned or filled
+        // `run`, so both shapes are covered by one call and the
+        // nothing-happened case (an empty paste with no clipboard image)
+        // still takes no checkpoint — a phantom entry would make ctrl+z a
+        // press the human has to repeat.
+        this.#checkpoint();
         const pasted = _a.#textOf(run);
         const lines = pasted.split("\n").length;
         const small = lines < _a.#PASTE_LINES && run.length < _a.#PASTE_CHARS;

package/dist/lines.js

@@ -13,7 +13,7 @@
  * the event renderers (renderEvent, the status line, the recap, the
  * session line).
  */
-import { escapeTerminal, foldResult, foldThinking, kUnit, palette } from "@vincemakes/kiso-tui-cells/render";
+import { echoText, escapeTerminal, foldResult, foldThinking, kUnit, palette } from "@vincemakes/kiso-tui-cells/render";
 import { foldTerms, widthCut } from "@vincemakes/kiso-tui-cells/components";
 import { visibleWidth } from "@vincemakes/kiso-tui-cells/width";
 export * from "@vincemakes/kiso-tui-cells/render";
@@ -60,7 +60,7 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
         case "tool_execution_failed":
             return { text: `${p.red}  failed: ${escapeTerminal(ev.error.slice(0, 160))}${p.reset}\n`, newline: true, prompt: false };
         case "tool_result": {
-            const content = typeof ev.content === "string" ? ev.content : ev.content.map((b) => (b.type === "text" ? b.text : "(image)")).join("");
+            const content = echoText(ev.content); // DC-60: one projection, shared with the live echo
             return {
                 // v2b: the echo truncates at 160 chars + a /last hint — the
                 // full content stays in the event stream.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.32.0",
+	"version": "0.32.2",
 	"description": "kiso tui — 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.32.0"
+		"@vincemakes/kiso-tui-cells": "0.32.2"
 	}
 }