@vincemakes/kiso-tui 0.15.3 → 0.15.4

package/dist/ask-panel.d.ts

@@ -53,6 +53,11 @@ export interface AskStep {
     readonly state: AskRuntime;
     readonly result?: AskResult;
 }
+/** REL-0152-D4: is the cursor on the type-your-own row? The editor asks
+ *  before it decides what a printable key means — on this row a key is
+ *  the first character of an answer, everywhere else it is a shortcut.
+ *  Exported so that rule lives on ONE definition of the row. */
+export declare function askOnCustomRow(spec: AskSpec, state: AskRuntime): boolean;
 export declare function askKey(spec: AskSpec, state: AskRuntime, key: string): AskStep;
 /** The typed answer commits: it becomes THE answer for this question
  *  (clearing its picks) and the walk advances. An empty line is a

package/dist/ask-panel.js

@@ -107,6 +107,14 @@ function toggle(state, option, multi) {
  *  option, which is where `askBlockRows` draws it. Options and this row
  *  are one list to the eye, so they are one list to the cursor. */
 const customRow = (q) => q.options.length;
+/** REL-0152-D4: is the cursor on the type-your-own row? The editor asks
+ *  before it decides what a printable key means — on this row a key is
+ *  the first character of an answer, everywhere else it is a shortcut.
+ *  Exported so that rule lives on ONE definition of the row. */
+export function askOnCustomRow(spec, state) {
+    const q = spec.questions[state.qIndex];
+    return q !== undefined && state.phase === "options" && state.cursor === customRow(q);
+}
 export function askKey(spec, state, key) {
     const q = spec.questions[state.qIndex];
     const multi = q.multiSelect === true;
@@ -119,7 +127,11 @@ export function askKey(spec, state, key) {
     }
     if (key === "esc")
         return { state, result: askDeclineAll(spec) };
-    if (key === "t")
+    // `t` is the shortcut from anywhere in the list; `type` is the
+    // REL-0152-D4 gesture — the editor sends it when the cursor is
+    // already on the custom row and a printable key arrives, so the
+    // keystroke that opened the phase is also its first character.
+    if (key === "t" || key === "type")
         return { state: { ...state, phase: "custom" } };
     if (key === "left")
         return { state: state.qIndex === 0 ? state : { ...state, qIndex: state.qIndex - 1, cursor: 0 } };
@@ -202,9 +214,17 @@ export function askBlockRows(view, state, W, maxRows) {
     // look like a footnote.
     const typed = state.custom[state.qIndex];
     const onCustom = state.cursor === customRow(q);
-    body.push(`${gutter}${cutLine(typed === null || typed === undefined
-        ? `${onCustom ? p.bold : p.dim} t   type your own answer${p.reset}`
-        : `${onCustom ? p.bold : ""} t ◉ ${escapeTerminal(typed)}${p.reset}`, Math.max(1, W - 2))}`);
+    // REL-0152-D4: while the phase is OPEN the row becomes the answer's
+    // box — a faint placeholder standing where the text will land, so an
+    // empty typing phase looks like somewhere to type instead of looking
+    // like nothing happened. The placeholder is dim and the answer is
+    // not: the two can never be mistaken for each other.
+    const typingHere = state.phase === "custom";
+    body.push(`${gutter}${cutLine(typed !== null && typed !== undefined
+        ? `${onCustom || typingHere ? p.bold : ""} t ◉ ${escapeTerminal(typed)}${p.reset}`
+        : typingHere
+            ? `${p.bold} t ▸${p.reset} ${p.dim}type your answer — enter sends, esc backs out${p.reset}`
+            : `${onCustom ? p.bold : p.dim} t   type your own answer${p.reset}`, Math.max(1, W - 2))}`);
     // the bounded block: the options fold nothing and cut individually,
     // so the cap drops whole rows with the W21 notice row.
     const budget = Math.max(1, maxRows - 5);

package/dist/editor.js

@@ -21,6 +21,7 @@
  * (?2004h) unwraps and inserts its newlines LITERALLY; every newline
  * source funnels through the ONE normalizer in feed() (§3).
  */
+var _a;
 import { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // the width primitives moved to width.ts (W1, the single width
 // authority) — re-exported so the editor's public surface is unchanged.
@@ -29,7 +30,7 @@ import { palette } from "./render.js";
 import { PICK_MAX, panelOptions, saferDegradedNote, } from "./approval-panel.js";
 // KC3.5: the panel-slot dispatchers — the ask branch folded into the
 // W21 lead/rows, so this file keeps ONE panel and one key owner.
-import { askCommitCustom, askKey, askStart, panelLead } from "./ask-panel.js";
+import { askCommitCustom, askKey, askOnCustomRow, askStart, panelLead } from "./ask-panel.js";
 import { AT_VISIBLE, atFilter } from "./at-picker.js";
 // TUI2-R2 ②: the session picker — the band's THIRD occupant. Its filter
 // is the @ picker's rank aimed at the session id; the editor owns the
@@ -110,6 +111,29 @@ export class Editor {
     // user's next turn.
     #panel = null;
     #pasting = false;
+    /**
+     * REL-0152-D8 — the paste capsule.
+     *
+     * A paste large enough to break the composer's layout is held HERE
+     * and shown in the buffer as `[Pasted text #N +M lines]`. The buffer
+     * is the display; this map is the content; the line that LEAVES the
+     * editor is the content again. That ordering is the whole design —
+     * the capsule can never truncate what gets sent, because expansion
+     * happens on the way out and reads from a map the display cannot
+     * edit.
+     *
+     * A capsule the human deletes is a paste that never happened: the
+     * token is gone, the expansion finds nothing to replace, and the
+     * entry is simply never read. That is how you take a paste back.
+     *
+     * The map is per-editor and grows by one entry per large paste in a
+     * session — bounded by how many times a human can press cmd-V, and
+     * every entry is text they chose to paste and may still submit.
+     */
+    #pastes = new Map();
+    #pasteSeq = 0;
+    /** The buffer index where the in-flight paste began; null outside one. */
+    #pasteAt = null;
     /** TUI2-R3v2 ①: one-shot — a panel that just closed swallows the
      *  habitual trailing enter rather than submitting the restored draft. */
     #swallowEnter = false;
@@ -795,6 +819,22 @@ export class Editor {
                         i += 1;
                         continue;
                     }
+                    // REL-0152-D4 — on the custom row a printable key is TEXT.
+                    // The row names typing as its purpose and then swallowed
+                    // the first thing you typed; only enter or `t` opened the
+                    // phase. Now the keystroke opens it AND lands in the
+                    // buffer, so the character you meant is the character you
+                    // get. This is checked BEFORE the shortcut branch below on
+                    // purpose: on this row "3" and "t" are the start of an
+                    // answer, not a pick and not a mode key. Everywhere else
+                    // in the list they keep their fast-path meaning exactly.
+                    if (askOnCustomRow(panel.view.ask, panel.ask) && c !== undefined && c >= " " && c !== "\x7f") {
+                        this.#askStep("type");
+                        this.#insert(c.codePointAt(0));
+                        this.#onRender();
+                        i += 1;
+                        continue;
+                    }
                     if (!typing && (c === " " || (c !== undefined && c >= "1" && c <= "4") || c === "t" || c === "T")) {
                         this.#askStep(c === " " ? "space" : c === "T" ? "t" : c);
                         i += 1;
@@ -1186,10 +1226,13 @@ export class Editor {
             const n = Number(params);
             if (n === 3)
                 this.#delete();
-            else if (n === 200)
+            else if (n === 200) {
                 this.#pasting = true;
+                this.#pasteAt = this.#cursor; // REL-0152-D8: where the capsule will go
+            }
             else if (n === 201) {
                 this.#pasting = false;
+                this.#encapsulate();
                 this.#onRender();
             }
         }
@@ -1568,7 +1611,10 @@ export class Editor {
             return;
         const spec = panel.view.ask;
         const before = panel.ask.phase;
-        const step = key === "commit" ? askCommitCustom(spec, panel.ask, this.line()) : askKey(spec, panel.ask, key);
+        // REL-0152-D8: a typed ask answer is a line leaving the editor too —
+        // pasting a stack trace into "type your own answer" must send the
+        // stack trace, not the capsule that stands for it.
+        const step = key === "commit" ? askCommitCustom(spec, panel.ask, this.#expandPastes(this.line())) : askKey(spec, panel.ask, key);
         panel.ask = step.state;
         if (step.state.phase !== before) {
             this.#chars = [];
@@ -1737,6 +1783,67 @@ export class Editor {
      *  reset together (W22: a departing line ends the pop-walk, so the
      *  next esc at rest interrupts again). Shared by the submit and the
      *  redirect — the two doors a line can leave by. */
+    /**
+     * REL-0152-D8 — how big a paste has to be before it is a capsule.
+     *
+     * LINES first, because lines are what actually break the layout: the
+     * composer grows a row per line and walks up the terminal. The
+     * character bound catches the pathological one-liner, which wraps to
+     * the same screenful by another route.
+     *
+     * Below both, the paste is left exactly as it arrived. A four-line
+     * snippet is something you want to SEE in the composer, and a capsule
+     * there would be pure obstruction.
+     */
+    static #PASTE_LINES = 8;
+    static #PASTE_CHARS = 900;
+    /** The token a capsule shows as. Parsed back by the same regexp on
+     *  the way out — one definition, so the two can never drift. */
+    static #capsuleText(id, lines) {
+        return `[Pasted text #${id} +${lines} line${lines === 1 ? "" : "s"}]`;
+    }
+    static #CAPSULE = /\[Pasted text #(\d+) \+\d+ lines?\]/g;
+    /**
+     * Close an in-flight paste: if it was large, swap the pasted run out
+     * of the buffer for its capsule and keep the text.
+     *
+     * The swap is a splice at the recorded start, so a paste in the
+     * MIDDLE of a line leaves the prose on both sides of it untouched —
+     * the capsule is a character run like any other from here on, and
+     * every editing operation in this file works on it without knowing
+     * it exists.
+     */
+    #encapsulate() {
+        const start = this.#pasteAt;
+        this.#pasteAt = null;
+        if (start === null || this.#cursor <= start)
+            return;
+        const pasted = String.fromCodePoint(...this.#chars.slice(start, this.#cursor));
+        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;
+        this.#reflow();
+    }
+    /**
+     * The way out: every capsule token becomes its text again.
+     *
+     * Applied to the line the editor HANDS OVER, never to the buffer —
+     * so what the human sees stays short and what the model receives is
+     * what the human pasted. A token whose entry is missing (a stale id
+     * recalled from history after the map moved on) is left standing as
+     * literal text rather than silently becoming an empty string: a
+     * visible oddity beats a silent deletion of someone's paste.
+     */
+    #expandPastes(line) {
+        if (this.#pastes.size === 0)
+            return line;
+        return line.replace(_a.#CAPSULE, (whole, id) => this.#pastes.get(Number(id)) ?? whole);
+    }
     #takeLine() {
         const line = String.fromCodePoint(...this.#chars);
         this.#chars = [];
@@ -1850,16 +1957,21 @@ export class Editor {
             }
         }
         const line = this.#takeLine();
+        // REL-0152-D8: the capsule expands ON THE WAY OUT. The consumer
+        // gets what was pasted; the HISTORY keeps the short form, so ↑
+        // recalls a readable line that still expands when it is sent
+        // again (the map outlives the buffer, by design).
+        const sent = this.#expandPastes(line);
         const cb = this.#questionCb;
         this.#questionCb = null;
         if (cb !== null) {
-            cb(line);
+            cb(sent);
         }
         else if (this.#lineCb !== null) {
-            this.#lineCb(line);
+            this.#lineCb(sent);
         }
         else {
-            this.#pendingLines.push(line); // nobody wired yet — hold it
+            this.#pendingLines.push(sent); // nobody wired yet — hold it
         }
         if (cb === null && line !== "")
             this.#remember(line);
@@ -1949,3 +2061,4 @@ export class Editor {
         return end;
     }
 }
+_a = Editor;

package/package.json

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