@google/gemini-cli 0.12.0-nightly.20251023.c4c0c0d1 → 0.12.0-preview.0

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

@@ -1,5 +1,6 @@
 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 { vi } from 'vitest';
 import { KeypressProvider, useKeypressContext, DRAG_COMPLETION_TIMEOUT_MS, KITTY_SEQUENCE_TIMEOUT_MS, 
 // CSI_END_O,
@@ -15,29 +16,20 @@ 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);
     }
 }
 describe('KeypressContext - Kitty Protocol', () => {
@@ -58,12 +50,10 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Send kitty protocol sequence for regular enter: ESC[13u
             act(() => {
-                stdin.sendKittySequence(`\x1b[13u`);
+                stdin.write(`\x1b[13u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'return',
@@ -78,12 +68,10 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Send kitty protocol sequence for numpad enter: ESC[57414u
             act(() => {
-                stdin.sendKittySequence(`\x1b[57414u`);
+                stdin.write(`\x1b[57414u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'return',
@@ -98,12 +86,10 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Send kitty protocol sequence for numpad enter with Shift (modifier 2): ESC[57414;2u
             act(() => {
-                stdin.sendKittySequence(`\x1b[57414;2u`);
+                stdin.write(`\x1b[57414;2u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'return',
@@ -118,13 +104,9 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            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`);
-            });
+            act(() => stdin.write(`\x1b[57414;5u`));
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'return',
                 kittyProtocol: true,
@@ -138,12 +120,10 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            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`);
+                stdin.write(`\x1b[57414;3u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'return',
@@ -158,12 +138,10 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: false }),
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // 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
@@ -179,12 +157,10 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: true }),
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Send kitty protocol sequence for escape: ESC[27u
             act(() => {
-                stdin.sendKittySequence('\x1b[27u');
+                stdin.write('\x1b[27u');
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'escape',
@@ -198,7 +174,7 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
             act(() => result.current.subscribe(keyHandler));
             act(() => {
-                stdin.sendKittySequence(`\x1b[9u`);
+                stdin.write(`\x1b[9u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'tab',
@@ -212,7 +188,7 @@ describe('KeypressContext - Kitty Protocol', () => {
             act(() => result.current.subscribe(keyHandler));
             // Modifier 2 is Shift
             act(() => {
-                stdin.sendKittySequence(`\x1b[9;2u`);
+                stdin.write(`\x1b[9;2u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'tab',
@@ -225,7 +201,7 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
             act(() => result.current.subscribe(keyHandler));
             act(() => {
-                stdin.sendKittySequence(`\x1b[127u`);
+                stdin.write(`\x1b[127u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'backspace',
@@ -239,7 +215,7 @@ describe('KeypressContext - Kitty Protocol', () => {
             act(() => result.current.subscribe(keyHandler));
             // Modifier 3 is Alt/Option
             act(() => {
-                stdin.sendKittySequence(`\x1b[127;3u`);
+                stdin.write(`\x1b[127;3u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'backspace',
@@ -253,7 +229,7 @@ describe('KeypressContext - Kitty Protocol', () => {
             act(() => result.current.subscribe(keyHandler));
             // Modifier 5 is Ctrl
             act(() => {
-                stdin.sendKittySequence(`\x1b[127;5u`);
+                stdin.write(`\x1b[127;5u`);
             });
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'backspace',
@@ -269,14 +245,14 @@ describe('KeypressContext - Kitty Protocol', () => {
             const { result } = renderHook(() => useKeypressContext(), {
                 wrapper,
             });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            act(() => result.current.subscribe(keyHandler));
             // Simulate a bracketed paste event
             act(() => {
-                stdin.sendPaste(pastedText);
+                stdin.write(PASTE_START);
+                stdin.write(pastedText);
+                stdin.write(PASTE_END);
             });
-            await waitFor(() => {
+            await vi.waitFor(() => {
                 // Expect the handler to be called exactly once for the entire paste
                 expect(keyHandler).toHaveBeenCalledTimes(1);
             });
@@ -286,6 +262,46 @@ describe('KeypressContext - Kitty Protocol', () => {
                 sequence: pastedText,
             }));
         });
+        it('should paste start code split over multiple writes', async () => {
+            const keyHandler = vi.fn();
+            const pastedText = 'pasted content';
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => {
+                // Split PASTE_START into two parts
+                stdin.write(PASTE_START.slice(0, 3));
+                stdin.write(PASTE_START.slice(3));
+                stdin.write(pastedText);
+                stdin.write(PASTE_END);
+            });
+            await vi.waitFor(() => {
+                expect(keyHandler).toHaveBeenCalledTimes(1);
+            });
+            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+                paste: true,
+                sequence: pastedText,
+            }));
+        });
+        it('should paste end code split over multiple writes', async () => {
+            const keyHandler = vi.fn();
+            const pastedText = 'pasted content';
+            const { result } = renderHook(() => useKeypressContext(), { wrapper });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => {
+                stdin.write(PASTE_START);
+                stdin.write(pastedText);
+                // Split PASTE_END into two parts
+                stdin.write(PASTE_END.slice(0, 3));
+                stdin.write(PASTE_END.slice(3));
+            });
+            await vi.waitFor(() => {
+                expect(keyHandler).toHaveBeenCalledTimes(1);
+            });
+            expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
+                paste: true,
+                sequence: pastedText,
+            }));
+        });
     });
     describe('debug keystroke logging', () => {
         let consoleLogSpy;
@@ -302,12 +318,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,13 +330,9 @@ 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');
-            });
+            act(() => stdin.write('\x1b[27u'));
             expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Kitty 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'));
@@ -333,44 +343,21 @@ 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 long sequence starting with a valid kitty prefix to trigger overflow
             const longSequence = '\x1b[1;' + '1'.repeat(100);
-            act(() => {
-                stdin.sendKittySequence(longSequence);
-            });
+            act(() => stdin.write(longSequence));
             expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Kitty 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] Kitty buffer cleared on Ctrl+C:', INCOMPLETE_KITTY_SEQUENCE);
             // Verify Ctrl+C was handled
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'c',
@@ -381,24 +368,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:', JSON.stringify(sequence));
+            expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Kitty buffer accumulating:', JSON.stringify(INCOMPLETE_KITTY_SEQUENCE));
             // Verify warning for char codes
-            expect(consoleWarnSpy).toHaveBeenCalledWith('Kitty sequence buffer has content:', JSON.stringify(sequence));
+            expect(consoleWarnSpy).toHaveBeenCalledWith('Kitty sequence buffer has content:', JSON.stringify(INCOMPLETE_KITTY_SEQUENCE));
         });
     });
     describe('Parameterized functional keys', () => {
@@ -414,6 +390,9 @@ describe('KeypressContext - Kitty Protocol', () => {
             { sequence: `\x1b[1~`, expected: { name: 'home' } },
             { sequence: `\x1b[4~`, expected: { name: 'end' } },
             { sequence: `\x1b[2~`, expected: { name: 'insert' } },
+            // 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,29 +423,17 @@ 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~`));
+            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' }));
         });
@@ -474,7 +441,7 @@ describe('KeypressContext - Kitty Protocol', () => {
             const keyHandler = vi.fn();
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
             act(() => result.current.subscribe(keyHandler));
-            act(() => stdin.sendKittySequence(`\x1b[3~\x1b[5~`));
+            act(() => stdin.write(`\x1b[3~\x1b[5~`));
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({ name: 'delete' }));
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({ name: 'pageup' }));
         });
@@ -485,15 +452,9 @@ describe('KeypressContext - Kitty Protocol', () => {
             // 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' }));
         });
@@ -519,37 +480,15 @@ describe('Drag and Drop Handling', () => {
         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,
-                });
-            });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => stdin.write(SINGLE_QUOTE));
             expect(keyHandler).not.toHaveBeenCalled();
         });
         it('should start collecting when double 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: DOUBLE_QUOTE,
-                });
-            });
+            act(() => result.current.subscribe(keyHandler));
+            act(() => stdin.write(DOUBLE_QUOTE));
             expect(keyHandler).not.toHaveBeenCalled();
         });
     });
@@ -557,31 +496,11 @@ describe('Drag and Drop Handling', () => {
         it('should collect single character inputs during drag mode', async () => {
             const keyHandler = vi.fn();
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            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,
-                });
-            });
+            act(() => stdin.write(SINGLE_QUOTE));
             // Send single character
-            act(() => {
-                stdin.pressKey({
-                    name: undefined,
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: 'a',
-                });
-            });
+            act(() => stdin.write('a'));
             // Character should not be immediately broadcast
             expect(keyHandler).not.toHaveBeenCalled();
             // Fast-forward to completion timeout
@@ -598,61 +517,14 @@ describe('Drag and Drop Handling', () => {
         it('should collect multiple characters and complete on timeout', async () => {
             const keyHandler = vi.fn();
             const { result } = renderHook(() => useKeypressContext(), { wrapper });
-            act(() => {
-                result.current.subscribe(keyHandler);
-            });
+            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,
-                });
-            });
+            act(() => stdin.write(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(() => stdin.write('p'));
+            act(() => stdin.write('a'));
+            act(() => stdin.write('t'));
+            act(() => stdin.write('h'));
             // Characters should not be immediately broadcast
             expect(keyHandler).not.toHaveBeenCalled();
             // Fast-forward to completion timeout
@@ -686,20 +558,19 @@ describe('Kitty Sequence Parsing', () => {
     });
     // 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
+    // Key mappings: letter -> [keycode, accented character]
     const keys = {
-        a: [97, 'å', true],
-        o: [111, 'ø', true],
-        m: [109, 'µ', false],
+        a: [97, 'å'],
+        o: [111, 'ø'],
+        m: [109, 'µ'],
     };
-    it.each(terminals.flatMap((terminal) => Object.entries(keys).map(([key, [keycode, accentedChar, shouldHaveMeta]]) => {
+    it.each(terminals.flatMap((terminal) => Object.entries(keys).map(([key, [keycode, accentedChar]]) => {
         if (terminal === 'Ghostty') {
             // Ghostty uses kitty protocol sequences
             return {
                 terminal,
                 key,
-                kittySequence: `\x1b[${keycode};3u`,
+                chunk: `\x1b[${keycode};3u`,
                 expected: {
                     name: key,
                     ctrl: false,
@@ -716,14 +587,7 @@ describe('Kitty Sequence Parsing', () => {
                 terminal,
                 key,
                 kitty: false,
-                input: {
-                    sequence: `\x1b${key}`,
-                    name: key,
-                    ctrl: false,
-                    meta: true,
-                    shift: false,
-                    paste: false,
-                },
+                chunk: `\x1b${key}`,
                 expected: {
                     sequence: `\x1b${key}`,
                     name: key,
@@ -736,18 +600,12 @@ describe('Kitty Sequence Parsing', () => {
         }
         else {
             // iTerm2 and VSCode send accented characters (å, ø, µ)
-            // Note: µ comes with meta:false but gets converted to m with meta:true
+            // Note: µ (mu) is sent with meta:false on iTerm2/VSCode but
+            // gets converted to m with meta:true
             return {
                 terminal,
                 key,
-                input: {
-                    name: key,
-                    ctrl: false,
-                    meta: shouldHaveMeta,
-                    shift: false,
-                    paste: false,
-                    sequence: accentedChar,
-                },
+                chunk: accentedChar,
                 expected: {
                     name: key,
                     ctrl: false,
@@ -758,19 +616,14 @@ describe('Kitty Sequence Parsing', () => {
                 },
             };
         }
-    })))('should handle Alt+$key in $terminal', ({ kittySequence, input, expected, kitty = true, }) => {
+    })))('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));
-        if (kittySequence) {
-            act(() => stdin.sendKittySequence(kittySequence));
-        }
-        else if (input) {
-            act(() => stdin.pressKey(input));
-        }
+        act(() => stdin.write(chunk));
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining(expected));
     });
     describe('Backslash key handling', () => {
@@ -784,14 +637,7 @@ describe('Kitty Sequence Parsing', () => {
             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: '\\',
-            }));
+            act(() => stdin.write('\\'));
             // Advance timers to trigger the backslash timeout
             act(() => {
                 vi.runAllTimers();
@@ -805,57 +651,30 @@ describe('Kitty Sequence Parsing', () => {
     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);
-        });
-        // Send incomplete kitty sequence
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[1;',
-            });
-        });
+        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);
-        });
+        act(() => vi.advanceTimersByTime(KITTY_SEQUENCE_TIMEOUT_MS - 5));
         // Still shouldn't broadcast
         expect(keyHandler).not.toHaveBeenCalled();
         // Advance past timeout
-        act(() => {
-            vi.advanceTimersByTime(10);
-        });
+        act(() => vi.advanceTimersByTime(10));
         // Should now broadcast the incomplete sequence as regular input
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
             name: '',
-            sequence: '\x1b[1;',
+            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);
-        });
+        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.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[m',
-            });
-        });
+        act(() => stdin.write('\x1b[m'));
         // Should broadcast immediately as it's not a valid kitty pattern
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
             name: '',
@@ -866,20 +685,9 @@ describe('Kitty Sequence Parsing', () => {
     it('should parse valid kitty sequences immediately when complete', async () => {
         const keyHandler = vi.fn();
         const { result } = renderHook(() => useKeypressContext(), { wrapper });
-        act(() => {
-            result.current.subscribe(keyHandler);
-        });
+        act(() => result.current.subscribe(keyHandler));
         // Send complete kitty sequence for Ctrl+A
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[97;5u',
-            });
-        });
+        act(() => stdin.write('\x1b[97;5u'));
         // Should parse and broadcast immediately
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
             name: 'a',
@@ -890,20 +698,9 @@ describe('Kitty Sequence Parsing', () => {
     it('should handle batched kitty sequences correctly', async () => {
         const keyHandler = vi.fn();
         const { result } = renderHook(() => useKeypressContext(), { wrapper });
-        act(() => {
-            result.current.subscribe(keyHandler);
-        });
-        // Send multiple kitty sequences at once
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[97;5u\x1b[98;5u', // Ctrl+a followed by Ctrl+b
-            });
-        });
+        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({
@@ -920,35 +717,12 @@ describe('Kitty Sequence Parsing', () => {
     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);
-        });
-        // Send incomplete kitty sequence
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[1;',
-            });
-        });
+        act(() => result.current.subscribe(keyHandler));
+        act(() => stdin.write(INCOMPLETE_KITTY_SEQUENCE));
         // Press Ctrl+C
-        act(() => {
-            stdin.pressKey({
-                name: 'c',
-                ctrl: true,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x03',
-            });
-        });
+        act(() => stdin.write('\x03'));
         // Advance past timeout
-        act(() => {
-            vi.advanceTimersByTime(KITTY_SEQUENCE_TIMEOUT_MS + 10);
-        });
+        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({
@@ -959,20 +733,10 @@ describe('Kitty Sequence Parsing', () => {
     it('should handle mixed valid and invalid sequences', async () => {
         const keyHandler = vi.fn();
         const { result } = renderHook(() => useKeypressContext(), { wrapper });
-        act(() => {
-            result.current.subscribe(keyHandler);
-        });
+        act(() => result.current.subscribe(keyHandler));
         // Send valid kitty sequence followed by invalid CSI
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[13u\x1b[!', // Valid enter, then invalid sequence
-            });
-        });
+        // 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({
@@ -989,20 +753,9 @@ describe('Kitty Sequence Parsing', () => {
         const { result } = renderHook(() => useKeypressContext(), {
             wrapper: ({ children }) => wrapper({ children, kittyProtocolEnabled: false }),
         });
-        act(() => {
-            result.current.subscribe(keyHandler);
-        });
+        act(() => result.current.subscribe(keyHandler));
         // Send what would be a kitty sequence
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[13u',
-            });
-        });
+        act(() => stdin.write('\x1b[13u'));
         // Should pass through without parsing
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
             sequence: '\x1b[13u',
@@ -1028,7 +781,7 @@ describe('Kitty Sequence Parsing', () => {
             await new Promise((resolve) => setTimeout(resolve, 0));
         }
         // Should parse once complete
-        await waitFor(() => {
+        await vi.waitFor(() => {
             expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
                 name: 'escape',
                 kittyProtocol: true,
@@ -1038,113 +791,56 @@ describe('Kitty Sequence Parsing', () => {
     it('should reset timeout when new input arrives', async () => {
         const keyHandler = vi.fn();
         const { result } = renderHook(() => useKeypressContext(), { wrapper });
-        act(() => {
-            result.current.subscribe(keyHandler);
-        });
+        act(() => result.current.subscribe(keyHandler));
         // Start incomplete sequence
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '\x1b[1',
-            });
-        });
+        act(() => stdin.write('\x1b[97;13'));
         // Advance time partway
-        act(() => {
-            vi.advanceTimersByTime(30);
-        });
+        act(() => vi.advanceTimersByTime(30));
         // Add more to sequence
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: '3',
-            });
-        });
+        act(() => stdin.write('5'));
         // Advance time from the first timeout point
-        act(() => {
-            vi.advanceTimersByTime(25);
-        });
+        act(() => vi.advanceTimersByTime(25));
         // Should not have timed out yet (timeout restarted)
         expect(keyHandler).not.toHaveBeenCalled();
         // Complete the sequence
-        act(() => {
-            stdin.pressKey({
-                name: undefined,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: 'u',
-            });
-        });
+        act(() => stdin.write('u'));
         // Should now parse as complete enter key
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
-            name: 'return',
+            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);
-        });
-        // Send incomplete kitty sequence
-        act(() => {
-            stdin.pressKey({
-                sequence: '\x1b[1;',
-            });
-        });
+        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
-        const FOCUS_IN = '\x1b[I';
-        act(() => {
-            stdin.pressKey({
-                sequence: FOCUS_IN,
-            });
-        });
+        act(() => stdin.write('\x1b[I'));
         // The buffered sequence should be flushed
         expect(keyHandler).toHaveBeenCalledTimes(1);
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
             name: '',
-            sequence: '\x1b[1;',
+            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);
-        });
-        // Send incomplete kitty sequence
-        act(() => {
-            stdin.pressKey({
-                sequence: '\x1b[1;',
-            });
-        });
+        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
-        const FOCUS_OUT = '\x1b[O';
-        act(() => {
-            stdin.pressKey({
-                sequence: FOCUS_OUT,
-            });
-        });
+        act(() => stdin.write('\x1b[O'));
         // The buffered sequence should be flushed
         expect(keyHandler).toHaveBeenCalledTimes(1);
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
             name: '',
-            sequence: '\x1b[1;',
+            sequence: INCOMPLETE_KITTY_SEQUENCE,
             paste: false,
         }));
     });
@@ -1152,39 +848,27 @@ describe('Kitty Sequence Parsing', () => {
         vi.useFakeTimers();
         const keyHandler = vi.fn();
         const { result } = renderHook(() => useKeypressContext(), { wrapper });
-        act(() => {
-            result.current.subscribe(keyHandler);
-        });
-        // Send incomplete kitty sequence
-        act(() => {
-            stdin.pressKey({
-                sequence: '\x1b[1;',
-            });
-        });
+        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
-        const PASTE_MODE_PREFIX = `\x1b[200~`;
-        act(() => {
-            stdin.emit('data', Buffer.from(PASTE_MODE_PREFIX));
-        });
+        act(() => stdin.write(`\x1b[200~`));
         // The buffered sequence should be flushed
         expect(keyHandler).toHaveBeenCalledTimes(1);
         expect(keyHandler).toHaveBeenCalledWith(expect.objectContaining({
             name: '',
-            sequence: '\x1b[1;',
+            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.emit('data', Buffer.from(pastedText));
-            stdin.emit('data', Buffer.from(PASTE_MODE_SUFFIX));
-        });
-        act(() => {
-            vi.runAllTimers();
+            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({