@google/gemini-cli 0.12.0-nightly.20251023.a7faa208 → 0.12.0-nightly.20251027.cb0947c5

package/dist/src/ui/contexts/KeypressContext.js

@@ -7,10 +7,11 @@ import { PassThrough } from 'node:stream';
 import { BACKSLASH_ENTER_DETECTION_WINDOW_MS, CHAR_CODE_ESC, KITTY_CTRL_C, KITTY_KEYCODE_BACKSPACE, KITTY_KEYCODE_ENTER, KITTY_KEYCODE_NUMPAD_ENTER, KITTY_KEYCODE_TAB, MAX_KITTY_SEQUENCE_LENGTH, KITTY_MODIFIER_BASE, KITTY_MODIFIER_EVENT_TYPES_OFFSET, MODIFIER_SHIFT_BIT, MODIFIER_ALT_BIT, MODIFIER_CTRL_BIT, } from '../utils/platformConstants.js';
 import { FOCUS_IN, FOCUS_OUT } from '../hooks/useFocus.js';
 const ESC = '\u001B';
-export const PASTE_MODE_PREFIX = `${ESC}[200~`;
-export const PASTE_MODE_SUFFIX = `${ESC}[201~`;
+export const PASTE_MODE_START = `${ESC}[200~`;
+export const PASTE_MODE_END = `${ESC}[201~`;
 export const DRAG_COMPLETION_TIMEOUT_MS = 100; // Broadcast full path after 100ms if no more input
 export const KITTY_SEQUENCE_TIMEOUT_MS = 50; // Flush incomplete kitty sequences after 50ms
+export const PASTE_CODE_TIMEOUT_MS = 50; // Flush incomplete paste code after 50ms
 export const SINGLE_QUOTE = "'";
 export const DOUBLE_QUOTE = '"';
 const ALT_KEY_CHARACTER_MAP = {
@@ -41,169 +42,186 @@ const ALT_KEY_CHARACTER_MAP = {
     '\u00A5': 'y',
     '\u03A9': 'z',
 };
-const KeypressContext = createContext(undefined);
-export function useKeypressContext() {
-    const context = useContext(KeypressContext);
-    if (!context) {
-        throw new Error('useKeypressContext must be used within a KeypressProvider');
-    }
-    return context;
+/**
+ * Check if a buffer could potentially be a valid kitty sequence or its prefix.
+ */
+function couldBeKittySequence(buffer) {
+    // Kitty sequences always start with ESC[.
+    if (buffer.length === 0)
+        return true;
+    if (buffer === ESC || buffer === `${ESC}[`)
+        return true;
+    if (!buffer.startsWith(`${ESC}[`))
+        return false;
+    // Check for known kitty sequence patterns:
+    // 1. ESC[<digit> - could be CSI-u or tilde-coded
+    // 2. ESC[1;<digit> - parameterized functional
+    // 3. ESC[<letter> - legacy functional keys
+    // 4. ESC[Z - reverse tab
+    const afterCSI = buffer.slice(2);
+    // Check if it starts with a digit (could be CSI-u or parameterized)
+    if (/^\d/.test(afterCSI))
+        return true;
+    // Check for known single-letter sequences
+    if (/^[ABCDHFPQRSZ]/.test(afterCSI))
+        return true;
+    // Check for 1; pattern (parameterized sequences)
+    if (/^1;\d/.test(afterCSI))
+        return true;
+    // Anything else starting with ESC[ that doesn't match our patterns
+    // is likely not a kitty sequence we handle
+    return false;
 }
-export function KeypressProvider({ children, kittyProtocolEnabled, config, debugKeystrokeLogging, }) {
-    const { stdin, setRawMode } = useStdin();
-    const subscribers = useRef(new Set()).current;
-    const isDraggingRef = useRef(false);
-    const dragBufferRef = useRef('');
-    const draggingTimerRef = useRef(null);
-    const subscribe = useCallback((handler) => {
-        subscribers.add(handler);
-    }, [subscribers]);
-    const unsubscribe = useCallback((handler) => {
-        subscribers.delete(handler);
-    }, [subscribers]);
-    useEffect(() => {
-        const clearDraggingTimer = () => {
-            if (draggingTimerRef.current) {
-                clearTimeout(draggingTimerRef.current);
-                draggingTimerRef.current = null;
-            }
+/**
+ * Parses a single complete kitty/parameterized/legacy sequence from the start
+ * of the buffer.
+ *
+ * This enables peel-and-continue parsing for batched input, allowing us to
+ * "peel off" one complete event when multiple sequences arrive in a single
+ * chunk, preventing buffer overflow and fragmentation.
+ *
+ * @param buffer - The input buffer string to parse.
+ * @returns The parsed Key and the number of characters consumed, or null if
+ * no complete sequence is found at the start of the buffer.
+ */
+function parseKittyPrefix(buffer) {
+    // In older terminals ESC [ Z was used as Cursor Backward Tabulation (CBT)
+    // In newer terminals the same functionality of key combination for moving
+    // backward through focusable elements is Shift+Tab, hence we will
+    // map ESC [ Z to Shift+Tab
+    // 0) Reverse Tab (legacy): ESC [ Z
+    //    Treat as Shift+Tab for UI purposes.
+    //    Regex parts:
+    //    ^     - start of buffer
+    //    ESC [ - CSI introducer
+    //    Z     - legacy reverse tab
+    const revTabLegacy = new RegExp(`^${ESC}\\[Z`);
+    let m = buffer.match(revTabLegacy);
+    if (m) {
+        return {
+            key: {
+                name: 'tab',
+                ctrl: false,
+                meta: false,
+                shift: true,
+                paste: false,
+                sequence: buffer.slice(0, m[0].length),
+                kittyProtocol: true,
+            },
+            length: m[0].length,
         };
-        const wasRaw = stdin.isRaw;
-        if (wasRaw === false) {
-            setRawMode(true);
+    }
+    // 1) Reverse Tab (parameterized): ESC [ 1 ; <mods> Z
+    //    Parameterized reverse Tab: ESC [ 1 ; <mods> Z
+    const revTabParam = new RegExp(`^${ESC}\\[1;(\\d+)Z`);
+    m = buffer.match(revTabParam);
+    if (m) {
+        let mods = parseInt(m[1], 10);
+        if (mods >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
+            mods -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
         }
-        const keypressStream = new PassThrough();
-        let usePassthrough = false;
-        const nodeMajorVersion = parseInt(process.versions.node.split('.')[0], 10);
-        if (nodeMajorVersion < 20 ||
-            process.env['PASTE_WORKAROUND'] === '1' ||
-            process.env['PASTE_WORKAROUND'] === 'true') {
-            usePassthrough = true;
+        const bits = mods - KITTY_MODIFIER_BASE;
+        const alt = (bits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
+        const ctrl = (bits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
+        return {
+            key: {
+                name: 'tab',
+                ctrl,
+                meta: alt,
+                // Reverse tab implies Shift behavior; force shift regardless of mods
+                shift: true,
+                paste: false,
+                sequence: buffer.slice(0, m[0].length),
+                kittyProtocol: true,
+            },
+            length: m[0].length,
+        };
+    }
+    // 2) Parameterized functional: ESC [ 1 ; <mods> (A|B|C|D|H|F|P|Q|R|S)
+    // 2) Parameterized functional: ESC [ 1 ; <mods> (A|B|C|D|H|F|P|Q|R|S)
+    //    Arrows, Home/End, F1–F4 with modifiers encoded in <mods>.
+    const arrowPrefix = new RegExp(`^${ESC}\\[1;(\\d+)([ABCDHFPQSR])`);
+    m = buffer.match(arrowPrefix);
+    if (m) {
+        let mods = parseInt(m[1], 10);
+        if (mods >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
+            mods -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
         }
-        let isPaste = false;
-        let pasteBuffer = Buffer.alloc(0);
-        let kittySequenceBuffer = '';
-        let kittySequenceTimeout = null;
-        let backslashTimeout = null;
-        let waitingForEnterAfterBackslash = false;
-        // Check if a buffer could potentially be a valid kitty sequence or its prefix
-        const couldBeKittySequence = (buffer) => {
-            // Kitty sequences always start with ESC[.
-            if (buffer.length === 0)
-                return true;
-            if (buffer === ESC || buffer === `${ESC}[`)
-                return true;
-            if (!buffer.startsWith(`${ESC}[`))
-                return false;
-            // Check for known kitty sequence patterns:
-            // 1. ESC[<digit> - could be CSI-u or tilde-coded
-            // 2. ESC[1;<digit> - parameterized functional
-            // 3. ESC[<letter> - legacy functional keys
-            // 4. ESC[Z - reverse tab
-            const afterCSI = buffer.slice(2);
-            // Check if it starts with a digit (could be CSI-u or parameterized)
-            if (/^\d/.test(afterCSI))
-                return true;
-            // Check for known single-letter sequences
-            if (/^[ABCDHFPQRSZ]/.test(afterCSI))
-                return true;
-            // Check for 1; pattern (parameterized sequences)
-            if (/^1;\d/.test(afterCSI))
-                return true;
-            // Anything else starting with ESC[ that doesn't match our patterns
-            // is likely not a kitty sequence we handle
-            return false;
+        const bits = mods - KITTY_MODIFIER_BASE;
+        const shift = (bits & MODIFIER_SHIFT_BIT) === MODIFIER_SHIFT_BIT;
+        const alt = (bits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
+        const ctrl = (bits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
+        const sym = m[2];
+        const symbolToName = {
+            A: 'up',
+            B: 'down',
+            C: 'right',
+            D: 'left',
+            H: 'home',
+            F: 'end',
+            P: 'f1',
+            Q: 'f2',
+            R: 'f3',
+            S: 'f4',
         };
-        // Parse a single complete kitty sequence from the start (prefix) of the
-        // buffer and return both the Key and the number of characters consumed.
-        // This lets us "peel off" one complete event when multiple sequences arrive
-        // in a single chunk, preventing buffer overflow and fragmentation.
-        // Parse a single complete kitty/parameterized/legacy sequence from the start
-        // of the buffer and return both the parsed Key and the number of characters
-        // consumed. This enables peel-and-continue parsing for batched input.
-        const parseKittyPrefix = (buffer) => {
-            // In older terminals ESC [ Z was used as Cursor Backward Tabulation (CBT)
-            // In newer terminals the same functionality of key combination for moving
-            // backward through focusable elements is Shift+Tab, hence we will
-            // map ESC [ Z to Shift+Tab
-            // 0) Reverse Tab (legacy): ESC [ Z
-            //    Treat as Shift+Tab for UI purposes.
-            //    Regex parts:
-            //    ^     - start of buffer
-            //    ESC [ - CSI introducer
-            //    Z     - legacy reverse tab
-            const revTabLegacy = new RegExp(`^${ESC}\\[Z`);
-            let m = buffer.match(revTabLegacy);
-            if (m) {
-                return {
-                    key: {
-                        name: 'tab',
-                        ctrl: false,
-                        meta: false,
-                        shift: true,
-                        paste: false,
-                        sequence: buffer.slice(0, m[0].length),
-                        kittyProtocol: true,
-                    },
-                    length: m[0].length,
-                };
-            }
-            // 1) Reverse Tab (parameterized): ESC [ 1 ; <mods> Z
-            //    Parameterized reverse Tab: ESC [ 1 ; <mods> Z
-            const revTabParam = new RegExp(`^${ESC}\\[1;(\\d+)Z`);
-            m = buffer.match(revTabParam);
-            if (m) {
-                let mods = parseInt(m[1], 10);
-                if (mods >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
-                    mods -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
-                }
-                const bits = mods - KITTY_MODIFIER_BASE;
-                const alt = (bits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
-                const ctrl = (bits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
-                return {
-                    key: {
-                        name: 'tab',
-                        ctrl,
-                        meta: alt,
-                        // Reverse tab implies Shift behavior; force shift regardless of mods
-                        shift: true,
-                        paste: false,
-                        sequence: buffer.slice(0, m[0].length),
-                        kittyProtocol: true,
-                    },
-                    length: m[0].length,
-                };
-            }
-            // 2) Parameterized functional: ESC [ 1 ; <mods> (A|B|C|D|H|F|P|Q|R|S)
-            // 2) Parameterized functional: ESC [ 1 ; <mods> (A|B|C|D|H|F|P|Q|R|S)
-            //    Arrows, Home/End, F1–F4 with modifiers encoded in <mods>.
-            const arrowPrefix = new RegExp(`^${ESC}\\[1;(\\d+)([ABCDHFPQSR])`);
-            m = buffer.match(arrowPrefix);
-            if (m) {
-                let mods = parseInt(m[1], 10);
-                if (mods >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
-                    mods -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
-                }
-                const bits = mods - KITTY_MODIFIER_BASE;
-                const shift = (bits & MODIFIER_SHIFT_BIT) === MODIFIER_SHIFT_BIT;
-                const alt = (bits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
-                const ctrl = (bits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
-                const sym = m[2];
-                const symbolToName = {
-                    A: 'up',
-                    B: 'down',
-                    C: 'right',
-                    D: 'left',
-                    H: 'home',
-                    F: 'end',
-                    P: 'f1',
-                    Q: 'f2',
-                    R: 'f3',
-                    S: 'f4',
-                };
-                const name = symbolToName[sym] || '';
-                if (!name)
-                    return null;
+        const name = symbolToName[sym] || '';
+        if (!name)
+            return null;
+        return {
+            key: {
+                name,
+                ctrl,
+                meta: alt,
+                shift,
+                paste: false,
+                sequence: buffer.slice(0, m[0].length),
+                kittyProtocol: true,
+            },
+            length: m[0].length,
+        };
+    }
+    // 3) CSI-u form: ESC [ <code> ; <mods> (u|~)
+    // 3) CSI-u and tilde-coded functional keys: ESC [ <code> ; <mods> (u|~)
+    //    'u' terminator: Kitty CSI-u; '~' terminator: tilde-coded function keys.
+    const csiUPrefix = new RegExp(`^${ESC}\\[(\\d+)(;(\\d+))?([u~])`);
+    m = buffer.match(csiUPrefix);
+    if (m) {
+        const keyCode = parseInt(m[1], 10);
+        let modifiers = m[3] ? parseInt(m[3], 10) : KITTY_MODIFIER_BASE;
+        if (modifiers >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
+            modifiers -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
+        }
+        const modifierBits = modifiers - KITTY_MODIFIER_BASE;
+        const shift = (modifierBits & MODIFIER_SHIFT_BIT) === MODIFIER_SHIFT_BIT;
+        const alt = (modifierBits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
+        const ctrl = (modifierBits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
+        const terminator = m[4];
+        // Tilde-coded functional keys (Delete, Insert, PageUp/Down, Home/End)
+        if (terminator === '~') {
+            let name = null;
+            switch (keyCode) {
+                case 1:
+                    name = 'home';
+                    break;
+                case 2:
+                    name = 'insert';
+                    break;
+                case 3:
+                    name = 'delete';
+                    break;
+                case 4:
+                    name = 'end';
+                    break;
+                case 5:
+                    name = 'pageup';
+                    break;
+                case 6:
+                    name = 'pagedown';
+                    break;
+                default:
+                    break;
+            }
+            if (name) {
                 return {
                     key: {
                         name,
@@ -217,136 +235,207 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                     length: m[0].length,
                 };
             }
-            // 3) CSI-u form: ESC [ <code> ; <mods> (u|~)
-            // 3) CSI-u and tilde-coded functional keys: ESC [ <code> ; <mods> (u|~)
-            //    'u' terminator: Kitty CSI-u; '~' terminator: tilde-coded function keys.
-            const csiUPrefix = new RegExp(`^${ESC}\\[(\\d+)(;(\\d+))?([u~])`);
-            m = buffer.match(csiUPrefix);
-            if (m) {
-                const keyCode = parseInt(m[1], 10);
-                let modifiers = m[3] ? parseInt(m[3], 10) : KITTY_MODIFIER_BASE;
-                if (modifiers >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
-                    modifiers -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
-                }
-                const modifierBits = modifiers - KITTY_MODIFIER_BASE;
-                const shift = (modifierBits & MODIFIER_SHIFT_BIT) === MODIFIER_SHIFT_BIT;
-                const alt = (modifierBits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
-                const ctrl = (modifierBits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
-                const terminator = m[4];
-                // Tilde-coded functional keys (Delete, Insert, PageUp/Down, Home/End)
-                if (terminator === '~') {
-                    let name = null;
-                    switch (keyCode) {
-                        case 1:
-                            name = 'home';
-                            break;
-                        case 2:
-                            name = 'insert';
-                            break;
-                        case 3:
-                            name = 'delete';
-                            break;
-                        case 4:
-                            name = 'end';
-                            break;
-                        case 5:
-                            name = 'pageup';
-                            break;
-                        case 6:
-                            name = 'pagedown';
-                            break;
-                        default:
-                            break;
-                    }
-                    if (name) {
-                        return {
-                            key: {
-                                name,
-                                ctrl,
-                                meta: alt,
-                                shift,
-                                paste: false,
-                                sequence: buffer.slice(0, m[0].length),
-                                kittyProtocol: true,
-                            },
-                            length: m[0].length,
-                        };
-                    }
-                }
-                const kittyKeyCodeToName = {
-                    [CHAR_CODE_ESC]: 'escape',
-                    [KITTY_KEYCODE_TAB]: 'tab',
-                    [KITTY_KEYCODE_BACKSPACE]: 'backspace',
-                    [KITTY_KEYCODE_ENTER]: 'return',
-                    [KITTY_KEYCODE_NUMPAD_ENTER]: 'return',
-                };
-                const name = kittyKeyCodeToName[keyCode];
-                if (name) {
-                    return {
-                        key: {
-                            name,
-                            ctrl,
-                            meta: alt,
-                            shift,
-                            paste: false,
-                            sequence: buffer.slice(0, m[0].length),
-                            kittyProtocol: true,
-                        },
-                        length: m[0].length,
-                    };
-                }
-                // Ctrl+letters and Alt+letters
-                if ((ctrl || alt) &&
-                    keyCode >= 'a'.charCodeAt(0) &&
-                    keyCode <= 'z'.charCodeAt(0)) {
-                    const letter = String.fromCharCode(keyCode);
-                    return {
-                        key: {
-                            name: letter,
-                            ctrl,
-                            meta: alt,
-                            shift,
-                            paste: false,
-                            sequence: buffer.slice(0, m[0].length),
-                            kittyProtocol: true,
-                        },
-                        length: m[0].length,
-                    };
+        }
+        const kittyKeyCodeToName = {
+            [CHAR_CODE_ESC]: 'escape',
+            [KITTY_KEYCODE_TAB]: 'tab',
+            [KITTY_KEYCODE_BACKSPACE]: 'backspace',
+            [KITTY_KEYCODE_ENTER]: 'return',
+            [KITTY_KEYCODE_NUMPAD_ENTER]: 'return',
+        };
+        const name = kittyKeyCodeToName[keyCode];
+        if (name) {
+            return {
+                key: {
+                    name,
+                    ctrl,
+                    meta: alt,
+                    shift,
+                    paste: false,
+                    sequence: buffer.slice(0, m[0].length),
+                    kittyProtocol: true,
+                },
+                length: m[0].length,
+            };
+        }
+        // Ctrl+letters and Alt+letters
+        if ((ctrl || alt) &&
+            keyCode >= 'a'.charCodeAt(0) &&
+            keyCode <= 'z'.charCodeAt(0)) {
+            const letter = String.fromCharCode(keyCode);
+            return {
+                key: {
+                    name: letter,
+                    ctrl,
+                    meta: alt,
+                    shift,
+                    paste: false,
+                    sequence: buffer.slice(0, m[0].length),
+                    kittyProtocol: true,
+                },
+                length: m[0].length,
+            };
+        }
+    }
+    // 4) Legacy function keys (no parameters): ESC [ (A|B|C|D|H|F)
+    //    Arrows + Home/End without modifiers.
+    const legacyFuncKey = new RegExp(`^${ESC}\\[([ABCDHF])`);
+    m = buffer.match(legacyFuncKey);
+    if (m) {
+        const sym = m[1];
+        const nameMap = {
+            A: 'up',
+            B: 'down',
+            C: 'right',
+            D: 'left',
+            H: 'home',
+            F: 'end',
+        };
+        const name = nameMap[sym];
+        return {
+            key: {
+                name,
+                ctrl: false,
+                meta: false,
+                shift: false,
+                paste: false,
+                sequence: buffer.slice(0, m[0].length),
+                kittyProtocol: true,
+            },
+            length: m[0].length,
+        };
+    }
+    return null;
+}
+/**
+ * Returns the first index before which we are certain there is no paste marker.
+ */
+function earliestPossiblePasteMarker(data) {
+    // Check data for full start-paste or end-paste markers.
+    const startIndex = data.indexOf(PASTE_MODE_START);
+    const endIndex = data.indexOf(PASTE_MODE_END);
+    if (startIndex !== -1 && endIndex !== -1) {
+        return Math.min(startIndex, endIndex);
+    }
+    else if (startIndex !== -1) {
+        return startIndex;
+    }
+    else if (endIndex !== -1) {
+        return endIndex;
+    }
+    // data contains no full start-paste or end-paste.
+    // Check if data ends with a prefix of start-paste or end-paste.
+    const codeLength = PASTE_MODE_START.length;
+    for (let i = Math.min(data.length, codeLength - 1); i > 0; i--) {
+        const candidate = data.slice(data.length - i);
+        if (PASTE_MODE_START.indexOf(candidate) === 0 ||
+            PASTE_MODE_END.indexOf(candidate) === 0) {
+            return data.length - i;
+        }
+    }
+    return data.length;
+}
+/**
+ * A generator that takes in data chunks and spits out paste-start and
+ * paste-end keypresses. All non-paste marker data is passed to passthrough.
+ */
+function* pasteMarkerParser(passthrough, keypressHandler) {
+    while (true) {
+        let data = yield;
+        if (data.length === 0) {
+            continue; // we timed out
+        }
+        while (true) {
+            const index = earliestPossiblePasteMarker(data);
+            if (index === data.length) {
+                // no possible paste markers were found
+                passthrough.write(data);
+                break;
+            }
+            if (index > 0) {
+                // snip off and send the part that doesn't have a paste marker
+                passthrough.write(data.slice(0, index));
+                data = data.slice(index);
+            }
+            // data starts with a possible paste marker
+            const codeLength = PASTE_MODE_START.length;
+            if (data.length < codeLength) {
+                // we have a prefix. Concat the next data and try again.
+                const newData = yield;
+                if (newData.length === 0) {
+                    // we timed out. Just dump what we have and start over.
+                    passthrough.write(data);
+                    break;
                 }
+                data += newData;
             }
-            // 4) Legacy function keys (no parameters): ESC [ (A|B|C|D|H|F)
-            //    Arrows + Home/End without modifiers.
-            const legacyFuncKey = new RegExp(`^${ESC}\\[([ABCDHF])`);
-            m = buffer.match(legacyFuncKey);
-            if (m) {
-                const sym = m[1];
-                const nameMap = {
-                    A: 'up',
-                    B: 'down',
-                    C: 'right',
-                    D: 'left',
-                    H: 'home',
-                    F: 'end',
-                };
-                const name = nameMap[sym];
-                return {
-                    key: {
-                        name,
-                        ctrl: false,
-                        meta: false,
-                        shift: false,
-                        paste: false,
-                        sequence: buffer.slice(0, m[0].length),
-                        kittyProtocol: true,
-                    },
-                    length: m[0].length,
-                };
+            else if (data.startsWith(PASTE_MODE_START)) {
+                keypressHandler(undefined, {
+                    name: 'paste-start',
+                    ctrl: false,
+                    meta: false,
+                    shift: false,
+                    paste: false,
+                    sequence: '',
+                });
+                data = data.slice(PASTE_MODE_START.length);
             }
-            return null;
-        };
-        const broadcast = (key) => {
-            for (const handler of subscribers) {
-                handler(key);
+            else if (data.startsWith(PASTE_MODE_END)) {
+                keypressHandler(undefined, {
+                    name: 'paste-end',
+                    ctrl: false,
+                    meta: false,
+                    shift: false,
+                    paste: false,
+                    sequence: '',
+                });
+                data = data.slice(PASTE_MODE_END.length);
+            }
+            else {
+                // This should never happen.
+                passthrough.write(data);
+                break;
+            }
+        }
+    }
+}
+const KeypressContext = createContext(undefined);
+export function useKeypressContext() {
+    const context = useContext(KeypressContext);
+    if (!context) {
+        throw new Error('useKeypressContext must be used within a KeypressProvider');
+    }
+    return context;
+}
+function shouldUsePassthrough() {
+    return process.env['PASTE_WORKAROUND'] !== 'false';
+}
+export function KeypressProvider({ children, kittyProtocolEnabled, config, debugKeystrokeLogging, }) {
+    const { stdin, setRawMode } = useStdin();
+    const subscribers = useRef(new Set()).current;
+    const subscribe = useCallback((handler) => subscribers.add(handler), [subscribers]);
+    const unsubscribe = useCallback((handler) => subscribers.delete(handler), [subscribers]);
+    const broadcast = useCallback((key) => subscribers.forEach((handler) => handler(key)), [subscribers]);
+    useEffect(() => {
+        const wasRaw = stdin.isRaw;
+        if (wasRaw === false) {
+            setRawMode(true);
+        }
+        const keypressStream = shouldUsePassthrough() ? new PassThrough() : null;
+        // If non-null that means we are in paste mode
+        let pasteBuffer = null;
+        // Used to turn "\" quickly followed by a "enter" into a shift enter
+        let backslashTimeout = null;
+        // Buffers incomplete Kitty sequences and timer to flush it
+        let kittySequenceBuffer = '';
+        let kittySequenceTimeout = null;
+        // Used to detect filename drag-and-drops.
+        let dragBuffer = '';
+        let draggingTimer = null;
+        const clearDraggingTimer = () => {
+            if (draggingTimer) {
+                clearTimeout(draggingTimer);
+                draggingTimer = null;
             }
         };
         const flushKittyBufferOnInterrupt = (reason) => {
@@ -376,36 +465,36 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
             }
             if (key.name === 'paste-start') {
                 flushKittyBufferOnInterrupt('paste start');
-                isPaste = true;
+                pasteBuffer = Buffer.alloc(0);
                 return;
             }
             if (key.name === 'paste-end') {
-                isPaste = false;
-                broadcast({
-                    name: '',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: true,
-                    sequence: pasteBuffer.toString(),
-                });
-                pasteBuffer = Buffer.alloc(0);
+                if (pasteBuffer !== null) {
+                    broadcast({
+                        name: '',
+                        ctrl: false,
+                        meta: false,
+                        shift: false,
+                        paste: true,
+                        sequence: pasteBuffer.toString(),
+                    });
+                }
+                pasteBuffer = null;
                 return;
             }
-            if (isPaste) {
+            if (pasteBuffer !== null) {
                 pasteBuffer = Buffer.concat([pasteBuffer, Buffer.from(key.sequence)]);
                 return;
             }
             if (key.sequence === SINGLE_QUOTE ||
                 key.sequence === DOUBLE_QUOTE ||
-                isDraggingRef.current) {
-                isDraggingRef.current = true;
-                dragBufferRef.current += key.sequence;
+                draggingTimer !== null) {
+                dragBuffer += key.sequence;
                 clearDraggingTimer();
-                draggingTimerRef.current = setTimeout(() => {
-                    isDraggingRef.current = false;
-                    const seq = dragBufferRef.current;
-                    dragBufferRef.current = '';
+                draggingTimer = setTimeout(() => {
+                    draggingTimer = null;
+                    const seq = dragBuffer;
+                    dragBuffer = '';
                     if (seq) {
                         broadcast({ ...key, name: '', paste: true, sequence: seq });
                     }
@@ -419,17 +508,14 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                     ctrl: false,
                     meta: true,
                     shift: false,
-                    paste: isPaste,
+                    paste: pasteBuffer !== null,
                     sequence: key.sequence,
                 });
                 return;
             }
-            if (key.name === 'return' && waitingForEnterAfterBackslash) {
-                if (backslashTimeout) {
-                    clearTimeout(backslashTimeout);
-                    backslashTimeout = null;
-                }
-                waitingForEnterAfterBackslash = false;
+            if (key.name === 'return' && backslashTimeout !== null) {
+                clearTimeout(backslashTimeout);
+                backslashTimeout = null;
                 broadcast({
                     ...key,
                     shift: true,
@@ -439,20 +525,15 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
             }
             if (key.sequence === '\\' && !key.name) {
                 // Corrected escaping for backslash
-                waitingForEnterAfterBackslash = true;
                 backslashTimeout = setTimeout(() => {
-                    waitingForEnterAfterBackslash = false;
                     backslashTimeout = null;
                     broadcast(key);
                 }, BACKSLASH_ENTER_DETECTION_WINDOW_MS);
                 return;
             }
-            if (waitingForEnterAfterBackslash && key.name !== 'return') {
-                if (backslashTimeout) {
-                    clearTimeout(backslashTimeout);
-                    backslashTimeout = null;
-                }
-                waitingForEnterAfterBackslash = false;
+            if (backslashTimeout !== null && key.name !== 'return') {
+                clearTimeout(backslashTimeout);
+                backslashTimeout = null;
                 broadcast({
                     name: '',
                     sequence: '\\',
@@ -501,8 +582,8 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                 // Check if this could start a kitty sequence
                 const startsWithEsc = key.sequence.startsWith(ESC);
                 const isExcluded = [
-                    PASTE_MODE_PREFIX,
-                    PASTE_MODE_SUFFIX,
+                    PASTE_MODE_START,
+                    PASTE_MODE_END,
                     FOCUS_IN,
                     FOCUS_OUT,
                 ].some((prefix) => key.sequence.startsWith(prefix));
@@ -614,74 +695,40 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
             if (key.name === 'return' && key.sequence === `${ESC}\r`) {
                 key.meta = true;
             }
-            broadcast({ ...key, paste: isPaste });
-        };
-        const handleRawKeypress = (data) => {
-            const pasteModePrefixBuffer = Buffer.from(PASTE_MODE_PREFIX);
-            const pasteModeSuffixBuffer = Buffer.from(PASTE_MODE_SUFFIX);
-            let pos = 0;
-            while (pos < data.length) {
-                const prefixPos = data.indexOf(pasteModePrefixBuffer, pos);
-                const suffixPos = data.indexOf(pasteModeSuffixBuffer, pos);
-                const isPrefixNext = prefixPos !== -1 && (suffixPos === -1 || prefixPos < suffixPos);
-                const isSuffixNext = suffixPos !== -1 && (prefixPos === -1 || suffixPos < prefixPos);
-                let nextMarkerPos = -1;
-                let markerLength = 0;
-                if (isPrefixNext) {
-                    nextMarkerPos = prefixPos;
-                }
-                else if (isSuffixNext) {
-                    nextMarkerPos = suffixPos;
-                }
-                markerLength = pasteModeSuffixBuffer.length;
-                if (nextMarkerPos === -1) {
-                    keypressStream.write(data.slice(pos));
-                    return;
-                }
-                const nextData = data.slice(pos, nextMarkerPos);
-                if (nextData.length > 0) {
-                    keypressStream.write(nextData);
-                }
-                const createPasteKeyEvent = (name) => ({
-                    name,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: '',
-                });
-                if (isPrefixNext) {
-                    handleKeypress(undefined, createPasteKeyEvent('paste-start'));
-                }
-                else if (isSuffixNext) {
-                    handleKeypress(undefined, createPasteKeyEvent('paste-end'));
-                }
-                pos = nextMarkerPos + markerLength;
-            }
+            broadcast({ ...key, paste: pasteBuffer !== null });
         };
+        let cleanup = () => { };
         let rl;
-        if (usePassthrough) {
+        if (keypressStream !== null) {
             rl = readline.createInterface({
                 input: keypressStream,
                 escapeCodeTimeout: 0,
             });
             readline.emitKeypressEvents(keypressStream, rl);
+            const parser = pasteMarkerParser(keypressStream, handleKeypress);
+            parser.next(); // prime the generator so it starts listening.
+            let timeoutId;
+            const handleRawKeypress = (data) => {
+                clearTimeout(timeoutId);
+                parser.next(data);
+                timeoutId = setTimeout(() => parser.next(''), PASTE_CODE_TIMEOUT_MS);
+            };
             keypressStream.on('keypress', handleKeypress);
+            process.stdin.setEncoding('utf8'); // so handleRawKeypress gets strings
             stdin.on('data', handleRawKeypress);
+            cleanup = () => {
+                keypressStream.removeListener('keypress', handleKeypress);
+                stdin.removeListener('data', handleRawKeypress);
+            };
         }
         else {
             rl = readline.createInterface({ input: stdin, escapeCodeTimeout: 0 });
             readline.emitKeypressEvents(stdin, rl);
             stdin.on('keypress', handleKeypress);
+            cleanup = () => stdin.removeListener('keypress', handleKeypress);
         }
         return () => {
-            if (usePassthrough) {
-                keypressStream.removeListener('keypress', handleKeypress);
-                stdin.removeListener('data', handleRawKeypress);
-            }
-            else {
-                stdin.removeListener('keypress', handleKeypress);
-            }
+            cleanup();
             rl.close();
             // Restore the terminal to its original state.
             if (wasRaw === false) {
@@ -708,7 +755,7 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                 kittySequenceBuffer = '';
             }
             // Flush any pending paste data to avoid data loss on exit.
-            if (isPaste) {
+            if (pasteBuffer !== null) {
                 broadcast({
                     name: '',
                     ctrl: false,
@@ -717,23 +764,19 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                     paste: true,
                     sequence: pasteBuffer.toString(),
                 });
-                pasteBuffer = Buffer.alloc(0);
-            }
-            if (draggingTimerRef.current) {
-                clearTimeout(draggingTimerRef.current);
-                draggingTimerRef.current = null;
+                pasteBuffer = null;
             }
-            if (isDraggingRef.current && dragBufferRef.current) {
+            clearDraggingTimer();
+            if (dragBuffer) {
                 broadcast({
                     name: '',
                     ctrl: false,
                     meta: false,
                     shift: false,
                     paste: true,
-                    sequence: dragBufferRef.current,
+                    sequence: dragBuffer,
                 });
-                isDraggingRef.current = false;
-                dragBufferRef.current = '';
+                dragBuffer = '';
             }
         };
     }, [
@@ -741,8 +784,8 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
         setRawMode,
         kittyProtocolEnabled,
         config,
-        subscribers,
         debugKeystrokeLogging,
+        broadcast,
     ]);
     return (_jsx(KeypressContext.Provider, { value: { subscribe, unsubscribe }, children: children }));
 }