@deepseek-harness-tui/dsh-tui 0.6.1 → 0.7.0

package/lib/types/ink/input-suppression.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Input suppression window for terminal handoffs (issue #123): when stdin is
+ * handed to an external TUI (full-screen editor) and back, the tty can
+ * deliver a burst of bytes that are NOT user keystrokes — the editor's
+ * rmcup/mode-restore replies, CPR/DECRPM query responses, mouse-event
+ * fragments, or keystrokes typed into the canonical line buffer while raw
+ * mode was off. Parsed as input they are destructive: a stray ESC reads as
+ * the escape key (which CLEARS a non-empty prompt) and the rest lands as
+ * text garbage.
+ *
+ * resumeStdin() drains what is already buffered; this module covers what
+ * arrives LATE (terminal replies are async). use-input checks the window at
+ * the single choke point every component's input flows through, so no
+ * listener (Chat's ctrl+c/esc handling included) sees the burst.
+ */
+/** Suppress all parsed input for `ms` from now (monotonic extension). */
+export declare function suppressInputFor(ms: number): void;
+/** True while the post-handoff suppression window is open. */
+export declare function isInputSuppressed(): boolean;
+//# sourceMappingURL=input-suppression.d.ts.map

package/lib/types/ink/input-suppression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-suppression.d.ts","sourceRoot":"","sources":["../../../src/ink/input-suppression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAGjD;AAED,8DAA8D;AAC9D,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C"}

package/lib/types/ink/input-suppression.js

@@ -0,0 +1,26 @@
+/**
+ * Input suppression window for terminal handoffs (issue #123): when stdin is
+ * handed to an external TUI (full-screen editor) and back, the tty can
+ * deliver a burst of bytes that are NOT user keystrokes — the editor's
+ * rmcup/mode-restore replies, CPR/DECRPM query responses, mouse-event
+ * fragments, or keystrokes typed into the canonical line buffer while raw
+ * mode was off. Parsed as input they are destructive: a stray ESC reads as
+ * the escape key (which CLEARS a non-empty prompt) and the rest lands as
+ * text garbage.
+ *
+ * resumeStdin() drains what is already buffered; this module covers what
+ * arrives LATE (terminal replies are async). use-input checks the window at
+ * the single choke point every component's input flows through, so no
+ * listener (Chat's ctrl+c/esc handling included) sees the burst.
+ */
+let suppressedUntil = 0;
+/** Suppress all parsed input for `ms` from now (monotonic extension). */
+export function suppressInputFor(ms) {
+    const until = Date.now() + ms;
+    if (until > suppressedUntil)
+        suppressedUntil = until;
+}
+/** True while the post-handoff suppression window is open. */
+export function isInputSuppressed() {
+    return Date.now() < suppressedUntil;
+}

package/lib/types/ink/log-update.js

@@ -452,9 +452,27 @@ function readLine(screen, y) {
     return line.trimEnd();
 }
 function fullResetSequence_CAUSES_FLICKER(frame, reason, stylePool, debug) {
-    // After clearTerminal, cursor is at (0, 0)
-    const screen = new VirtualScreen({ x: 0, y: 0 }, frame.viewport.width);
-    renderFrame(screen, frame, stylePool);
+    // After clearTerminal the viewport is blank and the cursor is at (0, 0), so
+    // this paints downward from the top — and therefore must paint only what
+    // fits. Every row here ends in CR+LF, the bottom viewport row is reserved
+    // for the cursor park, and so at most viewportHeight-1 rows of content can
+    // land above it. Painting the whole frame regardless overflows as soon as
+    // the frame is as tall as the viewport: the trailing CR+LF is emitted on the
+    // bottom row, the terminal scrolls, and the frame's last row — the status
+    // hint, always the final row of the main screen — is carried off the bottom.
+    // A narrowing resize is what makes a frame reach full height (content wraps
+    // onto more rows while the row count stays put), which is why that direction
+    // lost its bottom row while widening never did.
+    //
+    // Painting the frame's tail instead keeps the same end state the in-place
+    // viewport repaint documents — frame rows [H-contentRows, H) on screen with
+    // the cursor parked one row below the last of them — so the next frame's
+    // bookkeeping needs no special case for having come through a reset.
+    const height = frame.screen.height;
+    const contentRows = Math.min(height, Math.max(1, frame.viewport.height - 1));
+    const startY = height - contentRows;
+    const screen = new VirtualScreen({ x: 0, y: startY }, frame.viewport.width);
+    renderFrameSlice(screen, frame, startY, height, stylePool);
     return [{ type: 'clearTerminal', reason, debug }, ...screen.diff];
 }
 /**
@@ -507,9 +525,6 @@ function repaintViewportInPlace(prev, next, stylePool) {
     renderFrameSlice(screen, next, startY, height, stylePool);
     return [{ type: 'stdout', content: anchor }, ...screen.diff];
 }
-function renderFrame(screen, frame, stylePool) {
-    renderFrameSlice(screen, frame, 0, frame.screen.height, stylePool);
-}
 /**
  * Render a slice of rows from the frame's screen.
  * Each row is rendered followed by a newline. Cursor ends at (0, endY).

package/lib/types/ink/parse-keypress.d.ts

@@ -58,6 +58,17 @@ export type TerminalResponse =
     type: 'xtversion';
     name: string;
 };
+/** Mutable cross-call state for the decomposed-paste matcher. */
+export type Win32PasteState = {
+    /** true between the decomposed start and end markers */
+    active: boolean;
+    /** progress into the marker pattern currently being matched */
+    matched: number;
+    /** keys held while a marker prefix match is in flight */
+    held: ParsedKey[];
+    /** collected paste content while active */
+    buffer: string;
+};
 /**
  * Parser state carried between parseMultipleKeypresses calls: paste mode,
  * buffered incomplete input, and the internal tokenizer instance.
@@ -66,6 +77,26 @@ export type KeyParseState = {
     mode: 'NORMAL' | 'IN_PASTE';
     incomplete: string;
     pasteBuffer: string;
+    /**
+     * Pending high surrogate from a win32-input-mode record. Uc is a UTF-16
+     * code unit, so supplementary-plane characters (emoji, CJK ext-B) arrive
+     * as two consecutive records; the high half waits here for its low half.
+     */
+    win32HighSurrogate?: number;
+    /**
+     * Pending high surrogate for the Alt+numpad synthesis path — separate
+     * from win32HighSurrogate because the two Alt rounds of one supplementary
+     * char interleave with keydown records (Alt-down, numpad digits) that
+     * would settle the regular slot before the low half arrives.
+     */
+    win32AltHighSurrogate?: number;
+    /**
+     * Decomposed bracketed-paste tracking for win32-input-mode. Classic
+     * conhost synthesizes pastes as per-char KEY_EVENT_RECORDs — including
+     * the ESC[200~ / ESC[201~ markers themselves — so under W32IM the markers
+     * arrive as ordinary key records and must be reassembled here (issue #147).
+     */
+    win32Paste?: Win32PasteState;
     _tokenizer?: Tokenizer;
 };
 /** Initial `KeyParseState` for a fresh parser. */

package/lib/types/ink/parse-keypress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-keypress.d.ts","sourceRoot":"","sources":["../../../src/ink/parse-keypress.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"parse-keypress.d.ts","sourceRoot":"","sources":["../../../src/ink/parse-keypress.ts"],"names":[],"mappings":"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"}

package/lib/types/ink/parse-keypress.js

@@ -25,6 +25,74 @@ const CSI_U_RE = /^\x1b\[(\d+)(?:;(\d+))?u/;
 // Note param order is reversed vs CSI u (modifier first, keycode second).
 // eslint-disable-next-line no-control-regex
 const MODIFY_OTHER_KEYS_RE = /^\x1b\[27;(\d+);(\d+)~/;
+// win32-input-mode (ConPTY, DECSET 9001): CSI Vk;Sc;Uc;Kd;Cs;Rc _
+// One record per key event, carrying the full INPUT_RECORD state:
+//   Vk = virtual-key code (VK_RETURN=13, VK_ESCAPE=27, VK_UP=38, ...)
+//   Sc = scan code (unused — Vk+Uc fully determine the key)
+//   Uc = UTF-16 code unit of the produced character (0 for non-printing)
+//   Kd = keydown(1)/keyup(0)
+//   Cs = dwControlKeyState (0x01/0x02 Alt, 0x04/0x08 Ctrl, 0x10 Shift;
+//        also NUMLOCK 0x20 / CAPSLOCK 0x80 / ENHANCED 0x100 — mask before
+//        testing modifiers)
+//   Rc = repeat count
+// All six fields are optional per spec #4999 and take their KEY_EVENT_RECORD
+// defaults (Vk/Sc/Uc/Kd/Cs=0, Rc=1) when omitted or empty — a reduced 'a'
+// keydown is legitimately `CSI 65;30;97;1_`. This is the only encoding that
+// preserves Enter's Shift/Ctrl bits on Windows (issue #147). Enabled on
+// win32 instead of kitty/modifyOtherKeys.
+// eslint-disable-next-line no-control-regex
+const WIN32_INPUT_RE = /^\x1b\[([\d;]*)_$/;
+// dwControlKeyState modifier bits (others — NUMLOCK_ON 0x20, CAPSLOCK_ON
+// 0x80, ENHANCED_KEY 0x100 — are state indicators, not pressed modifiers)
+const WIN32_CS_ALT = 0x01 | 0x02;
+const WIN32_CS_CTRL = 0x04 | 0x08;
+const WIN32_CS_SHIFT = 0x10;
+// Virtual-key codes that produce no input event of their own: the bare
+// modifier keys. Their pressed state rides on the NEXT real key's Cs field,
+// so both their keydown and keyup records are dropped.
+const WIN32_VK_MODIFIER = new Set([16, 17, 18]); // VK_SHIFT, VK_CONTROL, VK_MENU
+// Virtual-key code → key name for non-printing keys. Names match the
+// keyName vocabulary below so input-event's nonAlphanumericKeys filter
+// clears their raw sequence from text input. Printable keys are NOT here —
+// they map through Uc (or Vk for Ctrl+letter, whose Uc is a control code).
+const WIN32_VK_NAMES = {
+    8: 'backspace', // VK_BACK
+    9: 'tab', // VK_TAB
+    13: 'return', // VK_RETURN
+    27: 'escape', // VK_ESCAPE
+    32: 'space', // VK_SPACE
+    33: 'pageup', // VK_PRIOR
+    34: 'pagedown', // VK_NEXT
+    35: 'end', // VK_END
+    36: 'home', // VK_HOME
+    37: 'left', // VK_LEFT
+    38: 'up', // VK_UP
+    39: 'right', // VK_RIGHT
+    40: 'down', // VK_DOWN
+    45: 'insert', // VK_INSERT
+    46: 'delete', // VK_DELETE
+};
+// VK_F1 (112) .. VK_F12 (123)
+for (let i = 0; i < 12; i++)
+    WIN32_VK_NAMES[112 + i] = `f${i + 1}`;
+// OEM punctuation virtual-key codes → base character, used to recover
+// Ctrl+<punctuation> combos (Ctrl+] etc.) whose Uc collapses to a control
+// code. US-layout values; other layouts differ, but these combos are
+// rare enough that a best-effort base key beats swallowing the event.
+const WIN32_VK_OEM_CHARS = {
+    186: ';', // VK_OEM_1
+    187: '=', // VK_OEM_PLUS
+    188: ',', // VK_OEM_COMMA
+    189: '-', // VK_OEM_MINUS
+    190: '.', // VK_OEM_PERIOD
+    191: '/', // VK_OEM_2
+    192: '`', // VK_OEM_3
+    219: '[', // VK_OEM_4
+    220: '\\', // VK_OEM_5
+    221: ']', // VK_OEM_6
+    222: "'", // VK_OEM_7
+    226: '\\', // VK_OEM_102
+};
 // -- Terminal response patterns (inbound sequences from the terminal itself) --
 // DECRPM: CSI ? Ps ; Pm $ y  — response to DECRQM (request mode)
 // eslint-disable-next-line no-control-regex
@@ -140,6 +208,302 @@ function splitNumericParams(params) {
         return [];
     return params.split(';').map(p => parseInt(p, 10));
 }
+/**
+ * Build a modifier-free text key from a win32 record (used for the
+ * Alt+numpad payload on Alt-release). `sequence` defaults to the char —
+ * space needs the literal ' ' so input-event lets it through as text.
+ */
+function win32TextKey(raw, name, sequence = name) {
+    return {
+        kind: 'key',
+        name,
+        fn: false,
+        ctrl: false,
+        meta: false,
+        shift: false,
+        option: false,
+        super: false,
+        sequence,
+        raw,
+        isPasted: false,
+    };
+}
+/**
+ * Translate a win32-input-mode record (CSI Vk;Sc;Uc;Kd;Cs;Rc _) into a
+ * ParsedKey, so the rest of the input pipeline sees the same key objects as
+ * on VT-protocol terminals (issue #147).
+ *
+ * @param ctx - surrogate-pair scratch state. Uc is a UTF-16 code unit, so a
+ *   supplementary-plane character (emoji, CJK ext-B) arrives as two
+ *   consecutive records; the high half waits in `ctx.high` for its low half.
+ *   Mutated here, never on the caller's KeyParseState — the caller threads
+ *   it into the next call's state.
+ * @returns `undefined` when `s` is not a win32 record (caller falls through
+ *   to the VT parsers); `null` for a record that must be swallowed (keyup,
+ *   bare modifier transition, orphaned surrogate half); otherwise the key
+ *   plus its repeat count (Rc — ConPTY coalesces held-key repeats into one
+ *   record).
+ */
+function parseWin32KeyEvent(s, ctx) {
+    const m = WIN32_INPUT_RE.exec(s);
+    if (!m)
+        return undefined;
+    const fields = m[1].split(';');
+    const num = (i, dflt) => {
+        const f = fields[i];
+        return f === undefined || f === '' ? dflt : parseInt(f, 10);
+    };
+    const vk = num(0, 0);
+    const uc = num(2, 0);
+    const keydown = num(3, 0) === 1;
+    const cs = num(4, 0);
+    // Rc coalesces auto-repeat; cap it so a corrupt/huge field can't flood the
+    // input queue (legitimate bursts arrive as separate records anyway).
+    const repeat = Math.max(1, Math.min(num(5, 1) || 1, 64));
+    // A line editor acts on keypresses only — keyup carries no meaning and
+    // would double every key if dispatched. Checked BEFORE settling a pending
+    // surrogate pair: CharToKeyEvents emits down+up per UTF-16 unit, so a
+    // supplementary character legitimately streams as high-down, high-up,
+    // low-down — a keyup must never clear the held high half.
+    if (!keydown) {
+        // Exception: Alt+numpad Unicode input (WindowsInbox's
+        // Feature_UseNumpadEventsForClipboardInput). The stream is Alt-down,
+        // digit records with no text, then a single Alt KEYUP whose Uc carries
+        // the composed character — the only payload in the stream. Ordinary
+        // keyups also carry Uc, so this is gated strictly on VK_MENU release
+        // with a nonzero Uc.
+        if (vk !== 18 || uc === 0)
+            return null;
+        // A supplementary-plane char is synthesized per UTF-16 unit: TWO Alt
+        // rounds, high half then low half, each riding its own Alt-up. The
+        // pending high waits in ctx.altHigh — a dedicated slot, because the
+        // next round's Alt-down/numpad records are keydowns that would settle
+        // the regular ctx.high before the low half ever arrives.
+        if (uc >= 0xd800 && uc <= 0xdbff) {
+            ctx.altHigh = uc;
+            return null;
+        }
+        if (uc >= 0xdc00 && uc <= 0xdfff) {
+            const high = ctx.altHigh;
+            ctx.altHigh = undefined;
+            if (high === undefined)
+                return null;
+            return { key: win32TextKey(s, String.fromCharCode(high, uc)), repeat: 1 };
+        }
+        // BMP payload: any pending synthesized high is orphaned by this char.
+        ctx.altHigh = undefined;
+        if (uc === 0x20) {
+            return { key: win32TextKey(s, 'space', ' '), repeat: 1 };
+        }
+        if (uc > 0x20 && !(uc >= 0x7f && uc <= 0x9f)) {
+            return { key: win32TextKey(s, String.fromCharCode(uc)), repeat: 1 };
+        }
+        return null;
+    }
+    // Every keydown settles a pending pair: a high half followed by anything
+    // but its low half is dropped, never combined across keys.
+    const highSurrogate = ctx.high;
+    ctx.high = undefined;
+    // The Alt+numpad pending high survives ONLY the synthesis stream's own
+    // filler records: a payload-free VK_MENU transition (the next round's
+    // Alt-down), or a payload-free numpad digit while Alt is held (Cs carries
+    // an Alt bit). Real Shift/Ctrl transitions and digits pressed without
+    // Alt are real input — they settle (drop) the pending high.
+    const altHeld = (cs & WIN32_CS_ALT) !== 0;
+    const isSynthesisFiller = (vk === 18 && uc === 0) || (vk >= 96 && vk <= 105 && uc === 0 && altHeld);
+    if (!isSynthesisFiller) {
+        ctx.altHigh = undefined;
+    }
+    // Bare modifier transitions: their state rides on the next real key's Cs.
+    if (WIN32_VK_MODIFIER.has(vk))
+        return null;
+    const shift = (cs & WIN32_CS_SHIFT) !== 0;
+    let ctrl = (cs & WIN32_CS_CTRL) !== 0;
+    let meta = (cs & WIN32_CS_ALT) !== 0;
+    const base = {
+        kind: 'key',
+        fn: false,
+        ctrl,
+        meta,
+        shift,
+        option: false,
+        super: false,
+        raw: s,
+        isPasted: false,
+    };
+    // Printable text comes through Uc, already shift/IME-composed by the
+    // console host — so it must win over the Vk name table: NumLock-on numpad
+    // keys legitimately carry the Ins/Del/Home/... cluster's Vk with the digit
+    // in Uc (tcell emits e.g. CSI 45;82;48;1;32;1_ for numpad 0), and only Uc
+    // (plus the ENHANCED_KEY bit, which text keys never set) tells them apart.
+    // "Printable" excludes C0, DEL and the C1 band (matching Windows
+    // Terminal's own codepoint > 0x20 && != 0x7f rule, extended over C1):
+    // Ctrl+8 / Ctrl+/ report Uc=0x7F and must reach the Ctrl recovery chain
+    // below.
+    let char;
+    if (uc >= 0xd800 && uc <= 0xdbff) {
+        ctx.high = uc;
+        return null;
+    }
+    if (uc >= 0xdc00 && uc <= 0xdfff) {
+        // Orphaned low half (no pending high): swallow immediately. Falling
+        // through to the Vk table would resurrect it as a named key — a stray
+        // CSI 32;57;56832;1;0;1_ must not become a Space.
+        if (highSurrogate === undefined)
+            return null;
+        char = String.fromCharCode(highSurrogate, uc);
+    }
+    else if (uc > 0x20 && !(uc >= 0x7f && uc <= 0x9f)) {
+        char = String.fromCharCode(uc);
+    }
+    // Space gets its own Vk-independent branch: spec-legal records omit Vk
+    // (CSI ;;32;1_) and Unicode-injected input arrives as VK_PACKET (231) —
+    // neither reaches the Vk=32 name entry below. Unlike graphic chars,
+    // space KEEPS ctrl/meta: Ctrl+Alt+Space is a binding, not AltGr text
+    // (input-event maps ctrl+space to ' ').
+    if (uc === 0x20) {
+        return { key: { ...base, name: 'space', sequence: ' ' }, repeat };
+    }
+    if (char !== undefined) {
+        // AltGr arrives as RightAlt + a synthesized LeftCtrl with the printable
+        // char in Uc — that's text input ('@', '€', '\', '|', braces on
+        // international layouts), not a Ctrl+Alt binding. Clearing the modifiers
+        // is required for the text to be insertable at all (PromptInput rejects
+        // input carrying ctrl/meta). Genuine Ctrl+Alt+<printable> bindings are
+        // indistinguishable from AltGr by Windows design.
+        if (ctrl && meta) {
+            ctrl = false;
+            meta = false;
+        }
+        return { key: { ...base, ctrl, meta, name: char, sequence: char }, repeat };
+    }
+    // Synthesized character records (conhost's SynthesizeKeyEvent: Vk=0,
+    // Sc=0, Cs=0) carry their entire payload in Uc — including the control
+    // chars that spell the bracketed-paste markers (ESC[200~ / ESC[201~).
+    // Map the editing-relevant ones to named keys so the decomposed-paste
+    // reassembler below can see the marker characters at all.
+    if (vk === 0) {
+        if (uc === 27)
+            return { key: { ...base, name: 'escape', sequence: s }, repeat };
+        if (uc === 13 || uc === 10)
+            return { key: { ...base, name: 'return', sequence: s }, repeat };
+        if (uc === 9)
+            return { key: { ...base, name: 'tab', sequence: s }, repeat };
+        if (uc === 8 || uc === 0x7f)
+            return { key: { ...base, name: 'backspace', sequence: s }, repeat };
+        return null;
+    }
+    // Non-printing keys by virtual-key code. sequence stays the raw record so
+    // input-event clears it via nonAlphanumericKeys ('space' isn't in that
+    // list — it needs the literal ' ' as sequence to reach text input).
+    const named = WIN32_VK_NAMES[vk];
+    if (named) {
+        return {
+            key: { ...base, name: named, sequence: named === 'space' ? ' ' : s },
+            repeat,
+        };
+    }
+    // Ctrl combos collapse Uc to a control code (Ctrl+C → 3, Ctrl+[ → 27,
+    // Ctrl+2 → 0). Recover the base key from Vk so the combination isn't
+    // swallowed: Ctrl+[ must stay usable as Escape (legacy VT parity — the
+    // \x1b byte), letters map to their name for bindings like Ctrl+C
+    // (exitOnCtrlC), punctuation via the OEM table.
+    if (ctrl) {
+        if (uc === 27) {
+            return { key: { ...base, name: 'escape', sequence: s }, repeat };
+        }
+        const baseChar = vk >= 65 && vk <= 90
+            ? String.fromCharCode(vk + 32)
+            : vk >= 48 && vk <= 57
+                ? String.fromCharCode(vk)
+                : WIN32_VK_OEM_CHARS[vk];
+        if (baseChar !== undefined) {
+            return { key: { ...base, name: baseChar, sequence: baseChar }, repeat };
+        }
+    }
+    // No usable payload (unmapped function key, dead key, Uc=0): swallow so
+    // the raw record can't leak into the prompt as text.
+    return null;
+}
+// Character spellings of CSI 200~ / CSI 201~ as key records: the ESC char
+// arrives as a Vk=27 record (name 'escape'), the rest as text chars.
+const WIN32_PASTE_START_CHARS = ['\x1b', '[', '2', '0', '0', '~'];
+const WIN32_PASTE_END_CHARS = ['\x1b', '[', '2', '0', '1', '~'];
+/**
+ * The text equivalent of a translated win32 key for paste purposes: chars
+ * map to themselves, named editing keys to their control char. Returns
+ * undefined for keys with no text meaning (arrows, F-keys).
+ */
+function win32RecordChar(key) {
+    switch (key.name) {
+        case 'escape':
+            return '\x1b';
+        case 'space':
+            return ' ';
+        case 'tab':
+            return '\t';
+        case 'return':
+            return '\n';
+        case 'backspace':
+            return '\x7f';
+        default:
+            // Text keys carry their char as BOTH name and sequence; named keys
+            // keep the raw CSI record as sequence. This avoids a UTF-16 length
+            // check — a supplementary-plane char (emoji, CJK ext-B) is a
+            // length-2 string but still text.
+            return key.sequence === key.name ? key.name : undefined;
+    }
+}
+/**
+ * Feed one translated win32 key through the decomposed-paste matcher.
+ * Returns the keys to emit (empty while holding a candidate prefix or
+ * collecting paste content).
+ */
+function feedWin32Paste(state, key) {
+    const pattern = state.active ? WIN32_PASTE_END_CHARS : WIN32_PASTE_START_CHARS;
+    // Marker chars never carry Ctrl/Alt in the synthesized stream; requiring
+    // this keeps a user's real Ctrl+[ from starting a phantom paste. Shift is
+    // allowed — '~' legitimately arrives with it.
+    const ch = key.ctrl || key.meta ? undefined : win32RecordChar(key);
+    if (ch !== undefined && ch === pattern[state.matched]) {
+        state.held.push(key);
+        state.matched++;
+        if (state.matched === pattern.length) {
+            state.matched = 0;
+            state.held = [];
+            if (!state.active) {
+                state.active = true;
+                state.buffer = '';
+                return [];
+            }
+            // End marker complete: the whole paste as a single event.
+            const paste = createPasteKey(state.buffer);
+            state.active = false;
+            state.buffer = '';
+            return [paste];
+        }
+        return [];
+    }
+    // Mismatch: release whatever prefix was held, then re-evaluate the
+    // current key from a clean match position (it may itself start a marker,
+    // e.g. ESC ESC [ 2 0 1 ~).
+    if (state.matched > 0) {
+        const held = state.held;
+        state.held = [];
+        state.matched = 0;
+        if (state.active) {
+            for (const k of held)
+                state.buffer += win32RecordChar(k) ?? '';
+            return feedWin32Paste(state, key);
+        }
+        return [...held, ...feedWin32Paste(state, key)];
+    }
+    if (state.active) {
+        state.buffer += win32RecordChar(key) ?? '';
+        return [];
+    }
+    return [key];
+}
 /** Initial `KeyParseState` for a fresh parser. */
 export const INITIAL_STATE = {
     mode: 'NORMAL',
@@ -185,6 +549,23 @@ export function parseMultipleKeypresses(prevState, input = '') {
     const keys = [];
     let inPaste = prevState.mode === 'IN_PASTE';
     let pasteBuffer = prevState.pasteBuffer;
+    // Surrogate-pair scratch for win32-input-mode records. Threaded through a
+    // local object so prevState is never mutated — App.tsx seeds the parser
+    // with the shared INITIAL_STATE singleton, and a pending high surrogate
+    // leaking into it would survive into fresh parser instances.
+    const win32Ctx = {
+        high: prevState.win32HighSurrogate,
+        altHigh: prevState.win32AltHighSurrogate,
+    };
+    // Decomposed-paste matcher state rides on a shared mutable object across
+    // calls (like _tokenizer). Fresh instances never touch INITIAL_STATE —
+    // the field stays undefined there and the object is created on demand.
+    const win32Paste = prevState.win32Paste ?? {
+        active: false,
+        matched: 0,
+        held: [],
+        buffer: '',
+    };
     for (const token of tokens) {
         if (token.type === 'sequence') {
             if (token.value === PASTE_START) {
@@ -204,17 +585,33 @@ export function parseMultipleKeypresses(prevState, input = '') {
                 pasteBuffer += token.value;
             }
             else {
-                const response = parseTerminalResponse(token.value);
-                if (response) {
-                    keys.push({ kind: 'response', sequence: token.value, response });
+                const win32 = parseWin32KeyEvent(token.value, win32Ctx);
+                if (win32 !== undefined) {
+                    // win32-input-mode record. null means a swallowed event (keyup,
+                    // bare modifier, orphaned surrogate) — the sequence is consumed
+                    // either way and never reaches the VT keypress parser.
+                    if (win32 !== null) {
+                        // Keys pass through the decomposed-paste matcher: on classic
+                        // conhost the bracketed-paste markers themselves arrive as key
+                        // records and must be reassembled before dispatch.
+                        for (let i = 0; i < win32.repeat; i++) {
+                            keys.push(...feedWin32Paste(win32Paste, win32.key));
+                        }
+                    }
                 }
                 else {
-                    const mouse = parseMouseEvent(token.value);
-                    if (mouse) {
-                        keys.push(mouse);
+                    const response = parseTerminalResponse(token.value);
+                    if (response) {
+                        keys.push({ kind: 'response', sequence: token.value, response });
                     }
                     else {
-                        keys.push(parseKeypress(token.value));
+                        const mouse = parseMouseEvent(token.value);
+                        if (mouse) {
+                            keys.push(mouse);
+                        }
+                        else {
+                            keys.push(parseKeypress(token.value));
+                        }
                     }
                 }
             }
@@ -251,11 +648,39 @@ export function parseMultipleKeypresses(prevState, input = '') {
         inPaste = false;
         pasteBuffer = '';
     }
+    // Flush handling for the decomposed win32 paste: mid-paste (active) the
+    // 50ms quiet timer means the paste stream ended — finalize with whatever
+    // was collected (mirrors the VT IN_PASTE flush above; a truncated end
+    // marker must not strand the matcher and eat all future typing). Outside
+    // a paste, release any held marker-prefix keys (e.g. a lone Escape).
+    if (isFlush && win32Paste.active) {
+        let content = win32Paste.buffer;
+        for (const k of win32Paste.held)
+            content += win32RecordChar(k) ?? '';
+        keys.push(createPasteKey(content));
+        win32Paste.active = false;
+        win32Paste.buffer = '';
+        win32Paste.held = [];
+        win32Paste.matched = 0;
+    }
+    else if (isFlush && win32Paste.held.length > 0) {
+        keys.push(...win32Paste.held);
+        win32Paste.held = [];
+        win32Paste.matched = 0;
+    }
     // Build new state
     const newState = {
         mode: inPaste ? 'IN_PASTE' : 'NORMAL',
-        incomplete: tokenizer.buffer(),
+        // App.tsx arms its flush timer whenever `incomplete` is non-empty. The
+        // tokenizer only reports raw bytes there, so paste-matcher holds (a
+        // marker prefix in flight, or an active paste) set a sentinel to get the
+        // same 50ms release — a lone Escape stays as responsive as in VT mode.
+        incomplete: tokenizer.buffer() ||
+            (win32Paste.held.length > 0 || win32Paste.active ? '\x1b' : ''),
         pasteBuffer,
+        win32HighSurrogate: win32Ctx.high,
+        win32AltHighSurrogate: win32Ctx.altHigh,
+        win32Paste,
         _tokenizer: tokenizer,
     };
     return [keys, newState];
@@ -603,6 +1028,15 @@ function parseKeypress(s = '') {
         key.raw = undefined;
         key.name = 'return';
     }
+    else if (s === '\x1b\r' || s === '\x1b\n') {
+        // Option+Enter on terminals without extended key reporting (Terminal.app,
+        // default macOS terminal) sends ESC CR when "Use Option as Meta" is on —
+        // the tokenizer passes CR through as text since it's not an ESC final
+        // byte, so the pair arrives here as one chunk (issue #110).
+        key.raw = undefined;
+        key.name = 'return';
+        key.meta = true;
+    }
     else if (s === '\n') {
         key.name = 'enter';
     }