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

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-1",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",