@machina.ai/cell-cli 1.10.0-rc1 → 1.13.0-rc1

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

@@ -1,179 +1,215 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { KittySequenceOverflowEvent, logKittySequenceOverflow, } from '@google/gemini-cli-core';
+import { debugLogger, KittySequenceOverflowEvent, logKittySequenceOverflow, } from '@google/gemini-cli-core';
 import { useStdin } from 'ink';
 import { createContext, useCallback, useContext, useEffect, useRef, } from 'react';
 import readline from 'node:readline';
 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 { ESC, couldBeMouseSequence } from '../utils/input.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~`;
+import { isIncompleteMouseSequence, parseMouseEvent } from '../utils/mouse.js';
+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 = {
-    '\u00E5': 'a',
-    '\u222B': 'b',
-    '\u00E7': 'c',
-    '\u2202': 'd',
-    '\u00B4': 'e',
-    '\u0192': 'f',
-    '\u00A9': 'g',
-    '\u02D9': 'h',
-    '\u02C6': 'i',
-    '\u2206': 'j',
-    '\u02DA': 'k',
-    '\u00AC': 'l',
-    '\u00B5': 'm',
-    '\u02DC': 'n',
-    '\u00F8': 'o',
-    '\u03C0': 'p',
-    '\u0153': 'q',
-    '\u00AE': 'r',
-    '\u00DF': 's',
-    '\u2020': 't',
-    '\u00A8': 'u',
-    '\u221A': 'v',
-    '\u2211': 'w',
-    '\u2248': 'x',
-    '\u00A5': 'y',
-    '\u03A9': 'z',
+// On Mac, hitting alt+char will yield funny characters.
+// Remap these three since we listen for them.
+const MAC_ALT_KEY_CHARACTER_MAP = {
+    '\u222B': 'b', // "∫" back one word
+    '\u0192': 'f', // "ƒ" forward one word
+    '\u00B5': 'm', // "µ" toggle markup view
 };
-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;
+/**
+ * Maps symbols from parameterized functional keys `\x1b[1;1<letter>`
+ * to their corresponding key names (e.g., 'up', 'f1').
+ */
+const LEGACY_FUNC_TO_NAME = {
+    A: 'up',
+    B: 'down',
+    C: 'right',
+    D: 'left',
+    H: 'home',
+    F: 'end',
+    P: 'f1',
+    Q: 'f2',
+    R: 'f3',
+    S: 'f4',
+};
+/**
+ * Maps key codes from tilde-coded functional keys `\x1b[<code>~`
+ * to their corresponding key names.
+ */
+const TILDE_KEYCODE_TO_NAME = {
+    1: 'home',
+    2: 'insert',
+    3: 'delete',
+    4: 'end',
+    5: 'pageup',
+    6: 'pagedown',
+    11: 'f1',
+    12: 'f2',
+    13: 'f3',
+    14: 'f4',
+    15: 'f5',
+    17: 'f6', // skipping 16 is intentional
+    18: 'f7',
+    19: 'f8',
+    20: 'f9',
+    21: 'f10',
+    23: 'f11', // skipping 22 is intentional
+    24: 'f12',
+};
+/**
+ * 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;
+    if (couldBeMouseSequence(buffer))
+        return true;
+    // 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: false,
+            },
+            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 backslashTimeout = null;
-        let waitingForEnterAfterBackslash = false;
-        // 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 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 name = LEGACY_FUNC_TO_NAME[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 === '~') {
+            const name = TILDE_KEYCODE_TO_NAME[keyCode];
+            if (name) {
                 return {
                     key: {
                         name,
@@ -182,202 +218,284 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                         shift,
                         paste: false,
                         sequence: buffer.slice(0, m[0].length),
-                        kittyProtocol: true,
+                        kittyProtocol: false,
                     },
                     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 name = LEGACY_FUNC_TO_NAME[sym];
+        return {
+            key: {
+                name,
+                ctrl: false,
+                meta: false,
+                shift: false,
+                paste: false,
+                sequence: buffer.slice(0, m[0].length),
+                kittyProtocol: false,
+            },
+            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);
+            }
+            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 sequences (Kitty or Mouse) and timer to flush it
+        let inputBuffer = '';
+        let inputTimeout = null;
+        // Used to detect filename drag-and-drops.
+        let dragBuffer = '';
+        let draggingTimer = null;
+        const clearDraggingTimer = () => {
+            if (draggingTimer) {
+                clearTimeout(draggingTimer);
+                draggingTimer = null;
             }
-            return null;
         };
-        const broadcast = (key) => {
-            for (const handler of subscribers) {
-                handler(key);
+        const flushInputBufferOnInterrupt = (reason) => {
+            if (inputBuffer) {
+                if (debugKeystrokeLogging) {
+                    debugLogger.log(`[DEBUG] Input sequence flushed due to ${reason}:`, JSON.stringify(inputBuffer));
+                }
+                broadcast({
+                    name: '',
+                    ctrl: false,
+                    meta: false,
+                    shift: false,
+                    paste: false,
+                    sequence: inputBuffer,
+                });
+                inputBuffer = '';
+            }
+            if (inputTimeout) {
+                clearTimeout(inputTimeout);
+                inputTimeout = null;
             }
         };
         const handleKeypress = (_, key) => {
             if (key.sequence === FOCUS_IN || key.sequence === FOCUS_OUT) {
+                flushInputBufferOnInterrupt('focus event');
                 return;
             }
             if (key.name === 'paste-start') {
-                isPaste = true;
+                flushInputBufferOnInterrupt('paste start');
+                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 });
                     }
                 }, DRAG_COMPLETION_TIMEOUT_MS);
                 return;
             }
-            const mappedLetter = ALT_KEY_CHARACTER_MAP[key.sequence];
-            if (mappedLetter && !key.meta) {
+            const mappedLetter = MAC_ALT_KEY_CHARACTER_MAP[key.sequence];
+            if (process.platform === 'darwin' && mappedLetter && !key.meta) {
                 broadcast({
                     name: mappedLetter,
                     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,
@@ -387,20 +505,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: '\\',
@@ -416,10 +529,14 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
             }
             if ((key.ctrl && key.name === 'c') ||
                 key.sequence === `${ESC}${KITTY_CTRL_C}`) {
-                if (kittySequenceBuffer && debugKeystrokeLogging) {
-                    console.log('[DEBUG] Kitty buffer cleared on Ctrl+C:', kittySequenceBuffer);
+                if (inputBuffer && debugKeystrokeLogging) {
+                    debugLogger.log('[DEBUG] Input buffer cleared on Ctrl+C:', inputBuffer);
+                }
+                inputBuffer = '';
+                if (inputTimeout) {
+                    clearTimeout(inputTimeout);
+                    inputTimeout = null;
                 }
-                kittySequenceBuffer = '';
                 if (key.sequence === `${ESC}${KITTY_CTRL_C}`) {
                     broadcast({
                         name: 'c',
@@ -436,142 +553,209 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                 }
                 return;
             }
-            if (kittyProtocolEnabled) {
-                if (kittySequenceBuffer ||
-                    (key.sequence.startsWith(`${ESC}[`) &&
-                        !key.sequence.startsWith(PASTE_MODE_PREFIX) &&
-                        !key.sequence.startsWith(PASTE_MODE_SUFFIX) &&
-                        !key.sequence.startsWith(FOCUS_IN) &&
-                        !key.sequence.startsWith(FOCUS_OUT))) {
-                    kittySequenceBuffer += key.sequence;
-                    if (debugKeystrokeLogging) {
-                        console.log('[DEBUG] Kitty buffer accumulating:', kittySequenceBuffer);
-                    }
-                    // Try to peel off as many complete sequences as are available at the
-                    // start of the buffer. This handles batched inputs cleanly. If the
-                    // prefix is incomplete or invalid, skip to the next CSI introducer
-                    // (ESC[) so that a following valid sequence can still be parsed.
-                    let parsedAny = false;
-                    while (kittySequenceBuffer) {
-                        const parsed = parseKittyPrefix(kittySequenceBuffer);
-                        if (!parsed) {
-                            // Look for the next potential CSI start beyond index 0
-                            const nextStart = kittySequenceBuffer.indexOf(`${ESC}[`, 1);
-                            if (nextStart > 0) {
-                                if (debugKeystrokeLogging) {
-                                    console.log('[DEBUG] Skipping incomplete/invalid CSI prefix:', kittySequenceBuffer.slice(0, nextStart));
-                                }
-                                kittySequenceBuffer = kittySequenceBuffer.slice(nextStart);
-                                continue;
+            // Clear any pending timeout when new input arrives
+            if (inputTimeout) {
+                clearTimeout(inputTimeout);
+                inputTimeout = null;
+            }
+            // Always check if this could start a sequence we need to buffer (Kitty or Mouse)
+            // Other ESC sequences (like Alt+Key which is ESC+Key) should be let through if readline parsed them.
+            const shouldBuffer = couldBeKittySequence(key.sequence);
+            const isExcluded = [
+                PASTE_MODE_START,
+                PASTE_MODE_END,
+                FOCUS_IN,
+                FOCUS_OUT,
+            ].some((prefix) => key.sequence.startsWith(prefix));
+            if (inputBuffer || (shouldBuffer && !isExcluded)) {
+                inputBuffer += key.sequence;
+                if (debugKeystrokeLogging && !couldBeMouseSequence(inputBuffer)) {
+                    debugLogger.log('[DEBUG] Input buffer accumulating:', JSON.stringify(inputBuffer));
+                }
+                // Try immediate parsing
+                let remainingBuffer = inputBuffer;
+                let parsedAny = false;
+                while (remainingBuffer) {
+                    const parsed = parseKittyPrefix(remainingBuffer);
+                    if (parsed) {
+                        // If kitty protocol is disabled, only allow legacy/standard sequences.
+                        // parseKittyPrefix returns true for kittyProtocol if it's a modern kitty sequence.
+                        if (kittyProtocolEnabled || !parsed.key.kittyProtocol) {
+                            if (debugKeystrokeLogging) {
+                                const parsedSequence = remainingBuffer.slice(0, parsed.length);
+                                debugLogger.log('[DEBUG] Sequence parsed successfully:', JSON.stringify(parsedSequence));
                             }
-                            break;
+                            broadcast(parsed.key);
+                            remainingBuffer = remainingBuffer.slice(parsed.length);
+                            parsedAny = true;
+                            continue;
                         }
-                        if (debugKeystrokeLogging) {
-                            const parsedSequence = kittySequenceBuffer.slice(0, parsed.length);
-                            if (kittySequenceBuffer.length > parsed.length) {
-                                console.log('[DEBUG] Kitty sequence parsed successfully (prefix):', parsedSequence);
+                    }
+                    const mouseParsed = parseMouseEvent(remainingBuffer);
+                    if (mouseParsed) {
+                        // These are handled by the separate mouse sequence parser.
+                        // All we need to do is make sure we don't get confused by these
+                        // sequences.
+                        remainingBuffer = remainingBuffer.slice(mouseParsed.length);
+                        parsedAny = true;
+                        continue;
+                    }
+                    // If we can't parse a sequence at the start, check if there's
+                    // another ESC later in the buffer. If so, the data before it
+                    // is garbage/incomplete and should be dropped so we can
+                    // process the next sequence.
+                    const nextEscIndex = remainingBuffer.indexOf(ESC, 1);
+                    if (nextEscIndex !== -1) {
+                        const garbage = remainingBuffer.slice(0, nextEscIndex);
+                        // Special case: if garbage is exactly ESC, it's likely a rapid ESC press.
+                        if (garbage === ESC) {
+                            if (debugKeystrokeLogging) {
+                                debugLogger.log('[DEBUG] Flushing rapid ESC before next ESC:', JSON.stringify(garbage));
                             }
-                            else {
-                                console.log('[DEBUG] Kitty sequence parsed successfully:', parsedSequence);
+                            broadcast({
+                                name: 'escape',
+                                ctrl: false,
+                                meta: true,
+                                shift: false,
+                                paste: false,
+                                sequence: garbage,
+                            });
+                        }
+                        else {
+                            if (debugKeystrokeLogging) {
+                                debugLogger.log('[DEBUG] Dropping incomplete sequence before next ESC:', JSON.stringify(garbage));
                             }
                         }
-                        // Consume the parsed prefix and broadcast it.
-                        kittySequenceBuffer = kittySequenceBuffer.slice(parsed.length);
-                        broadcast(parsed.key);
-                        parsedAny = true;
+                        // Continue parsing from next ESC
+                        remainingBuffer = remainingBuffer.slice(nextEscIndex);
+                        // We made progress, so we can continue the loop to parse the next sequence
+                        continue;
                     }
-                    if (parsedAny)
-                        return;
-                    if (config?.getDebugMode() || debugKeystrokeLogging) {
-                        const codes = Array.from(kittySequenceBuffer).map((ch) => ch.charCodeAt(0));
-                        console.warn('Kitty sequence buffer has char codes:', codes);
+                    // Check if buffer could become a valid sequence
+                    const couldBeValidKitty = kittyProtocolEnabled && couldBeKittySequence(remainingBuffer);
+                    const isMouse = isIncompleteMouseSequence(remainingBuffer);
+                    const couldBeValid = couldBeValidKitty || isMouse;
+                    if (!couldBeValid) {
+                        // Not a valid sequence - flush as regular input immediately
+                        if (debugKeystrokeLogging) {
+                            debugLogger.log('[DEBUG] Not a valid sequence, flushing:', JSON.stringify(remainingBuffer));
+                        }
+                        broadcast({
+                            name: '',
+                            ctrl: false,
+                            meta: false,
+                            shift: false,
+                            paste: false,
+                            sequence: remainingBuffer,
+                        });
+                        remainingBuffer = '';
+                        parsedAny = true;
                     }
-                    if (kittySequenceBuffer.length > MAX_KITTY_SEQUENCE_LENGTH) {
+                    else if (remainingBuffer.length > MAX_KITTY_SEQUENCE_LENGTH) {
+                        // Buffer overflow - log and clear
                         if (debugKeystrokeLogging) {
-                            console.log('[DEBUG] Kitty buffer overflow, clearing:', kittySequenceBuffer);
+                            debugLogger.log('[DEBUG] Input buffer overflow, clearing:', JSON.stringify(remainingBuffer));
                         }
-                        if (config) {
-                            const event = new KittySequenceOverflowEvent(kittySequenceBuffer.length, kittySequenceBuffer);
+                        if (config && kittyProtocolEnabled) {
+                            const event = new KittySequenceOverflowEvent(remainingBuffer.length, remainingBuffer);
                             logKittySequenceOverflow(config, event);
                         }
-                        kittySequenceBuffer = '';
+                        // Flush as regular input
+                        broadcast({
+                            name: '',
+                            ctrl: false,
+                            meta: false,
+                            shift: false,
+                            paste: false,
+                            sequence: remainingBuffer,
+                        });
+                        remainingBuffer = '';
+                        parsedAny = true;
                     }
                     else {
-                        return;
+                        if ((config?.getDebugMode() || debugKeystrokeLogging) &&
+                            !couldBeMouseSequence(inputBuffer)) {
+                            debugLogger.warn('Input sequence buffer has content:', JSON.stringify(inputBuffer));
+                        }
+                        // Could be valid but incomplete - set timeout
+                        // Only set timeout if it's NOT a mouse sequence.
+                        // Mouse sequences might be slow (e.g. over network) and we don't want to
+                        // flush them as garbage keypresses.
+                        // However, if it's just ESC or ESC[, it might be a user typing slowly,
+                        // so we should still timeout in that case.
+                        const isAmbiguousPrefix = remainingBuffer === ESC || remainingBuffer === `${ESC}[`;
+                        if (!isMouse || isAmbiguousPrefix) {
+                            inputTimeout = setTimeout(() => {
+                                if (inputBuffer) {
+                                    if (debugKeystrokeLogging) {
+                                        debugLogger.log('[DEBUG] Input sequence timeout, flushing:', JSON.stringify(inputBuffer));
+                                    }
+                                    const isEscape = inputBuffer === ESC;
+                                    broadcast({
+                                        name: isEscape ? 'escape' : '',
+                                        ctrl: false,
+                                        meta: isEscape,
+                                        shift: false,
+                                        paste: false,
+                                        sequence: inputBuffer,
+                                    });
+                                    inputBuffer = '';
+                                }
+                                inputTimeout = null;
+                            }, KITTY_SEQUENCE_TIMEOUT_MS);
+                        }
+                        else {
+                            // It IS a mouse sequence and it's long enough to be unambiguously NOT just a user hitting ESC slowly.
+                            // We just wait for more data.
+                            if (inputTimeout) {
+                                clearTimeout(inputTimeout);
+                                inputTimeout = null;
+                            }
+                        }
+                        break;
                     }
                 }
+                inputBuffer = remainingBuffer;
+                if (parsedAny || inputBuffer)
+                    return;
             }
             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) {
@@ -581,8 +765,24 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
                 clearTimeout(backslashTimeout);
                 backslashTimeout = null;
             }
+            if (inputTimeout) {
+                clearTimeout(inputTimeout);
+                inputTimeout = null;
+            }
+            // Flush any pending kitty sequence data to avoid data loss on exit.
+            if (inputBuffer) {
+                broadcast({
+                    name: '',
+                    ctrl: false,
+                    meta: false,
+                    shift: false,
+                    paste: false,
+                    sequence: inputBuffer,
+                });
+                inputBuffer = '';
+            }
             // Flush any pending paste data to avoid data loss on exit.
-            if (isPaste) {
+            if (pasteBuffer !== null) {
                 broadcast({
                     name: '',
                     ctrl: false,
@@ -591,23 +791,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 = '';
             }
         };
     }, [
@@ -615,8 +811,8 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
         setRawMode,
         kittyProtocolEnabled,
         config,
-        subscribers,
         debugKeystrokeLogging,
+        broadcast,
     ]);
     return (_jsx(KeypressContext.Provider, { value: { subscribe, unsubscribe }, children: children }));
 }