@code-yeongyu/senpi-tui 2026.11.5-1 → 2026.11.6-2

package/dist/keys.js

@@ -905,8 +905,10 @@ export function matchesKey(data, keyId) {
             if (data === `\x1b${rawCtrl}`)
                 return true;
         }
-        if (modifier === MODIFIERS.alt && !_kittyProtocolActive && (isLetter || isDigit || SYMBOL_KEYS.has(key))) {
-            // Legacy: alt+printable key is ESC followed by the key
+        if (modifier === MODIFIERS.alt && (isLetter || isDigit || SYMBOL_KEYS.has(key))) {
+            // Legacy: alt+printable key is ESC followed by the key. Accepted with Kitty active too: a
+            // conforming Kitty terminal sends Escape as CSI 27 u, and under ConPTY the reply comes from the
+            // outer terminal while the console host still encodes Alt as ESC <key> (#6058).
             if (data === `\x1b${key}`)
                 return true;
         }
@@ -1057,9 +1059,9 @@ export function parseKey(data) {
         return "alt+left";
     if (!_kittyProtocolActive && data === "\x1bF")
         return "alt+right";
-    if (!_kittyProtocolActive && data.length === 2 && data[0] === "\x1b") {
+    if (data.length === 2 && data[0] === "\x1b") {
         const code = data.charCodeAt(1);
-        if (code >= 1 && code <= 26) {
+        if (!_kittyProtocolActive && code >= 1 && code <= 26) {
             return `ctrl+alt+${String.fromCharCode(code + 96)}`;
         }
         // Legacy alt+letter/digit/symbol (ESC followed by the key)

package/dist/stdin-buffer.d.ts

@@ -62,8 +62,10 @@ export declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
     private readonly clock;
     private lastInputAt;
     private heldNewline;
-    private heldNewlineEndsPaste;
+    private heldNewlineKind;
     private lastBurstPasteAt;
+    /** True when the last burst paste's own line breaks were bare CR (an unbracketed paste from xterm/VTE/iTerm2). */
+    private lastBurstPasteUsesCrLineBreaks;
     private burstTimer;
     constructor(options?: StdinBufferOptions);
     process(data: string | Buffer): void;

package/dist/stdin-buffer.js

@@ -246,7 +246,9 @@ export class StdinBuffer extends EventEmitter {
         this.pasteBuffer = "";
         this.decoder = new StringDecoder("utf8");
         this.heldNewline = "";
-        this.heldNewlineEndsPaste = false;
+        this.heldNewlineKind = "keystroke";
+        /** True when the last burst paste's own line breaks were bare CR (an unbracketed paste from xterm/VTE/iTerm2). */
+        this.lastBurstPasteUsesCrLineBreaks = false;
         this.burstTimer = null;
         this.timeoutMs = options.timeout ?? DEFAULT_SEQUENCE_TIMEOUT_MS;
         this.escapeTimeoutMs = options.escapeTimeout ?? DEFAULT_ESCAPE_TIMEOUT_MS;
@@ -316,10 +318,15 @@ export class StdinBuffer extends EventEmitter {
             if (burstGap !== undefined && burstGap >= this.burstWindowMs) {
                 this.releaseHeldNewline();
             }
+            else if (this.heldNewlineKind === "enter" && !this.buffer.startsWith("\n")) {
+                // A held Enter only continues into the LF half of a CRLF pair; any other read means the submit
+                // stands, so the Enter lands before that read is framed.
+                this.releaseHeldNewline();
+            }
             else {
                 this.buffer = this.heldNewline + this.buffer;
                 this.heldNewline = "";
-                this.heldNewlineEndsPaste = false;
+                this.heldNewlineKind = "keystroke";
             }
         }
         if (this.pasteMode) {
@@ -404,15 +411,28 @@ export class StdinBuffer extends EventEmitter {
         if (breaks === 0) {
             return false;
         }
+        const trailing = text.match(TRAILING_LINE_BREAK_RUN)?.[0];
+        const trailingEndsWithCr = trailing !== undefined && trailing.endsWith("\r");
+        // An unbracketed paste from a terminal that turns pasted newlines into bare CR (xterm, VTE, iTerm2) carries
+        // no LF at all, so its own trailing CR closes that paste. Only a burst whose breaks include LF or CRLF can
+        // end in the Enter key that submits it; anything else would submit a human's CR-only paste.
+        const crOnlyPasteBurst = trailingEndsWithCr && !text.includes("\n") && /[^\r\n]/.test(text);
         // Typing delivers one key per read, so a single read that holds two line breaks, or text after a
         // line break, is pasted. Both carry text: a run of bare Enters stays keystrokes.
         if ((breaks >= 2 || LINE_BREAK_BEFORE_TEXT.test(text)) && /[^\r\n]/.test(text)) {
+            const endsWithEnter = trailingEndsWithCr && !crOnlyPasteBurst;
+            const body = endsWithEnter ? text.slice(0, -1) : text;
             this.buffer = "";
             this.lastBurstPasteAt = this.lastInputAt;
-            this.emit("paste", text);
+            this.lastBurstPasteUsesCrLineBreaks = !body.includes("\n");
+            this.emit("paste", body);
+            if (endsWithEnter) {
+                // The paste is committed first, so the Enter that trails it submits the block after it. It waits out
+                // the window only because a CRLF split across reads still belongs to its paste.
+                this.holdTrailingNewline("\r", "enter");
+            }
             return true;
         }
-        const trailing = text.match(TRAILING_LINE_BREAK_RUN)?.[0];
         if (trailing === undefined || burstGap === undefined || burstGap >= this.burstWindowMs) {
             return false;
         }
@@ -422,20 +442,23 @@ export class StdinBuffer extends EventEmitter {
         const endsPaste = this.lastBurstPasteAt !== undefined &&
             this.lastInputAt !== undefined &&
             this.lastInputAt - this.lastBurstPasteAt < this.burstWindowMs;
-        // A read of bare line breaks is a keystroke unless it closes a paste, so it is forwarded at once.
-        if (head.length === 0 && !endsPaste) {
+        // A CR closing a burst whose own breaks were bare CR continues that paste, exactly as the same text in one
+        // read keeps it; after an LF/CRLF paste it is the Enter key the sender pressed.
+        const crContinuesPaste = endsPaste && this.lastBurstPasteUsesCrLineBreaks;
+        // A read of bare line breaks is a keystroke unless it closes a paste, and a submit is never held back.
+        if ((trailingEndsWithCr && !crContinuesPaste) || (head.length === 0 && !endsPaste)) {
             return false;
         }
         for (const chunk of head) {
             this.emitDataSequence(chunk);
         }
         this.buffer = "";
-        this.holdTrailingNewline(trailing, endsPaste);
+        this.holdTrailingNewline(trailing, endsPaste ? "paste" : "keystroke");
         return true;
     }
-    holdTrailingNewline(run, endsPaste) {
+    holdTrailingNewline(run, kind) {
         this.heldNewline = run;
-        this.heldNewlineEndsPaste = endsPaste;
+        this.heldNewlineKind = kind;
         if (this.burstTimer) {
             clearTimeout(this.burstTimer);
         }
@@ -449,10 +472,10 @@ export class StdinBuffer extends EventEmitter {
             return;
         }
         const held = this.heldNewline;
-        const endsPaste = this.heldNewlineEndsPaste;
+        const kind = this.heldNewlineKind;
         this.heldNewline = "";
-        this.heldNewlineEndsPaste = false;
-        if (endsPaste) {
+        this.heldNewlineKind = "keystroke";
+        if (kind === "paste") {
             this.emit("paste", held);
             return;
         }
@@ -509,8 +532,9 @@ export class StdinBuffer extends EventEmitter {
             this.burstTimer = null;
         }
         this.heldNewline = "";
-        this.heldNewlineEndsPaste = false;
+        this.heldNewlineKind = "keystroke";
         this.lastBurstPasteAt = undefined;
+        this.lastBurstPasteUsesCrLineBreaks = false;
         this.buffer = "";
         this.pasteMode = false;
         this.pasteBuffer = "";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-tui",
-	"version": "2026.11.5-1",
+	"version": "2026.11.6-2",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",