@vincemakes/kiso-tui 0.15.8 → 0.15.9

package/dist/compositor.js

@@ -867,7 +867,7 @@ export class Body {
         if (process.stdout.isTTY !== true || palette().bold === "" || rows < 4)
             return;
         this.#docked = true;
-        this.#guardStdout();
+        this.#guardOutput();
         this.#attachResize();
         this.#fullRedraw = true;
         this.#dirty = true;
@@ -936,26 +936,56 @@ export class Body {
      * change, and the cursor parks on the wrong row. Three PTY gates
      * caught it.
      *
-     * The fix is not a list of writers to remember. stdout is wrapped
-     * while the dock is up: anything written that is not this frame's own
-     * bytes forgets the screen, and the next frame repaints. New callers
-     * cannot get it wrong because they are not asked to get it right.
+     * REL-0152-D17: BOTH descriptors, and the second one is the one that
+     * mattered. The first version of this guard wrapped stdout alone,
+     * while kiso's degradation notices go to stderr through
+     * `console.error` — and several of them BEGIN with `[` and contain
+     * `]`:
+     *
+     *     [extensions] …        [project .kiso] …
+     *     [KISO_FAUX_SCRIPT] …  [run failed] …
+     *
+     * Those land on the tty wherever the cursor is, and a renderer that
+     * does not know they were printed skips exactly the rows that would
+     * repair them. The residue survives on the rows whose desired content
+     * NEVER changes — the composer box's own edges — which is a stray `[`
+     * at the left and `]` at the right for the rest of the session,
+     * clearing only on a resize and returning on the next launch.
+     *
+     * The reasoning that missed it was mine, and it is worth keeping: the
+     * renderer emits no OSC and no bare `]`, so a `]` on screen CANNOT
+     * have come from its stream. I had that fact and concluded "therefore
+     * the terminal invents it" when the only sound conclusion is
+     * "therefore something else wrote it".
+     *
+     * The fix is not a list of writers to remember, and not silencing the
+     * loggers. A compositor cannot hold a belief about a terminal it does
+     * not own: any write it did not make forgets the screen, whichever
+     * descriptor carried it. New callers cannot get it wrong because they
+     * are not asked to get it right.
      */
-    #guardStdout() {
+    #guardOutput() {
         if (this.#unguard !== null || this.#opts.write !== undefined)
             return;
-        const real = process.stdout.write.bind(process.stdout);
-        const patched = ((chunk, ...rest) => {
-            if (!this.#inFrame)
-                this.#screen = [];
-            return real(chunk, ...rest);
-        });
-        process.stdout.write = patched;
+        const restores = [];
+        for (const stream of [process.stdout, process.stderr]) {
+            const real = stream.write.bind(stream);
+            const patched = ((chunk, ...rest) => {
+                if (!this.#inFrame)
+                    this.#screen = [];
+                return real(chunk, ...rest);
+            });
+            stream.write = patched;
+            restores.push(() => {
+                // only restore what we installed — another wrapper may have
+                // been layered on top since (the byte trace does exactly that)
+                if (stream.write === patched)
+                    stream.write = real;
+            });
+        }
         this.#unguard = () => {
-            // only restore what we installed — another wrapper may have
-            // been layered on top since (the byte trace does exactly that)
-            if (process.stdout.write === patched)
-                process.stdout.write = real;
+            for (const r of restores)
+                r();
             this.#unguard = null;
         };
     }

package/dist/editor.d.ts

@@ -72,6 +72,10 @@ export declare class Editor {
      *  human asks for them — ctrl+V, or an empty paste. The CLI owns the
      *  platform, the editor owns the moment. */
     onClipboardPaste(cb: () => string | null): void;
+    /** REL-0152-D16: the files this line's `[Image #N]` capsules stand
+     *  for, by their number. The CLI resolves them when it builds the
+     *  turn; a capsule the human deleted is simply never looked up. */
+    attachments(): Map<number, string>;
     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

@@ -131,6 +131,24 @@ export class Editor {
      * every entry is text they chose to paste and may still submit.
      */
     #pastes = new Map();
+    /**
+     * REL-0152-D16 — which file each `[Image #N]` capsule stands for.
+     *
+     * D15 made ctrl+V fetch the clipboard and it worked; then it inserted
+     * the PATH, the path began with `/`, and the composer handed it to
+     * the slash-command dispatcher. A feature that reaches the last step
+     * and gives the result to the wrong parser has not shipped.
+     *
+     * So the buffer carries a token and this carries the file. The token
+     * is what the LINE is — the dispatcher sees `[Image #1]`, which is
+     * not a command and never could be — and the CLI reads this map when
+     * it builds the turn. Unlike the text capsule, the image is NOT
+     * expanded into the line on the way out: a path is not something the
+     * model should be sent, and a transcript full of temp-file names is
+     * not something the human should have to read.
+     */
+    #attachments = new Map();
+    #attachSeq = 0;
     #pasteSeq = 0;
     /** The buffer index where the in-flight paste began; null outside one. */
     #pasteAt = null;
@@ -311,6 +329,12 @@ export class Editor {
     onClipboardPaste(cb) {
         this.#onClipboardPaste = cb;
     }
+    /** REL-0152-D16: the files this line's `[Image #N]` capsules stand
+     *  for, by their number. The CLI resolves them when it builds the
+     *  turn; a capsule the human deleted is simply never looked up. */
+    attachments() {
+        return new Map(this.#attachments);
+    }
     onRedirect(cb) {
         this.#redirectCbs.push(cb);
     }
@@ -1205,9 +1229,13 @@ export class Editor {
                 // REL-0152-D15: ctrl+V asks for the clipboard. Inert with no
                 // hook wired, and 0x16 must NEVER reach the buffer — an
                 // unhandled control byte in a prompt is a corrupt prompt.
-                const text = this.#onClipboardPaste?.() ?? null;
-                if (text !== null && text !== "") {
-                    for (const ch of text)
+                const file = this.#onClipboardPaste?.() ?? null;
+                if (file !== null && file !== "") {
+                    // REL-0152-D16: the capsule goes in the buffer, the file
+                    // goes beside it. See #attachments.
+                    this.#attachSeq += 1;
+                    this.#attachments.set(this.#attachSeq, file);
+                    for (const ch of `[Image #${this.#attachSeq}]`)
                         this.#insert(ch.codePointAt(0));
                     this.#onRender();
                 }
@@ -1951,10 +1979,12 @@ export class Editor {
             // 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.#onClipboardPaste?.() ?? null;
-            if (substitute === null || substitute === "")
+            const file = this.#onClipboardPaste?.() ?? null;
+            if (file === null || file === "")
                 return;
-            run = [...substitute].map((ch) => ch.codePointAt(0));
+            this.#attachSeq += 1;
+            this.#attachments.set(this.#attachSeq, file);
+            run = [...`[Image #${this.#attachSeq}]`].map((ch) => ch.codePointAt(0));
         }
         if (this.#historyIdx !== null)
             this.#historyIdx = null;

package/package.json

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