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

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

@@ -1,7 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { renderHook, act, waitFor } from '@testing-library/react';
+import { act } from 'react';
+import { renderHook } from '../../test-utils/render.js';
+import { waitFor } from '../../test-utils/async.js';
 import { vi } from 'vitest';
-import { KeypressProvider, useKeypressContext, DRAG_COMPLETION_TIMEOUT_MS, 
+import { KeypressProvider, useKeypressContext, DRAG_COMPLETION_TIMEOUT_MS, KITTY_SEQUENCE_TIMEOUT_MS, 
 // CSI_END_O,
 // SS3_END,
 SINGLE_QUOTE, DOUBLE_QUOTE, } from './KeypressContext.js';
@@ -15,35 +17,34 @@ vi.mock('ink', async (importOriginal) => {
         useStdin: vi.fn(),
     };
 });
+const PASTE_START = '\x1B[200~';
+const PASTE_END = '\x1B[201~';
+// readline will not emit most incomplete kitty sequences but it will give
+// up on sequences like this where the modifier (135) has more than two digits.
+const INCOMPLETE_KITTY_SEQUENCE = '\x1b[97;135';
 class MockStdin extends EventEmitter {
     isTTY = true;
     setRawMode = vi.fn();
     on = this.addListener;
     removeListener = super.removeListener;
-    write = vi.fn();
     resume = vi.fn();
     pause = vi.fn();
-    // Helper to simulate a keypress event
-    pressKey(key) {
-        this.emit('keypress', null, key);
-    }
-    // Helper to simulate a kitty protocol sequence
-    sendKittySequence(sequence) {
-        this.emit('data', Buffer.from(sequence));
-    }
-    // Helper to simulate a paste event
-    sendPaste(text) {
-        const PASTE_MODE_PREFIX = `\x1b[200~`;
-        const PASTE_MODE_SUFFIX = `\x1b[201~`;
-        this.emit('data', Buffer.from(PASTE_MODE_PREFIX));
-        this.emit('data', Buffer.from(text));
-        this.emit('data', Buffer.from(PASTE_MODE_SUFFIX));
+    write(text) {
+        this.emit('data', text);
     }
 }
+// Helper function to setup keypress test with standard configuration
+const setupKeypressTest = (kittyProtocolEnabled = true) => {
+    const keyHandler = vi.fn();
+    const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: kittyProtocolEnabled, children: children }));
+    const { result } = renderHook(() => useKeypressContext(), { wrapper });
+    act(() => result.current.subscribe(keyHandler));
+    return { result, keyHandler };
+};
 describe('KeypressContext - Kitty Protocol', () => {
     let stdin;
     const mockSetRawMode = vi.fn();
-    const wrapper = ({ children, kittyProtocolEnabled = true, }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: kittyProtocolEnabled, children: children }));
+    const wrapper = ({ children, kittyProtocolEnabled = true, }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: kittyProtocolEnabled ?? false, children: children }));
     beforeEach(() => {
         vi.clearAllMocks();
         stdin = new MockStdin();
@@ -53,117 +54,58 @@ describe('KeypressContext - Kitty Protocol', () => {
         });
     });
     describe('Enter key handling', () => {
-        it('should recognize regular enter key (keycode 13) in kitty protocol', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Send kitty protocol sequence for regular enter: ESC[13u
-            act(() => {
-                stdin.sendKittySequence(`\x1b[13u`);
-            });
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'return',
-                kittyProtocol: true,
-                ctrl: false,
-                meta: false,
-                shift: false,
-            }));
-        });
-        it('should recognize numpad enter key (keycode 57414) in kitty protocol', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Send kitty protocol sequence for numpad enter: ESC[57414u
-            act(() => {
-                stdin.sendKittySequence(`\x1b[57414u`);
-            });
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'return',
-                kittyProtocol: true,
-                ctrl: false,
-                meta: false,
-                shift: false,
-            }));
-        });
-        it('should handle numpad enter with modifiers', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Send kitty protocol sequence for numpad enter with Shift (modifier 2): ESC[57414;2u
+        it.each([
+            {
+                name: 'regular enter key (keycode 13)',
+                sequence: '\x1b[13u',
+            },
+            {
+                name: 'numpad enter key (keycode 57414)',
+                sequence: '\x1b[57414u',
+            },
+        ])('should recognize $name in kitty protocol', async ({ sequence }) => {
+            const { keyHandler } = setupKeypressTest(true);
             act(() => {
-                stdin.sendKittySequence(`\x1b[57414;2u`);
+                stdin.write(sequence);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'return',
                 kittyProtocol: true,
                 ctrl: false,
                 meta: false,
-                shift: true,
-            }));
-        });
-        it('should handle numpad enter with Ctrl modifier', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Send kitty protocol sequence for numpad enter with Ctrl (modifier 5): ESC[57414;5u
-            act(() => {
-                stdin.sendKittySequence(`\x1b[57414;5u`);
-            });
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'return',
-                kittyProtocol: true,
-                ctrl: true,
-                meta: false,
                 shift: false,
             }));
         });
-        it('should handle numpad enter with Alt modifier', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Send kitty protocol sequence for numpad enter with Alt (modifier 3): ESC[57414;3u
-            act(() => {
-                stdin.sendKittySequence(`\x1b[57414;3u`);
-            });
+        it.each([
+            {
+                modifier: 'Shift',
+                sequence: '\x1b[57414;2u',
+                expected: { ctrl: false, meta: false, shift: true },
+            },
+            {
+                modifier: 'Ctrl',
+                sequence: '\x1b[57414;5u',
+                expected: { ctrl: true, meta: false, shift: false },
+            },
+            {
+                modifier: 'Alt',
+                sequence: '\x1b[57414;3u',
+                expected: { ctrl: false, meta: true, shift: false },
+            },
+        ])('should handle numpad enter with $modifier modifier', async ({ sequence, expected }) => {
+            const { keyHandler } = setupKeypressTest(true);
+            act(() => stdin.write(sequence));
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'return',
                 kittyProtocol: true,
-                ctrl: false,
-                meta: true,
-                shift: false,
+                ...expected,
             }));
         });
         it('should not process kitty sequences when kitty protocol is disabled', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: false }),
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            const { keyHandler } = setupKeypressTest(false);
             // Send kitty protocol sequence for numpad enter
             act(() => {
-                stdin.sendKittySequence(`\x1b[57414u`);
+                stdin.write(`\x1b[57414u`);
             });
             // When kitty protocol is disabled, the sequence should be passed through
             // as individual keypresses, not recognized as a single enter key
@@ -175,112 +117,115 @@ describe('KeypressContext - Kitty Protocol', () => {
     });
     describe('Escape key handling', () => {
         it('should recognize escape key (keycode 27) in kitty protocol', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            const { keyHandler } = setupKeypressTest(true);
             // Send kitty protocol sequence for escape: ESC[27u
             act(() => {
-                stdin.sendKittySequence('\x1b[27u');
+                stdin.write('\x1b[27u');
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'escape',
                 kittyProtocol: true,
             }));
         });
-    });
-    describe('Tab and Backspace handling', () => {
-        it('should recognize Tab key in kitty protocol', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            act(() => {
-                stdin.sendKittySequence(`\x1b[9u`);
-            });
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'tab',
-                kittyProtocol: true,
-                shift: false,
-            }));
-        });
-        it('should recognize Shift+Tab in kitty protocol', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            // Modifier 2 is Shift
-            act(() => {
-                stdin.sendKittySequence(`\x1b[9;2u`);
-            });
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'tab',
-                kittyProtocol: true,
-                shift: true,
-            }));
-        });
-        it('should recognize Backspace key in kitty protocol', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            act(() => {
-                stdin.sendKittySequence(`\x1b[127u`);
-            });
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'backspace',
-                kittyProtocol: true,
-                meta: false,
-            }));
-        });
-        it('should recognize Option+Backspace in kitty protocol', async () => {
+        it('should handle lone Escape key (keycode 27) with timeout when kitty protocol is enabled', async () => {
+            // Use real timers for this test to avoid issues with stream/buffer timing
+            vi.useRealTimers();
             const keyHandler = vi.fn();
+            const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, children: children }));
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
             act(() => result.current.subscribe(keyHandler));
-            // Modifier 3 is Alt/Option
+            // Send just ESC
             act(() => {
-                stdin.sendKittySequence(`\x1b[127;3u`);
+                stdin.write('\x1b');
             });
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'backspace',
-                kittyProtocol: true,
-                meta: true,
-            }));
+            // Should be buffered initially
+            expect(keyHandler).not.toHaveBeenCalled();
+            // Wait for timeout
+            await waitFor(() => {
+                expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    name: 'escape',
+                    meta: true,
+                }));
+            }, { timeout: 500 });
         });
-        it('should recognize Ctrl+Backspace in kitty protocol', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            // Modifier 5 is Ctrl
+    });
+    describe('Tab and Backspace handling', () => {
+        it.each([
+            {
+                name: 'Tab key',
+                sequence: '\x1b[9u',
+                expected: { name: 'tab', shift: false },
+            },
+            {
+                name: 'Shift+Tab',
+                sequence: '\x1b[9;2u',
+                expected: { name: 'tab', shift: true },
+            },
+            {
+                name: 'Backspace',
+                sequence: '\x1b[127u',
+                expected: { name: 'backspace', meta: false },
+            },
+            {
+                name: 'Option+Backspace',
+                sequence: '\x1b[127;3u',
+                expected: { name: 'backspace', meta: true },
+            },
+            {
+                name: 'Ctrl+Backspace',
+                sequence: '\x1b[127;5u',
+                expected: { name: 'backspace', ctrl: true },
+            },
+        ])('should recognize $name in kitty protocol', async ({ sequence, expected }) => {
+            const { keyHandler } = setupKeypressTest(true);
             act(() => {
-                stdin.sendKittySequence(`\x1b[127;5u`);
+                stdin.write(sequence);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'backspace',
+                ...expected,
                 kittyProtocol: true,
-                ctrl: true,
             }));
         });
     });
     describe('paste mode', () => {
-        it('should handle multiline paste as a single event', async () => {
+        it.each([
+            {
+                name: 'handle multiline paste as a single event',
+                pastedText: 'This \n is \n a \n multiline \n paste.',
+                writeSequence: (text) => {
+                    stdin.write(PASTE_START);
+                    stdin.write(text);
+                    stdin.write(PASTE_END);
+                },
+            },
+            {
+                name: 'handle paste start code split over multiple writes',
+                pastedText: 'pasted content',
+                writeSequence: (text) => {
+                    stdin.write(PASTE_START.slice(0, 3));
+                    stdin.write(PASTE_START.slice(3));
+                    stdin.write(text);
+                    stdin.write(PASTE_END);
+                },
+            },
+            {
+                name: 'handle paste end code split over multiple writes',
+                pastedText: 'pasted content',
+                writeSequence: (text) => {
+                    stdin.write(PASTE_START);
+                    stdin.write(text);
+                    stdin.write(PASTE_END.slice(0, 3));
+                    stdin.write(PASTE_END.slice(3));
+                },
+            },
+        ])('should $name', async ({ pastedText, writeSequence }) => {
             const keyHandler = vi.fn();
-            const pastedText = 'This \n is \n a \n multiline \n paste.';
-            const { result } = renderHook(() => useKeypressContext(), {
-                wrapper,
-            });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Simulate a bracketed paste event
-            act(() => {
-                stdin.sendPaste(pastedText);
-            });
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => writeSequence(pastedText));
             await waitFor(() => {
-                // Expect the handler to be called exactly once for the entire paste
                 expect(keyHandler).toHaveBeenCalledTimes(1);
             });
-            // Verify the single event contains the full pasted text
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 paste: true,
                 sequence: pastedText,
@@ -302,12 +247,10 @@ describe('KeypressContext - Kitty Protocol', () => {
             const keyHandler = vi.fn();
             const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, debugKeystrokeLogging: false, children: children }));
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Send a kitty sequence
             act(() => {
-                stdin.sendKittySequence('\x1b[27u');
+                stdin.write('\x1b[27u');
             });
             expect(keyHandler).toHaveBeenCalled();
             expect(consoleLogSpy).not.toHaveBeenCalledWith(expect.stringContaining('[DEBUG] Kitty'));
@@ -316,61 +259,34 @@ describe('KeypressContext - Kitty Protocol', () => {
             const keyHandler = vi.fn();
             const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, debugKeystrokeLogging: true, children: children }));
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Send a complete kitty sequence for escape
-            act(() => {
-                stdin.sendKittySequence('\x1b[27u');
-            });
-            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Kitty buffer accumulating:', expect.stringContaining('\x1b[27u'));
+            act(() => stdin.write('\x1b[27u'));
+            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Input buffer accumulating:', expect.stringContaining('"\\u001b[27u"'));
             const parsedCall = consoleLogSpy.mock.calls.find((args) => typeof args[0] === 'string' &&
-                args[0].includes('[DEBUG] Kitty sequence parsed successfully'));
+                args[0].includes('[DEBUG] Sequence parsed successfully'));
             expect(parsedCall).toBeTruthy();
-            expect(parsedCall?.[1]).toEqual(expect.stringContaining('\x1b[27u'));
+            expect(parsedCall?.[1]).toEqual(expect.stringContaining('\\u001b[27u'));
         });
         it('should log kitty buffer overflow when debugKeystrokeLogging is true', async () => {
             const keyHandler = vi.fn();
             const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, debugKeystrokeLogging: true, children: children }));
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Send an invalid long sequence to trigger overflow
-            const longInvalidSequence = '\x1b[' + 'x'.repeat(100);
-            act(() => {
-                stdin.sendKittySequence(longInvalidSequence);
-            });
-            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Kitty buffer overflow, clearing:', expect.any(String));
+            act(() => result.current.subscribe(keyHandler));
+            // Send a long sequence starting with a valid kitty prefix to trigger overflow
+            const longSequence = '\x1b[1;' + '1'.repeat(100);
+            act(() => stdin.write(longSequence));
+            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Input buffer overflow, clearing:', expect.any(String));
         });
         it('should log kitty buffer clear on Ctrl+C when debugKeystrokeLogging is true', async () => {
             const keyHandler = vi.fn();
             const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, debugKeystrokeLogging: true, children: children }));
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Send incomplete kitty sequence
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    sequence: '\x1b[1',
-                });
-            });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
             // Send Ctrl+C
-            act(() => {
-                stdin.pressKey({
-                    name: 'c',
-                    ctrl: true,
-                    meta: false,
-                    shift: false,
-                    sequence: '\x03',
-                });
-            });
-            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Kitty buffer cleared on Ctrl+C:', '\x1b[1');
+            act(() => stdin.write('\x03'));
+            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Input buffer cleared on Ctrl+C:', INCOMPLETE_KITTY_SEQUENCE);
             // Verify Ctrl+C was handled
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'c',
@@ -381,24 +297,13 @@ describe('KeypressContext - Kitty Protocol', () => {
             const keyHandler = vi.fn();
             const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, debugKeystrokeLogging: true, children: children }));
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Send incomplete kitty sequence
-            const sequence = '\x1b[12';
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    sequence,
-                });
-            });
+            act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
             // Verify debug logging for accumulation
-            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Kitty buffer accumulating:', sequence);
+            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Input buffer accumulating:', JSON.stringify(INCOMPLETE_KITTY_SEQUENCE));
             // Verify warning for char codes
-            expect(consoleWarnSpy).toHaveBeenCalledWith('Kitty sequence buffer has char codes:', [27, 91, 49, 50]);
+            expect(consoleWarnSpy).toHaveBeenCalledWith('Input sequence buffer has content:', JSON.stringify(INCOMPLETE_KITTY_SEQUENCE));
         });
     });
     describe('Parameterized functional keys', () => {
@@ -414,6 +319,13 @@ describe('KeypressContext - Kitty Protocol', () => {
             { sequence: `\x1b[1~`, expected: { name: 'home' } },
             { sequence: `\x1b[4~`, expected: { name: 'end' } },
             { sequence: `\x1b[2~`, expected: { name: 'insert' } },
+            { sequence: `\x1b[11~`, expected: { name: 'f1' } },
+            { sequence: `\x1b[17~`, expected: { name: 'f6' } },
+            { sequence: `\x1b[23~`, expected: { name: 'f11' } },
+            { sequence: `\x1b[24~`, expected: { name: 'f12' } },
+            // Reverse tabs
+            { sequence: `\x1b[Z`, expected: { name: 'tab', shift: true } },
+            { sequence: `\x1b[1;2Z`, expected: { name: 'tab', shift: true } },
             // Legacy Arrows
             {
                 sequence: `\x1b[A`,
@@ -444,56 +356,32 @@ describe('KeypressContext - Kitty Protocol', () => {
             const keyHandler = vi.fn();
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
             act(() => result.current.subscribe(keyHandler));
-            act(() => stdin.sendKittySequence(sequence));
+            act(() => stdin.write(sequence));
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining(expected));
         });
     });
-    describe('Shift+Tab forms', () => {
-        it.each([
-            { sequence: `\x1b[Z`, description: 'legacy reverse Tab' },
-            { sequence: `\x1b[1;2Z`, description: 'parameterized reverse Tab' },
-        ])('should recognize $description "$sequence" as Shift+Tab', ({ sequence }) => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            act(() => stdin.sendKittySequence(sequence));
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({ name: 'tab', shift: true }));
-        });
-    });
     describe('Double-tap and batching', () => {
         it('should emit two delete events for double-tap CSI[3~', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            act(() => stdin.sendKittySequence(`\x1b[3~`));
-            act(() => stdin.sendKittySequence(`\x1b[3~`));
+            const { keyHandler } = setupKeypressTest(true);
+            act(() => stdin.write(`\x1b[3~`));
+            act(() => stdin.write(`\x1b[3~`));
             expect(keyHandler).toHaveBeenNthCalledWith(1, expect.objectContaining({ name: 'delete' }));
             expect(keyHandler).toHaveBeenNthCalledWith(2, expect.objectContaining({ name: 'delete' }));
         });
         it('should parse two concatenated tilde-coded sequences in one chunk', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            act(() => stdin.sendKittySequence(`\x1b[3~\x1b[5~`));
+            const { keyHandler } = setupKeypressTest(true);
+            act(() => stdin.write(`\x1b[3~\x1b[5~`));
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({ name: 'delete' }));
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({ name: 'pageup' }));
         });
         it('should ignore incomplete CSI then parse the next complete sequence', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
+            const { keyHandler } = setupKeypressTest(true);
             // Incomplete ESC sequence then a complete Delete
             act(() => {
                 // Provide an incomplete ESC sequence chunk with a real ESC character
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    sequence: '\x1b[1;',
-                });
+                stdin.write('\x1b[1;');
             });
-            act(() => stdin.sendKittySequence(`\x1b[3~`));
+            act(() => stdin.write(`\x1b[3~`));
             expect(keyHandler).toHaveBeenCalledTimes(1);
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({ name: 'delete' }));
         });
@@ -502,7 +390,7 @@ describe('KeypressContext - Kitty Protocol', () => {
 describe('Drag and Drop Handling', () => {
     let stdin;
     const mockSetRawMode = vi.fn();
-    const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, children: children }));
+    const wrapper = ({ children, kittyProtocolEnabled = true, }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: kittyProtocolEnabled, children: children }));
     beforeEach(() => {
         vi.clearAllMocks();
         vi.useFakeTimers();
@@ -516,254 +404,150 @@ describe('Drag and Drop Handling', () => {
         vi.useRealTimers();
     });
     describe('drag start by quotes', () => {
-        it('should start collecting when single quote arrives and not broadcast immediately', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: SINGLE_QUOTE,
-                });
-            });
-            expect(keyHandler).not.toHaveBeenCalled();
-        });
-        it('should start collecting when double quote arrives and not broadcast immediately', async () => {
+        it.each([
+            { name: 'single quote', quote: SINGLE_QUOTE },
+            { name: 'double quote', quote: DOUBLE_QUOTE },
+        ])('should start collecting when $name arrives and not broadcast immediately', async ({ quote }) => {
             const keyHandler = vi.fn();
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: DOUBLE_QUOTE,
-                });
-            });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => stdin.write(quote));
             expect(keyHandler).not.toHaveBeenCalled();
         });
     });
     describe('drag collection and completion', () => {
-        it('should collect single character inputs during drag mode', async () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Start by single quote
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: SINGLE_QUOTE,
-                });
-            });
-            // Send single character
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: 'a',
-                });
-            });
-            // Character should not be immediately broadcast
-            expect(keyHandler).not.toHaveBeenCalled();
-            // Fast-forward to completion timeout
-            act(() => {
-                vi.advanceTimersByTime(DRAG_COMPLETION_TIMEOUT_MS + 10);
-            });
-            // Should broadcast the collected path as paste (includes starting quote)
-            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-                name: '',
-                paste: true,
-                sequence: `${SINGLE_QUOTE}a`,
-            }));
-        });
-        it('should collect multiple characters and complete on timeout', async () => {
+        it.each([
+            {
+                name: 'collect single character inputs during drag mode',
+                characters: ['a'],
+                expectedText: 'a',
+            },
+            {
+                name: 'collect multiple characters and complete on timeout',
+                characters: ['p', 'a', 't', 'h'],
+                expectedText: 'path',
+            },
+        ])('should $name', async ({ characters, expectedText }) => {
             const keyHandler = vi.fn();
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
-            // Start by single quote
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: SINGLE_QUOTE,
-                });
-            });
-            // Send multiple characters
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: 'p',
-                });
-            });
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: 'a',
-                });
-            });
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: 't',
-                });
-            });
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: 'h',
-                });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => stdin.write(SINGLE_QUOTE));
+            characters.forEach((char) => {
+                act(() => stdin.write(char));
             });
-            // Characters should not be immediately broadcast
             expect(keyHandler).not.toHaveBeenCalled();
-            // Fast-forward to completion timeout
             act(() => {
                 vi.advanceTimersByTime(DRAG_COMPLETION_TIMEOUT_MS + 10);
             });
-            // Should broadcast the collected path as paste (includes starting quote)
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: '',
                 paste: true,
-                sequence: `${SINGLE_QUOTE}path`,
+                sequence: `${SINGLE_QUOTE}${expectedText}`,
             }));
         });
     });
 });
-describe('Terminal-specific Alt+key combinations', () => {
+describe('Kitty Sequence Parsing', () => {
     let stdin;
     const mockSetRawMode = vi.fn();
-    const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: true, children: children }));
+    const wrapper = ({ children, kittyProtocolEnabled = true, }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: kittyProtocolEnabled, children: children }));
     beforeEach(() => {
         vi.clearAllMocks();
+        vi.useFakeTimers();
         stdin = new MockStdin();
         useStdin.mockReturnValue({
             stdin,
             setRawMode: mockSetRawMode,
         });
     });
-    // Terminals to test
-    const terminals = ['iTerm2', 'Ghostty', 'MacTerminal', 'VSCodeTerminal'];
-    // Key mappings: letter -> [keycode, accented character, shouldHaveMeta]
-    // Note: µ (mu) is sent with meta:false on iTerm2/VSCode
-    const keys = {
-        a: [97, 'å', true],
-        o: [111, 'ø', true],
-        m: [109, 'µ', false],
-    };
-    it.each(terminals.flatMap((terminal) => Object.entries(keys).map(([key, [keycode, accentedChar, shouldHaveMeta]]) => {
-        if (terminal === 'Ghostty') {
-            // Ghostty uses kitty protocol sequences
-            return {
-                terminal,
-                key,
-                kittySequence: `\x1b[${keycode};3u`,
-                expected: {
-                    name: key,
-                    ctrl: false,
-                    meta: true,
-                    shift: false,
-                    paste: false,
-                    kittyProtocol: true,
-                },
-            };
-        }
-        else if (terminal === 'MacTerminal') {
-            // Mac Terminal sends ESC + letter
-            return {
-                terminal,
-                key,
-                input: {
-                    sequence: `\x1b${key}`,
-                    name: key,
-                    ctrl: false,
-                    meta: true,
-                    shift: false,
-                    paste: false,
-                },
-                expected: {
-                    sequence: `\x1b${key}`,
-                    name: key,
-                    ctrl: false,
-                    meta: true,
-                    shift: false,
-                    paste: false,
-                },
-            };
-        }
-        else {
-            // iTerm2 and VSCode send accented characters (å, ø, µ)
-            // Note: µ comes with meta:false but gets converted to m with meta:true
-            return {
-                terminal,
-                key,
-                input: {
-                    name: key,
-                    ctrl: false,
-                    meta: shouldHaveMeta,
-                    shift: false,
-                    paste: false,
-                    sequence: accentedChar,
-                },
-                expected: {
-                    name: key,
-                    ctrl: false,
-                    meta: true, // Always expect meta:true after conversion
-                    shift: false,
-                    paste: false,
-                    sequence: accentedChar,
-                },
-            };
-        }
-    })))('should handle Alt+$key in $terminal', ({ kittySequence, input, expected, }) => {
-        const keyHandler = vi.fn();
-        const { result } = renderHook(() => useKeypressContext(), { wrapper });
-        act(() => result.current.subscribe(keyHandler));
-        if (kittySequence) {
-            act(() => stdin.sendKittySequence(kittySequence));
-        }
-        else if (input) {
-            act(() => stdin.pressKey(input));
-        }
-        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining(expected));
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('Cross-terminal Alt key handling (simulating macOS)', () => {
+        let originalPlatform;
+        beforeEach(() => {
+            originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', {
+                value: 'darwin',
+                configurable: true,
+            });
+        });
+        afterEach(() => {
+            Object.defineProperty(process, 'platform', {
+                value: originalPlatform,
+                configurable: true,
+            });
+        });
+        // Terminals to test
+        const terminals = ['iTerm2', 'Ghostty', 'MacTerminal', 'VSCodeTerminal'];
+        // Key mappings: letter -> [keycode, accented character]
+        const keys = {
+            b: [98, '\u222B'],
+            f: [102, '\u0192'],
+            m: [109, '\u00B5'],
+        };
+        it.each(terminals.flatMap((terminal) => Object.entries(keys).map(([key, [keycode, accentedChar]]) => {
+            if (terminal === 'Ghostty') {
+                // Ghostty uses kitty protocol sequences
+                return {
+                    terminal,
+                    key,
+                    chunk: `\x1b[${keycode};3u`,
+                    expected: {
+                        name: key,
+                        ctrl: false,
+                        meta: true,
+                        shift: false,
+                        paste: false,
+                        kittyProtocol: true,
+                    },
+                };
+            }
+            else if (terminal === 'MacTerminal') {
+                // Mac Terminal sends ESC + letter
+                return {
+                    terminal,
+                    key,
+                    kitty: false,
+                    chunk: `\x1b${key}`,
+                    expected: {
+                        sequence: `\x1b${key}`,
+                        name: key,
+                        ctrl: false,
+                        meta: true,
+                        shift: false,
+                        paste: false,
+                    },
+                };
+            }
+            else {
+                // iTerm2 and VSCode send accented characters (å, ø, µ)
+                // Note: µ (mu) is sent with meta:false on iTerm2/VSCode but
+                // gets converted to m with meta:true
+                return {
+                    terminal,
+                    key,
+                    chunk: accentedChar,
+                    expected: {
+                        name: key,
+                        ctrl: false,
+                        meta: true, // Always expect meta:true after conversion
+                        shift: false,
+                        paste: false,
+                        sequence: accentedChar,
+                    },
+                };
+            }
+        })))('should handle Alt+$key in $terminal', ({ chunk, expected, kitty = true, }) => {
+            const keyHandler = vi.fn();
+            const testWrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: kitty, children: children }));
+            const { result } = renderHook(() => useKeypressContext(), {
+                wrapper: testWrapper,
+            });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => stdin.write(chunk));
+            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining(expected));
+        });
     });
     describe('Backslash key handling', () => {
         beforeEach(() => {
@@ -773,17 +557,8 @@ describe('Terminal-specific Alt+key combinations', () => {
             vi.useRealTimers();
         });
         it('should treat backslash as a regular keystroke', () => {
-            const keyHandler = vi.fn();
-            const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => result.current.subscribe(keyHandler));
-            act(() => stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\\',
-            }));
+            const { keyHandler } = setupKeypressTest(true);
+            act(() => stdin.write('\\'));
             // Advance timers to trigger the backslash timeout
             act(() => {
                 vi.runAllTimers();
@@ -794,5 +569,349 @@ describe('Terminal-specific Alt+key combinations', () => {
             }));
         });
     });
+    it('should timeout and flush incomplete kitty sequences after 50ms', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
+        // Should not broadcast immediately
+        expect(keyHandler).not.toHaveBeenCalled();
+        // Advance time just before timeout
+        act(() => vi.advanceTimersByTime(KITTY_SEQUENCE_TIMEOUT_MS - 5));
+        // Still shouldn't broadcast
+        expect(keyHandler).not.toHaveBeenCalled();
+        // Advance past timeout
+        act(() => vi.advanceTimersByTime(10));
+        // Should now broadcast the incomplete sequence as regular input
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            name: '',
+            sequence: INCOMPLETE_KITTY_SEQUENCE,
+            paste: false,
+        }));
+    });
+    it('should immediately flush non-kitty CSI sequences', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        // Send a CSI sequence that doesn't match kitty patterns
+        // ESC[m is SGR reset, not a kitty sequence
+        act(() => stdin.write('\x1b[m'));
+        // Should broadcast immediately as it's not a valid kitty pattern
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            sequence: '\x1b[m',
+            paste: false,
+        }));
+    });
+    it('should parse valid kitty sequences immediately when complete', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        // Send complete kitty sequence for Ctrl+A
+        act(() => stdin.write('\x1b[97;5u'));
+        // Should parse and broadcast immediately
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'a',
+            ctrl: true,
+            kittyProtocol: true,
+        }));
+    });
+    it('should handle batched kitty sequences correctly', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        // Send Ctrl+a followed by Ctrl+b
+        act(() => stdin.write('\x1b[97;5u\x1b[98;5u'));
+        // Should parse both sequences
+        expect(keyHandler).toHaveBeenCalledTimes(2);
+        expect(keyHandler).toHaveBeenNthCalledWith(1, expect.objectContaining({
+            name: 'a',
+            ctrl: true,
+            kittyProtocol: true,
+        }));
+        expect(keyHandler).toHaveBeenNthCalledWith(2, expect.objectContaining({
+            name: 'b',
+            ctrl: true,
+            kittyProtocol: true,
+        }));
+    });
+    it('should clear kitty buffer and timeout on Ctrl+C', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
+        // Press Ctrl+C
+        act(() => stdin.write('\x03'));
+        // Advance past timeout
+        act(() => vi.advanceTimersByTime(KITTY_SEQUENCE_TIMEOUT_MS + 10));
+        // Should only have received Ctrl+C, not the incomplete sequence
+        expect(keyHandler).toHaveBeenCalledTimes(1);
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'c',
+            ctrl: true,
+        }));
+    });
+    it('should handle mixed valid and invalid sequences', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        // Send valid kitty sequence followed by invalid CSI
+        // Valid enter, then invalid sequence
+        act(() => stdin.write('\x1b[13u\x1b[!'));
+        // Should parse valid sequence and flush invalid immediately
+        expect(keyHandler).toHaveBeenCalledTimes(2);
+        expect(keyHandler).toHaveBeenNthCalledWith(1, expect.objectContaining({
+            name: 'return',
+            kittyProtocol: true,
+        }));
+        expect(keyHandler).toHaveBeenNthCalledWith(2, expect.objectContaining({
+            sequence: '\x1b[!',
+        }));
+    });
+    it('should not buffer sequences when kitty protocol is disabled', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), {
+            wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: false }),
+        });
+        act(() => result.current.subscribe(keyHandler));
+        // Send what would be a kitty sequence
+        act(() => stdin.write('\x1b[13u'));
+        // Should pass through without parsing
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            sequence: '\x1b[13u',
+        }));
+        expect(keyHandler).not.toHaveBeenCalledWith(expect.objectContaining({
+            name: 'return',
+            kittyProtocol: true,
+        }));
+    });
+    it('should handle sequences arriving character by character', async () => {
+        vi.useRealTimers(); // Required for correct buffering timing.
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => {
+            result.current.subscribe(keyHandler);
+        });
+        // Send kitty sequence character by character
+        const sequence = '\x1b[27u'; // Escape key
+        for (const char of sequence) {
+            act(() => {
+                stdin.emit('data', Buffer.from(char));
+            });
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        // Should parse once complete
+        await waitFor(() => {
+            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'escape',
+                kittyProtocol: true,
+            }));
+        });
+    });
+    it('should reset timeout when new input arrives', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        // Start incomplete sequence
+        act(() => stdin.write('\x1b[97;13'));
+        // Advance time partway
+        act(() => vi.advanceTimersByTime(30));
+        // Add more to sequence
+        act(() => stdin.write('5'));
+        // Advance time from the first timeout point
+        act(() => vi.advanceTimersByTime(25));
+        // Should not have timed out yet (timeout restarted)
+        expect(keyHandler).not.toHaveBeenCalled();
+        // Complete the sequence
+        act(() => stdin.write('u'));
+        // Should now parse as complete enter key
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'a',
+            kittyProtocol: true,
+        }));
+    });
+    it('should flush incomplete kitty sequence on FOCUS_IN event', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
+        // Incomplete sequence should be buffered, not broadcast
+        expect(keyHandler).not.toHaveBeenCalled();
+        // Send FOCUS_IN event
+        act(() => stdin.write('\x1b[I'));
+        // The buffered sequence should be flushed
+        expect(keyHandler).toHaveBeenCalledTimes(1);
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            name: '',
+            sequence: INCOMPLETE_KITTY_SEQUENCE,
+            paste: false,
+        }));
+    });
+    it('should flush incomplete kitty sequence on FOCUS_OUT event', async () => {
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
+        // Incomplete sequence should be buffered, not broadcast
+        expect(keyHandler).not.toHaveBeenCalled();
+        // Send FOCUS_OUT event
+        act(() => stdin.write('\x1b[O'));
+        // The buffered sequence should be flushed
+        expect(keyHandler).toHaveBeenCalledTimes(1);
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            name: '',
+            sequence: INCOMPLETE_KITTY_SEQUENCE,
+            paste: false,
+        }));
+    });
+    it('should flush incomplete kitty sequence on paste event', async () => {
+        vi.useFakeTimers();
+        const keyHandler = vi.fn();
+        const { result } = renderHook(() => useKeypressContext(), { wrapper });
+        act(() => result.current.subscribe(keyHandler));
+        act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
+        // Incomplete sequence should be buffered, not broadcast
+        expect(keyHandler).not.toHaveBeenCalled();
+        // Send paste start sequence
+        act(() => stdin.write(`\x1b[200~`));
+        // The buffered sequence should be flushed
+        expect(keyHandler).toHaveBeenCalledTimes(1);
+        expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+            name: '',
+            sequence: INCOMPLETE_KITTY_SEQUENCE,
+            paste: false,
+        }));
+        // Now send some paste content and end paste to make sure paste still works
+        const pastedText = 'hello';
+        const PASTE_MODE_SUFFIX = `\x1b[201~`;
+        act(() => {
+            stdin.write(pastedText);
+            stdin.write(PASTE_MODE_SUFFIX);
+        });
+        act(() => vi.runAllTimers());
+        // The paste event should be broadcast
+        expect(keyHandler).toHaveBeenCalledTimes(2);
+        expect(keyHandler).toHaveBeenNthCalledWith(2, expect.objectContaining({
+            paste: true,
+            sequence: pastedText,
+        }));
+        vi.useRealTimers();
+    });
+    describe('SGR Mouse Handling', () => {
+        it('should ignore SGR mouse sequences', async () => {
+            const keyHandler = vi.fn();
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            // Send various SGR mouse sequences
+            act(() => {
+                stdin.write('\x1b[<0;10;20M'); // Mouse press
+                stdin.write('\x1b[<0;10;20m'); // Mouse release
+                stdin.write('\x1b[<32;30;40M'); // Mouse drag
+                stdin.write('\x1b[<64;5;5M'); // Scroll up
+            });
+            // Should not broadcast any of these as keystrokes
+            expect(keyHandler).not.toHaveBeenCalled();
+        });
+        it('should handle mixed SGR mouse and key sequences', async () => {
+            const keyHandler = vi.fn();
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            // Send mouse event then a key press
+            act(() => {
+                stdin.write('\x1b[<0;10;20M');
+                stdin.write('a');
+            });
+            // Should only broadcast 'a'
+            expect(keyHandler).toHaveBeenCalledTimes(1);
+            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'a',
+                sequence: 'a',
+            }));
+        });
+        it('should ignore X11 mouse sequences', async () => {
+            const keyHandler = vi.fn();
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            // Send X11 mouse sequence: ESC [ M followed by 3 bytes
+            // Space is 32. 32+0=32 (button 0), 32+33=65 ('A', col 33), 32+34=66 ('B', row 34)
+            const x11Seq = '\x1b[M AB';
+            act(() => {
+                stdin.write(x11Seq);
+            });
+            // Should not broadcast as keystrokes
+            expect(keyHandler).not.toHaveBeenCalled();
+        });
+        it('should not flush slow SGR mouse sequences as garbage', async () => {
+            vi.useFakeTimers();
+            const keyHandler = vi.fn();
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            // Send start of SGR sequence
+            act(() => stdin.write('\x1b[<'));
+            // Advance time past the normal kitty timeout (50ms)
+            act(() => vi.advanceTimersByTime(KITTY_SEQUENCE_TIMEOUT_MS + 10));
+            // Send the rest
+            act(() => stdin.write('0;37;25M'));
+            // Should NOT have flushed the prefix as garbage, and should have consumed the whole thing
+            expect(keyHandler).not.toHaveBeenCalled();
+            vi.useRealTimers();
+        });
+        it('should ignore specific SGR mouse sequence sandwiched between keystrokes', async () => {
+            const keyHandler = vi.fn();
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => {
+                stdin.write('H');
+                stdin.write('\x1b[<64;96;8M');
+                stdin.write('I');
+            });
+            expect(keyHandler).toHaveBeenCalledTimes(2);
+            expect(keyHandler).toHaveBeenNthCalledWith(1, expect.objectContaining({ name: 'h', sequence: 'H', shift: true }));
+            expect(keyHandler).toHaveBeenNthCalledWith(2, expect.objectContaining({ name: 'i', sequence: 'I', shift: true }));
+        });
+    });
+    describe('Ignored Sequences', () => {
+        describe.each([true, false])('with kittyProtocolEnabled = %s', (kittyEnabled) => {
+            it.each([
+                { name: 'Focus In', sequence: '\x1b[I' },
+                { name: 'Focus Out', sequence: '\x1b[O' },
+                { name: 'SGR Mouse Release', sequence: '\u001b[<0;44;18m' },
+                { name: 'something mouse', sequence: '\u001b[<0;53;19M' },
+                { name: 'another mouse', sequence: '\u001b[<0;29;19m' },
+            ])('should ignore $name sequence', async ({ sequence }) => {
+                vi.useFakeTimers();
+                const keyHandler = vi.fn();
+                const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: kittyEnabled, children: children }));
+                const { result } = renderHook(() => useKeypressContext(), {
+                    wrapper,
+                });
+                act(() => result.current.subscribe(keyHandler));
+                for (const char of sequence) {
+                    act(() => {
+                        stdin.write(char);
+                    });
+                    await act(async () => {
+                        vi.advanceTimersByTime(0);
+                    });
+                }
+                act(() => {
+                    stdin.write('HI');
+                });
+                expect(keyHandler).toHaveBeenCalledTimes(2);
+                expect(keyHandler).toHaveBeenNthCalledWith(1, expect.objectContaining({ name: 'h', sequence: 'H', shift: true }));
+                expect(keyHandler).toHaveBeenNthCalledWith(2, expect.objectContaining({ name: 'i', sequence: 'I', shift: true }));
+                vi.useRealTimers();
+            });
+        });
+        it('should handle F12 when kittyProtocolEnabled is false', async () => {
+            const keyHandler = vi.fn();
+            const wrapper = ({ children }) => (_jsx(KeypressProvider, { kittyProtocolEnabled: false, children: children }));
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => {
+                stdin.write('\u001b[24~');
+            });
+            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({ name: 'f12', sequence: '\u001b[24~' }));
+        });
+    });
 });
 //# sourceMappingURL=KeypressContext.test.js.map